本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# AD Connector 入門
<a name="ad_connector_getting_started"></a>

透過 AD Connector，您可以 Directory Service 連線到現有的企業 Active Directory。連線到您的現有目錄時，您所有的目錄資料皆會保留在您的網域控制站。 Directory Service 不會複寫您任何目錄資料。

**Topics**
+ [AD Connector 事前準備](#prereq_connector)
+ [建立 AD Connector](#create_ad_connector)
+ [使用 AD Connector 建立的內容](create_details_ad_connector.md)

## AD Connector 事前準備
<a name="prereq_connector"></a>

若要使用 AD Connector 連線到現有目錄，您需要準備下列項目：

**Amazon VPC**  
進行下列 VPC 設定：  
+ 至少兩個子網路。每個子網路必須位於不同的可用區域，且必須為相同的網路類型。

  您可以針對 VPC 使用 IPv6。如需詳細資訊，請參閱《*Amazon Virtual Private Cloud 使用者指南*》中的 [VPC 的 IPv6 支援](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-migrate-ipv6.html)。
+ VPC 必須透過虛擬私有網路 (VPN) 連線或 Direct Connect連線到您的現有網路。
+ VPC 必須具有預設硬體租用。
Directory Service 使用兩個 VPC 結構。組成目錄的 EC2 執行個體會在 AWS 您的帳戶之外執行，並由 管理 AWS。其使用兩種網路轉接器，`ETH0` 和 `ETH1`。`ETH0` 是管理轉接器，而且位於您的帳戶外部。`ETH1` 則是建立於您的帳戶內部。  
目錄的 `ETH0` 網路的管理 IP 範圍以程式設計方式選擇，以確保它不會與部署目錄的 VPC 發生衝突。此 IP 範圍可以是以下任一對 (因為目錄在兩個子網路中運作)：  
+ 10.0.1.0/24 & 10.0.2.0/24 
+ 169.254.0.0/16
+ 192.168.1.0/24 & 192.168.2.0/24 
我們透過檢查 `ETH1` CIDR 的第一個八位元組來避免衝突。如果以 10 開頭，則我們選擇具有 192.168.1.0/24 和 192.168.2.0/24 子網路並且地址為 192.168.0.0/16 的 VPC。如果第一個八位元位元組不是 10，我們會選擇具有 10.0.1.0/24 和 10.0.2.0/24 子網路並且地址為 10.0.0.0/16 的 VPC。  
選取演算法不包含 VPC 上的路由。因此，這種情況可能會導致 IP 路由衝突。  
如需詳細資訊，請參閱 *Amazon VPC 使用者指南* 中的下列主題：  
+ [「什麼是 Amazon VPC？」](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Introduction.html)
+ [「您 VPC 中的子網路」](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#VPCSubnet)
+ [「將硬體虛擬私有閘道新增到您的 VPC」](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_VPN.html)
如需 的詳細資訊 AWS Direct Connect，請參閱[AWS Direct Connect 《 使用者指南》](https://docs.aws.amazon.com/directconnect/latest/UserGuide/)。

**現有的 Active Directory**  
您需要使用 Active Directory 網域連線到現有的網路。  
AD Connector 不支援[單一標籤域](https://support.microsoft.com/en-us/help/2269810/microsoft-support-for-single-label-domains)。
此 Active Directory 網域的功能層級必須`Windows Server 2003`或更高。AD Connector 也支援連線到託管於 Amazon EC2 執行個體上的域。  
當 AD Connector 與 Amazon EC2 加入域功能結合使用時，不支援唯讀域控制站 (RODC)。

**服務帳戶**  
您必須具備在現有目錄中，已委派下列權限之服務帳戶的登入資料：  
+ 讀取使用者和群組 – 必要
+ 將電腦加入域 – 只有在使用無縫域加入和 WorkSpaces 時必要
+ 建立電腦物件 – 只有在使用無縫域加入和 WorkSpaces 時必要
+ 服務帳戶密碼應符合 AWS 密碼要求。 AWS 密碼應：
  + 長度介於 8 到 128 個字元之間。
  + 至少包含以下四個類別中的三個字元：
    + 小寫字母 (a-z)
    + 大寫字母 (A-Z)
    + 數字 (0-9)
    + 非英數字元 (\~\!@\#$%^&\*\_-\+=`\|\\(){}[]:;"'<>,.?/)
如需詳細資訊，請參閱[委派權限給您的服務帳戶](#connect_delegate_privileges)。  
AD Connector 使用 Kerberos 對 AWS 應用程式進行身分驗證和授權。LDAP 僅用於使用者和群組物件查詢 (讀取操作)。對於 LDAP 交易，任何內容都不可變，並且憑證不會以明文形式傳遞。身分驗證由 AWS 內部服務處理，該服務使用 Kerberos 票證以使用者身分執行 LDAP 操作。

**使用者許可**  
所有 Active Directory 使用者必須具有讀取自己屬性的許可。特別是下列屬性：  
+ GivenName
+ SurName
+ Mail
+ SamAccountName
+ UserPrincipalName
+ UserAccountControl
+ MemberOf
在預設情況下，Active Directory 使用者具有讀取這些屬性的許可。不過，管理員可能隨時間變更這些許可，所以您在首次設定 AD Connector 前，可能需先確認您的使用者擁有這些讀取許可。

**IP 位址**  
取得您現有目錄中兩個 DNS 伺服器或網域控制器的 IP 地址。  
 當 AD Connector 連線到您的目錄時，要從這些伺服器取得 `_ldap._tcp.{{<DnsDomainName>}}` 和 `_kerberos._tcp.{{<DnsDomainName>}}` SRV 記錄，所以這些伺服器必須含有這些 SRV 記錄。AD Connector 會嘗試找到同時提供 LDAP 和 Kerberos 服務的常見域控制站，因此這些 SRV 記錄必須至少包含一個常見域控制站。如需 SRV 記錄的詳細資訊，請前往 Microsoft TechNet 上的 [SRV Resource Records](http://technet.microsoft.com/en-us/library/cc961719.aspx)。

**子網路的連接埠**  
若要讓 AD Connector 將目錄請求重新導向至現有 Active Directory 域控制站，現有網路的防火牆必須向您 Amazon VPC 中兩個子網路的 CIDR 開放下列連接埠。  
+ TCP/UDP 53 - DNS
+ TCP/UDP 88 - Kerberos 身分驗證
+ TCP/UDP 389 - LDAP
您至少需要這些連接埠，AD Connector 才可連線到您的目錄。您特定的組態可能需要開啟其他連接埠。  
如果您想要使用 AD Connector 和 Amazon WorkSpaces，則網域控制站的 DisableVLVSupportLDAP 屬性必須設定為 0。這是網域控制站的預設設定。如果啟用 DisableVLVSupportLDAP 屬性，AD Connector 將無法查詢 目錄中的使用者。這可防止 AD Connector 使用 Amazon WorkSpaces。  
如果現有 Active Directory 網域的 DNS 伺服器或網域控制器伺服器位於 VPC 內，則與這些伺服器關聯的安全群組必須向 VPC 中兩個子網路的 CIDR 開放上述連接埠。
如需其他連接埠需求，請參閱 Microsoft 文件上的 [AD 和 AD DS 連接埠需求](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/dd772723(v=ws.10))。

**Kerberos 預先驗證**  
您的使用者帳戶必須啟用 Kerberos 預先驗證。如需詳細的說明了解如何啟用此設定，請參閱 [確定已啟用 Kerberos 預先驗證](ms_ad_tutorial_setup_trust_prepare_onprem.md#tutorial_setup_trust_enable_kerberos)。如需此設定的一般資訊，請前往 Microsoft TechNet 上的[預先驗證](http://technet.microsoft.com/en-us/library/cc961961.aspx)。

**加密類型**  
AD Connector 在透過 Kerberos 對您的 Active Directory 網域控制站進行身分驗證時，支援下列加密類型：  
+ AES-256-HMAC
+ AES-128-HMAC
+ RC4-HMAC

### AWS IAM Identity Center 先決條件
<a name="prereq_aws_sso_ad_connector"></a>

如果您打算將 IAM Identity Center 與 AD Connector 搭配使用，您需要確保符合下列條件：
+ AD Connector 是在 AWS 組織的管理帳戶中設定。
+ 您的 IAM Identity Center 執行個體與 AD Connector 是在相同區域中設定。

如需詳細資訊，請參閱《 AWS IAM Identity Center 使用者指南》中的 [IAM Identity Center 先決條件](https://docs.aws.amazon.com/singlesignon/latest/userguide/prereqs.html)。

### 多重要素驗證先決條件
<a name="mfa_prereqs"></a>

若要使用 AD Connector 目錄支援多重驗證，您需要準備下列項目：
+ 您現有網路中具有兩個用戶端端點的[遠端驗證撥號使用者服務](https://en.wikipedia.org/wiki/RADIUS) (RADIUS) 伺服器。RADIUS 用戶端端點的要求如下：
  + 若要建立端點，您需要 Directory Service 伺服器的 IP 地址。這些 IP 地址可從您目錄詳細資訊的 **Directory IP Address** (目錄 IP 地址) 欄位取得。
  + 這兩個 RADIUS 端點必須使用同一個共享秘密代碼。
+ 您現有的網路必須允許來自 Directory Service 伺服器的預設 RADIUS 伺服器連接埠 (1812) 的傳入流量。
+ RADIUS 伺服器與現有目錄之間的使用者名稱必須相同。

如需搭配 MFA 使用 AD Connector 的詳細資訊，請參閱 [啟用 AD Connector 的多重驗證](ad_connector_mfa.md)。

### 委派權限給您的服務帳戶
<a name="connect_delegate_privileges"></a>

若要連線到現有目錄，您必須具備在現有目錄中，已委派特定權限之 AD Connector 服務帳戶的登入資料。雖然 **Domain Admins (網域管理員)** 群組的成員具有連線到目錄的足夠權限，但最佳實務應該使用只具有連線到目錄所需之最低權限的服務帳戶。下列程序示範如何建立名為 的新群組`Connectors`、委派 Directory Service 連線到此群組所需的必要權限，然後將新的服務帳戶新增至此群組。

此程序必須在已加入您目錄且已安裝 **Active Directory User and Computers** (Active Directory 使用者和電腦) MMC 嵌入的電腦上執行。您也必須以網域管理員的身分登入。

**委派權限給您的服務帳戶**

1. 開啟 **Active Directory User and Computers** (Active Directory 使用者和電腦)，並在導覽樹狀目錄中選取您的根網域。

1. 在左側窗格的清單中，對 **Users** (使用者) 按一下滑鼠右鍵，選取 **New** (新增)，再選取 **Group** (群組)。

1. 在 **New Object - Group** (新增物件 - 群組) 對話方塊中，輸入下列內容並按一下 **OK** (確定)。  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/zh_tw/directoryservice/latest/admin-guide/ad_connector_getting_started.html)

1. 在 **Active Directory 使用者和電腦**導覽樹狀目錄中，選取識別要建立電腦帳戶的組織單位 (OU)。在選單中，選取 **Action** (動作)，再選取 **Delegate Control** (委派控制)。您可以選取網域的父系 OU 做為許可傳播到子系 OUs。如果您的 AD Connector 連線至 AWS Managed Microsoft AD，您將無法存取在網域根層級委派控制權。在這種情況下，要委派控制，請選取將在其中建立電腦物件的目錄 OU 下的 OU。

1. 在 **Delegation of Control Wizard** (委派控制精靈) 頁面上，按一下 **Next** (下一步)，然後按一下 **Add** (新增)。

1. 在 **Select Users, Computers, or Groups** (選取使用者、電腦或群組) 對話方塊中，輸入 `Connectors`，並按一下 **OK** (確定)。如果找到多個物件，請選取在上述步驟中建立的 `Connectors` 群組。按一下 **Next (下一步)**。

1. 在 **Tasks to Delegate** (要委派的任務) 頁面上，選取 **Create a custom task to delegate** (建立要委派的自訂任務)，然後選擇 **Next** (下一步)。

1. 選取 **Only the following objects in the folder** (僅限資料夾中的下列物件)，再選取 **Computer objects** (電腦物件) 和 **User objects** (使用者物件)。

1. 選取 **Create selected objects in this folder** (在此資料夾中建立選取的物件) 和 **Delete selected objects in this folder** (在此資料夾中刪除選取的物件)。然後選擇**下一步**。  
![控制精靈委派 - 只會選取資料夾中的下列物件、使用者物件、在此資料夾中建立選取的物件，以及在此資料夾中刪除選取的物件選項。](http://docs.aws.amazon.com/zh_tw/directoryservice/latest/admin-guide/images/aduc_delegate_join_linux.png)

1. 選取 **Read (讀取)**，然後選擇 **Next (下一步)**。
**注意**  
如果您將使用無縫域加入或 WorkSpaces，您也必須啟用**寫入**權限，以讓 Active Directory 建立電腦物件。  
![控制精靈委派 - 在顯示這些許可下，已選取一般、屬性特定和讀取。](http://docs.aws.amazon.com/zh_tw/directoryservice/latest/admin-guide/images/aduc_delegate_join_permissions.png)

1. 驗證 **Completing the Delegation of Control Wizard** (完成委派控制精靈) 頁面中的資訊，然後按一下 **Finish** (完成)。

1. 建立使用高強度密碼的使用者帳戶，並將此使用者新增至 `Connectors` 群組。此使用者將稱為 AD Connector 服務帳戶，由於現在是 `Connectors`群組的成員，因此現在有足夠的權限 Directory Service 可連線至 目錄。

### 測試您的 AD Connector
<a name="connect_verification"></a>

若要讓 AD Connector 連線至您的現有目錄，現有網路的防火牆必須向 VPC 中兩個子網路的 CIDR 開放特定連接埠。若要測試是否符合這些條件，請執行下列步驟：

**測試連線**

1. 在 VPC 中啟動 Windows 執行個體，並透過 RDP 與其連線。該執行個體必須為您現有網域的成員。其餘步驟皆在此 VPC 執行個體上執行。

1. 下載並解壓縮 [DirectoryServicePortTest](samples/DirectoryServicePortTest.zip) 測試應用程式。其中已包含來源碼與 Visual Studio 專案檔案，您可視需要修改測試應用程式。
**注意**  
Windows Server 2003 或較舊的作業系統不支援此指令碼。

1. 在 Windows 命令提示下，運用下列選項執行 **DirectoryServicePortTest** 測試應用程式：
**注意**  
只在網域和樹系功能層級設定為 Windows Server 2012 R2 和以下時，才能使用 DirectoryServicePortTest 測試應用程式。

   ```
   DirectoryServicePortTest.exe -d {{<domain_name>}} -ip {{<server_IP_address>}} -tcp "53,88,389" -udp "53,88,389"
   ```  
{{<domain\_name>}}  
完全合格的網域名稱。這用於測試森林和網域功能層級。如果您排除網域名稱，就不會測試功能層級。  
{{<server\_IP\_address>}}  
現有網域中網域控制器的 IP 地址。將針對此 IP 地址測試連接埠。如果您排除 IP 地址，就不會測試連接埠。

   此測試應用程式會判斷 VPC 連線至您網域的必要連接埠是否開放，以及驗證最低的森林和網域功能層級。

   輸出會類似下列內容：

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

下列是 **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;
        }
    }
}
```

## 建立 AD Connector
<a name="create_ad_connector"></a>

若要使用 AD Connector 連線到您的現有目錄，請執行下列步驟。開始此程序之前，請確定您已完成 [AD Connector 事前準備](#prereq_connector) 中所示的必要條件。

**注意**  
您無法使用 Cloud Formation 範本建立 AD Connector。

**使用 AD Connector 連線**

1. 在 [AWS Directory Service 主控台](https://console.aws.amazon.com/directoryservicev2/)中，選擇**目錄**，然後選擇**設定目錄**。

1. 在**選取目錄類型** 頁面上，選擇 **AD Connector**，然後選擇**下一步**。

1. 在 **Enter AD Connector information (輸入 AD Connector 資訊)** 頁面上，提供下列資訊：  
**Directory size (目錄大小)**  
選擇 **Small (小型)** 或 **Large (大型)** 尺寸選項。如需尺寸的詳細資訊，請參閱 [AD Connector](directory_ad_connector.md)。  
**目錄描述**  
選擇填寫其他目錄說明。

1. 在 **Choose VPC and subnets (選擇 VPC 和子網路)** 頁面上，提供下列資訊，然後選擇 **Next (下一步)**。  
**VPC**  
目錄的 VPC。  
**子網路**  
選擇網域控制站的子網路。這兩個子網路必須位於不同的可用區域。

1. 在 **Connect to AD (連結到 AD)** 頁面上，提供下列資訊：  
**目錄 DNS 名稱**  
現有目錄的完整名稱，例如 `corp.example.com`。  
**目錄 NetBIOS 名稱**  
您現有目錄的簡稱，例如 `CORP`。  
**DNS IP 地址**  
您現有目錄中至少一個 DNS 伺服器的 IP 地址。這些伺服器皆必須可從步驟 4 指定的各子網路存取。只要指定的子網路和 DNS 伺服器 IP 地址之間有網路連線 AWS，這些伺服器就可以位於 外部。  
**服務帳戶使用名稱**  
現有目錄中使用者的使用者名稱。如需此帳戶的詳細資訊，請參閱「[AD Connector 事前準備](#prereq_connector)」。  
**服務帳戶密碼**  
現有使用者帳戶的密碼。密碼區分大小寫，長度須介於 8 至 128 個字元 (含) 之間。至少須有一位字元屬於以下四種類型中的三類：  
   + 小寫字母 (a-z)
   + 大寫字母 (A-Z)
   + 數字 (0-9)
   + 非英數字元 (\~\!@\#$%^&\*\_-\+=`\|\\(){}[]:;"'<>,.?/)  
**Confirm password** (確認密碼)  
重新輸入現有使用者帳戶的密碼。

1. 在 **Review & create (檢閱和建立)** 頁面上檢閱目錄資訊，並進行必要的變更。若資訊無誤，請選擇 **Create directory (建立目錄)**。建立目錄需要幾分鐘的時間。建立後，**Status** (狀態) 值會變更為 **Active** (作用中)。

如需使用 AD Connector 建立之項目的詳細資訊，請參閱 [使用 AD Connector 建立的內容](create_details_ad_connector.md)。