Pré-requisitos do AD Connector - AWS Directory Service

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Pré-requisitos do AD Connector

Para conectar-se ao seu diretório existente com o AD Connector, você precisa do seguinte:

VPC

Configure uma VPC com o seguinte:

  • Pelo menos duas sub-redes. Cada uma das sub-redes deve estar em uma zona de disponibilidade diferente.

  • A VPC deve estar conectada à sua rede existente por meio de uma conexão de rede privada virtual (VPN) ou AWS Direct Connect.

  • A VPC deve ter uma locação de hardware padrão.

O AWS Directory Service usa uma estrutura de duas VPCs. As instâncias do EC2 que compõem seu diretório são executadas fora da sua conta da AWS e são gerenciadas pela AWS. Elas têm dois adaptadores de rede, ETH0 e ETH1. O ETH0 é o adaptador de gerenciamento e existe fora da sua conta. O ETH1 é criado dentro da sua conta.

O intervalo de IPs de gerenciamento da rede ETH0 do seu diretório é escolhido de forma programática para garantir que não entre em conflito com a VPC onde o diretório está implantado. Esse intervalo de IPs pode estar em um dos seguintes pares (como Diretórios são executados em duas sub-redes):

  • 10.0.1.0/24 e 10.0.2.0/24

  • 192.168.1.0/24 e 192.168.2.0/24

Evitamos conflitos verificando o primeiro octeto do CIDR ETH1. Se ele começar com 10, escolheremos uma VPC 192.168.0.0/16 com sub-redes 192.168.1.0/24 e 192.168.2.0/24. Se o primeiro octeto for diferente de 10, escolheremos uma VPC 10.0.0.0/16 com sub-redes 10.0.1.0/24 e 10.0.2.0/24.

O algoritmo de seleção não inclui rotas na VPC. Portanto, é possível ter um conflito de roteamento de IP resultante desse cenário.

Para obter mais informações, consulte os tópicos a seguir no Guia do usuário da Amazon VPC:

Para obter mais informações sobre o AWS Direct Connect, consulte o Guia do usuário do AWS Direct Connect.

Active Directory existente

Será necessário se conectar a uma rede existente com um domínio do Active Directory.

nota

O AD Connector não oferece suporte à confiança com Domínios de Rótulo Único.

O nível funcional desse domínio deve ser Windows Server 2003 ou posterior. O AD Connector também oferece suporte à conexão a um domínio hospedado em uma instância do Amazon EC2.

nota

O AD Connector não oferece suporte a controladores de domínio somente leitura (RODC, read-only domain controllers) quando usados em combinação com o recurso de união de domínio do Amazon EC2.

Conta de serviço

Você deve ter credenciais para uma conta de serviço no diretório existente delegada com os privilégios a seguir:

  • Ler os usuários e grupos — Obrigatório

  • Ingressar computadores no domínio – necessário somente ao usar o ingresso transparente em domínios e o Amazon WorkSpaces

  • Criar objetos de computador — Obrigatório somente ao usar associação de domínio integrada e o Amazon WorkSpaces

Para obter mais informações, consulte Delegar privilégios para sua conta de serviço.

Permissões de usuário

Todos os usuários do Active Directory devem ter permissões para ler seus próprios atributos. Especificamente os seguintes atributos:

  • GivenName

  • SurName

  • Mail

  • SamAccountName

  • UserPrincipalName

  • UserAccountControl

  • MemberOf

Por padrão, os usuários do Active Directory têm permissão de leitura para esses atributos. No entanto, os administradores podem alterar essas permissões ao longo do tempo, de modo que você pode verificar se seus usuários têm essas permissões de leitura antes de configurar o AD Connector pela primeira vez.

Endereços IP

Obtenha os endereços IP de dois servidores DNS ou controladores de domínio no seu diretório existente.

AD ConnectorO obtém os registros SRV _ldap._tcp.<DnsDomainName> e _kerberos._tcp.<DnsDomainName> desses servidores ao se conectar ao seu diretório, de forma que esses servidores devem conter esses registros de SRV. O AD Connector tenta encontrar um controlador comum de domínio que fornece serviços de LDAP e Kerberos; portanto, esses registros SRV devem incluir pelo menos um controlador de domínio em comum. Para mais informações sobre os registos SRV, vá a Registos de recursos SRV na Microsoft TechNet.

Portas para sub-redes

para AD Connector para redirecionar pedidos de diretórios para os controladores de domínio existentes no Diretório Ativo, a firewall para a sua rede existente deve ter as seguintes portas abertas para o CIDRs para ambas as sub-redes no seu Amazon VPC.

  • TCP/UDP 53 — DNS

  • TCP/UDP 88 - autenticação de Kerberos

  • TCP/UDP 389 - LDAP

Essas são as portas mínimas necessárias para que o AD Connector possa conectar-se ao seu diretório. Sua configuração específica pode exigir que portas adicionais sejam abertas.

nota

Se os servidores DNS ou servidores do Controlador de Domínio para o seu Domínio do Active Directory existente estiverem no VPC, os grupos de segurança associados a esses servidores devem ter as portas acima abertas para o CIDRs para ambas as sub-redes no VPC.

Para requisitos de portas adicionais, consulte Requisitos de portas AD e AD DS na Microsoft TechNet.

Pré-autenticação do Kerberos

Suas contas de usuário devem ter a pré-autenticação Kerberos habilitada. Para obter instruções detalhadas sobre como habilitar essa configuração, consulte Verificar se a pré-autenticação Kerberos está habilitada. Para obter informações gerais sobre esta definição, aceda a Pré-autenticação na Microsoft TechNet.

Tipos de criptografia

O AD Connector é compatível com os seguintes tipos de criptografia ao fazer a autenticação via Kerberos em seus controladores de domínio do Active Directory:

  • AES-256-HMAC

  • AES-128-HMAC

  • RC4-HMAC

Pré-requisitos do Logon único da AWS

Se você planeja usar o Logon único da AWS (AWS SSO) com o AD Connector, é necessário garantir que o seguinte seja verdadeiro:

  • Seu AD Connector está configurado no seu AWS organização conta de gerenciamento.

  • A instância do AWS SSO está na mesma região onde o AD Connector está configurado.

Para obter mais informações, consulte Pré-requisitos do AWS SSO no Guia do usuário do Logon único da AWS.

Pré-requisitos da autenticação multifator

Para oferecer suporte à autenticação multifator com o seu diretório AD Connector, é necessário o seguinte:

  • Um servidor Remote Authentication Dial-In User Service (RADIUS) na sua rede existente que tenha dois endpoints clientes. Os endpoints clientes do RADIUS têm os seguintes requisitos:

    • Para criar os endpoints, são necessários os endereços IP dos servidores do AWS Directory Service. Esses endereços IP podem ser obtidos no campo Directory IP Address dos detalhes do seu diretório.

    • Ambos os endpoints do RADIUS devem usar o mesmo código secreto compartilhado.

  • Sua rede existente deve permitir tráfego de entrada pela porta do servidor RADIUS padrão (1812) dos servidores do AWS Directory Service.

  • Os nomes de usuário entre o servidor RADIUS e o diretório existente devem ser idênticos.

Para obter mais informações sobre como usar o AD Connector com o MFA, consulte Habilitar a autenticação multifator para o AD Connector.

Delegar privilégios para sua conta de serviço

Para conectar-se ao seu diretório existente, você deve ter as credenciais para sua conta de serviço do AD Connector no diretório existente delegada com determinados privilégios. Embora os membros do grupo Domain Admins (Administradores do domínio) tenham privilégios suficientes para se conectar ao diretório, como uma melhor prática, use uma conta de serviço que tenha apenas os privilégios mínimos necessários para conectar-se ao diretório. O procedimento a seguir demonstra como criar um novo grupo chamado Connectors, delegar os privilégios necessários para conectar o AWS Directory Service a esse grupo e adicionar uma nova conta de serviço a ele.

Este procedimento deve ser executado em uma máquina que esteja integrada ao seu diretório e tenha o snap-in do MMC Active Directory User and Computers (Usuário e computadores do Active Directory) instalado. Você também deve estar conectado como administrador de domínio.

Para delegar privilégios para sua conta de serviço

  1. Abra Active Directory User and Computers (Usuário e computadores do Active Directory) e selecione a raiz do domínio na árvore de navegação.

  2. Na lista no painel de trabalho à esquerda, clique com o botão direito do mouse sobre Users, selecione New e selecione Group.

  3. Na caixa de diálogo New Object - Group, digite o que está a seguir e clique em OK.

    Campo Valor/Seleção
    Group name Connectors
    Escopo do grupo Global
    Tipo de grupo Segurança
  4. Na árvore de navegação de Active Directory User and Computers (Usuário e computadores do Active Directory), selecione a raiz do seu domínio. No menu, selecione Action e Delegate Control. Se o seu AD Connector está ligado a AWS Managed Microsoft AD, não terá acesso ao controlo de delegados ao nível de raiz do domínio. Neste caso, para delegar o controlo, selecione a UO no seu diretório OU onde serão criados objetos informáticos.

  5. Na página Delegation of Control Wizard, clique em Next e em Add.

  6. Na caixa de diálogo Select Users, Computers, or Groups (Selecionar usuários, computadores ou grupos), digite Connectors e clique em OK. Se mais de um objeto for encontrado, selecione o grupo Connectors criado acima. Clique em Next (Próximo).

  7. Na página Tasks to Delegate, selecione Create a custom task to delegate e escolha Next.

  8. Selecione Only the following objects in the folder e selecione Computer objects e User objects.

  9. Selecione Create selected objects in this folder e Delete selected objects in this folder. Depois, escolha Next (Próximo).

    
                            Tipo de objeto
  10. Selecione Read (Ler) e depois escolha Next (Próximo).

    nota

    Se for usar a associação de domínio integrada ou o Amazon WorkSpaces, você também deverá habilitar as permissões Write (Gravar) para que AWS Managed Microsoft AD possa criar objetos de computador.

    
                            Tipo de objeto
  11. Verifique as informações da página Completing the Delegation of Control Wizard e clique em Finish.

  12. Crie uma conta de usuário com uma senha forte e adicione o usuário ao grupo Connectors. Esse usuário será conhecido como a conta de serviço do AD Connector e, já que agora é um membro do grupo Connectors, terá privilégios suficientes para conectar o AWS Directory Service ao diretório.

Testar o AD Connector

para AD Connector para se conectar ao seu diretório existente, a firewall para a sua rede existente deve ter determinadas portas abertas para o CIDRs para ambas as sub-redes no VPC. Para testar se essas condições são atendidas, execute as etapas a seguir:

Para testar a conexão com a

  1. Inicie uma instância do Windows na VPC e conecte-se a ela por RDP. A instância deve ser membro do seu domínio existente. As etapas restantes são executadas nesta instância da VPC.

  2. Descarregar e descompactar a DirectoryServicePortTest aplicação de teste. O código-fonte e os arquivos de projeto do Visual Studio são incluídos para que você possa modificar o aplicativo de teste, se desejar.

    nota

    Este script não tem suporte no Windows Server 2003 nem em um sistemas operacionais mais antigos.

  3. Pelo prompt de comando do Windows, execute a aplicativo de teste DirectoryServicePortTest com as seguintes opções:

    nota

    lá estão DirectoryServicePortTest a aplicação de teste só pode ser utilizada quando os níveis funcionais de domínio e floresta estiverem definidos para Windows Server 2012 R2 e abaixo de.

    DirectoryServicePortTest.exe -d <domain_name> -ip <server_IP_address> -tcp "53,88,389" -udp "53,88,389"
    <domain_name>

    O nome de domínio totalmente qualificado. Ele é usado para testar os níveis funcionais de floresta e domínio. Se você excluir o nome do domínio, os níveis funcionais não serão testados.

    <server_IP_address>

    O endereço IP de um controlador de domínio no seu domínio existente. As portas serão testadas com relação a esse endereço IP. Se você excluir o endereço IP, as portas não serão testadas.

    Este aplicativo de testes determina se as portas necessárias estão abertas na VPC para seu domínio e também verifica os níveis funcionais mínimos de floresta e domínio.

    A saída será semelhante ao seguinte:

    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

O seguinte é o código-fonte do aplicativo DirectoryServicePortTest.

/* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. This file is licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at http://aws.amazon.com/apache2.0/ This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ 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; } } }