Implantar uma floresta do Active Directory no Compute Engine

Last reviewed 2023-05-10 UTC

Este documento descreve como implantar uma floresta do Active Directory no Compute Engine de uma maneira que siga as práticas recomendadas descritas em Práticas recomendadas para executar o Active Directory no Google Cloud.

Este guia é destinado a administradores e engenheiros de DevOps. Ele pressupõe que você tenha uma compreensão sólida sobre o Active Directory e conhecimento básico de segurança e rede do Google Cloud.

Arquitetura

A implantação consiste em dois projetos:

Um projeto host que contém uma rede de VPC compartilhada, uma zona de encaminhamento de DNS particular e regras de firewall para o Active Directory.
Um projeto de serviço que contém dois controladores de domínio implantados em duas zonas.

Essa arquitetura permite:

Implantar cargas de trabalho adicionais do Windows em projetos separados e permitir que eles usem a rede VPC compartilhada e a floresta do Active Directory.
Integrar a floresta do Active Directory a uma floresta local para implementar o padrão da floresta de recursos.

Antes de começar

Para seguir as instruções deste guia, verifique se você tem o seguinte:

Intervalos CIDR de sub-rede para duas sub-redes:
- Sub-rede de controladores do domínio: Essa sub-rede contém os controladores do domínio. O uso de uma sub-rede dedicada para controladores de domínio ajuda a distinguir o tráfego do controlador do domínio do tráfego de servidor ao gerenciar regras de firewall ou analisar registros de rede.
  
  Recomendamos um intervalo CIDR de sub-rede de tamanho /28 ou /29.
- Sub-rede do recurso. Essa sub-rede contém servidores e estações de trabalho administrativas. Use um intervalo CIDR de sub-rede grande o suficiente para acomodar todos os servidores que planeja implantar.
Verifique se as sub-redes não sobrepõem nenhuma sub-rede local e deixam espaço suficiente para o crescimento.
Um nome de domínio DNS e um nome de domínio NetBIOS para o domínio raiz da floresta do Active Directory. Para mais informações sobre como escolher um nome, consulte as convenções de nomenclatura da Microsoft.

Implantar uma rede compartilhada

Nesta seção, você criará um novo projeto e o usará para implantar uma rede VPC compartilhada. Posteriormente, você usará essa rede para implantar os controladores do domínio do Active Directory.

Criar um projeto

Agora você criará um projeto e o usará para implantar uma rede VPC compartilhada.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Compute Engine and Cloud DNS.
Ative as APIs

Para receber as permissões necessárias para implantar uma rede compartilhada, solicite ao administrador os seguintes papéis do IAM na pasta principal ou projeto:

Administrador de rede do Compute (roles/compute.networkAdmin)
Administrador de segurança do Compute (roles/compute.securityAdmin)
Administrador de VPC compartilhada do Compute (roles/compute.xpnAdmin)
Administrador do DNS (roles/dns.admin)

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Excluir a VPC padrão

Por padrão, o Compute Engine cria uma rede padrão em cada novo projeto criado. Essa rede é configurada no modo automático, o que significa que uma sub-rede é pré-alocada para cada região e recebe automaticamente um intervalo CIDR.

Nesta seção, você substituirá essa rede VPC por uma rede de modo personalizado que contém duas sub-redes e que usa intervalos CIDR personalizados.

No console do Google Cloud, abra o Cloud Shell.

Ative o Cloud Shell
Inicie o PowerShell:
```
pwsh
```
Configure a CLI gcloud para usar o novo projeto:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo ID do seu projeto.

Exclua todas as regras de firewall associadas à VPC padrão:

$ProjectId = gcloud config get-value core/project
& gcloud compute firewall-rules list `
  --filter "network=default" `
  --format "value(name)" |
  % { gcloud compute firewall-rules delete --quiet $_ --project $ProjectId }

Exclua a VPC padrão:

& gcloud compute networks list --format "value(name)" |
  % { gcloud compute networks delete $_ --quiet }

Criar uma rede VPC de modo personalizado

Agora você criará uma rede VPC de modo personalizado no projeto host da VPC.

No PowerShell, inicialize as seguintes variáveis:
```
$VpcName = "VPC_NAME"
$Region = "REGION"
$SubnetRangeDomainControllers = "DC_CIDR"
$SubnetRangeResources = "RESOURCES_CIDR"
```
Substitua:
- VPC_NAME: o nome da VPC.
- REGION: a região onde implantar os controladores do domínio do Active Directory.
- DC_CIDR: o intervalo de sub-rede a ser usado para a sub-rede dos controladores do domínio.
- RESOURCES_CIDR: o intervalo de sub-redes a ser usado para a sub-rede de recursos.
Exemplo:
```
$VpcName = "ad"
$Region = "us-central1"
$SubnetRangeDomainControllers = "10.0.0.0/28"
$SubnetRangeResources = "10.0.1.0/24"
```

Crie a VPC e a configure para ser usada como uma rede VPC compartilhada:

$ProjectId = gcloud config get-value core/project
& gcloud compute networks create $VpcName --subnet-mode custom
& gcloud compute shared-vpc enable $ProjectId

Crie as sub-redes e ative o Acesso privado do Google para que o Windows possa ser ativado sem acesso à Internet.

& gcloud compute networks subnets create domain-controllers `
  --network $VpcName `
  --range $SubnetRangeDomainControllers `
  --region $Region `
  --enable-private-ip-google-access

& gcloud compute networks subnets create resources `
  --network $VpcName `
  --range $SubnetRangeResources `
  --region $Region `
  --enable-private-ip-google-access

Implantar sub-redes e regras de firewall

Agora você pode criar regras de firewall para permitir a comunicação do Active Directory na VPC.

Permita conexões RDP para todas as instâncias de VM pelo encaminhamento de TCP do IAP do Cloud:

& gcloud compute firewall-rules create allow-rdp-ingress-from-iap `
  --direction INGRESS `
  --action allow `
  --rules tcp:3389 `
  --enable-logging `
  --source-ranges 35.235.240.0/20 `
  --network $VpcName `
  --priority 10000

Permitir consultas DNS do Cloud DNS aos controladores do domínio.

& gcloud compute firewall-rules create allow-dns-ingress-from-clouddns `
  --direction INGRESS `
  --action=allow `
  --rules udp:53,tcp:53 `
  --enable-logging `
  --source-ranges 35.199.192.0/19 `
  --target-tags ad-domaincontroller `
  --network $VpcName `
  --priority 10000

Essa regra de firewall é necessária para que a zona de encaminhamento de DNS particular funcione.

Permita a replicação do Active Directory entre controladores do domínio:

& gcloud compute firewall-rules create allow-replication-between-addc `
  --direction INGRESS `
  --action allow `
  --rules "icmp,tcp:53,udp:53,tcp:88,udp:88,udp:123,tcp:135,tcp:389,udp:389,tcp:445,udp:445,tcp:49152-65535" `
  --enable-logging `
  --source-tags ad-domaincontroller `
  --target-tags ad-domaincontroller `
  --network $VpcName `
  --priority 10000

Permita logons do Active Directory de VMs que estão na sub-rede de recursos para controladores do domínio:

& gcloud compute firewall-rules create allow-logon-ingress-to-addc `
  --direction INGRESS `
  --action allow `
  --rules "icmp,tcp:53,udp:53,tcp:88,udp:88,udp:123,tcp:135,tcp:389,udp:389,tcp:445,udp:445,tcp:464,udp:464,tcp:3268,udp:3268,tcp:9389,tcp:49152-65535" `
  --enable-logging `
  --source-ranges $SubnetRangeResources `
  --target-tags ad-domaincontroller `
  --network $VpcName `
  --priority 10000

Se você planeja configurar o LDAP seguro, permita conexões LDAP seguras das VMs que estão na sub-rede de recursos para controladores do domínio:

& gcloud compute firewall-rules create allow-ldaps-ingress-to-addc `
  --direction INGRESS `
  --action allow `
  --rules tcp:636 `
  --enable-logging `
  --source-ranges $SubnetRangeResources `
  --target-tags ad-domaincontroller `
  --network $VpcName `
  --priority 10000

Você só precisará dessa regra de firewall se planeja configurar o LDAP seguro.

(Opcional) Crie uma regra de firewall que registre todas as tentativas de acesso com erro. Os registros podem ser úteis para diagnosticar problemas de conectividade, mas podem produzir um volume significativo de dados de registro.

& gcloud compute firewall-rules create deny-ingress-from-all `
  --direction INGRESS `
  --action deny `
  --rules tcp:0-65535,udp:0-65535 `
  --enable-logging `
  --source-ranges 0.0.0.0/0 `
  --network $VpcName `
  --priority 65000

Implantar a floresta do Active Directory

Nesta seção, você criará um novo projeto de serviço e o anexará ao projeto host da VPC compartilhada criado anteriormente. Em seguida, use o projeto de serviço para implantar uma nova floresta do Active Directory com dois controladores do domínio.

Criar um projeto

Agora você pode criar um projeto e usá-lo para implantar as VMs do controlador do domínio do Active Directory.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Compute Engine and Secret Manager.
Ative as APIs

Para ter as permissões necessárias para implantar a floresta do Active Directory, solicite ao administrador os seguintes papéis do IAM no projeto:

administrador de instâncias do Compute(v1) (roles/compute.instanceAdmin.v1)
Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Usuário da conta de serviço (roles/iam.serviceAccountUser)
Administrador do Secret Manager (roles/secretmanager.admin)
Usuário do túnel protegido pelo IAP (roles/iap.tunnelResourceAccessor)

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Preparar a configuração

A próxima etapa é preparar a configuração para a implantação do Active Directory.

Se você tiver fechado a sessão do PowerShell, abra o Cloud Shell.

Ative o Cloud Shell
Inicie o PowerShell:
```
pwsh
```
Configure a CLI gcloud para usar o novo projeto:
```
gcloud config set project DC_PROJECT_ID
```
Substitua DC_PROJECT_ID pelo ID do seu projeto.
Use o PowerShell para criar as seguintes variáveis:
```
$AdDnsDomain = "DNS_DOMAIN"
$AdNetbiosDomain = "NETBIOS_DOMAIN"
$VpcProjectId = "VPCHOST_PROJECT_ID"
$VpcName = "VPC_NAME"
$Region = "REGION"
$Zones = "REGION-a", "REGION-b"
```
Substitua:
- DNS_DOMAIN: o nome de domínio raiz da floresta do Active Directory, por exemplo, cloud.example.com.
- NETBIOS_DOMAIN: o nome do domínio NetBIOS do domínio raiz da floresta, por exemplo, CLOUD.
- VPCHOST_PROJECT_ID: o ID do projeto host da VPC criado anteriormente.
- VPC_NAME: o nome da rede VPC compartilhada criada anteriormente.
- REGION: a região em que os controladores do domínio do Active Directory serão implantados. Observe que os nomes das zonas são baseados nos nomes da região que você especificar. Você pode estender a VPC e seu domínio para cobrir regiões adicionais a qualquer momento.
Exemplo:
```
$AdDnsDomain = "cloud.example.com"
$AdNetbiosDomain = "CLOUD"
$VpcProjectId = "vpc-project-123"
$VpcName = "ad"
$Region = "us-west1"
$Zones = "us-west1-a", "us-west1-b"
```

Criar uma zona de encaminhamento de DNS particular

Agora reserve dois endereços IP estáticos para os controladores do domínio e crie uma zona de encaminhamento de DNS particular que encaminhará todas as consultas DNS do domínio do Active Directory para esses endereços IP.

Anexe o projeto à rede VPC compartilhada:

$ProjectId = gcloud config get-value core/project
& gcloud compute shared-vpc associated-projects add $ProjectId --host-project $VpcProjectId

Reserve dois endereços IP internos estáticos na sub-rede dos controladores do domínio:

$AddressOfDc1 = gcloud compute addresses create dc-1 `
  --region $Region `
  --subnet "projects/$VpcProjectId/regions/$Region/subnetworks/domain-controllers" `
  --format value`(address`)
$AddressOfDc2 = gcloud compute addresses create dc-2 `
  --region $Region `
  --subnet "projects/$VpcProjectId/regions/$Region/subnetworks/domain-controllers" `
  --format value`(address`)

Crie uma zona de encaminhamento particular do Cloud DNS no projeto host da VPC e configure a zona para encaminhar consultas DNS aos dois endereços IP reservados:

& gcloud dns managed-zones create $AdDnsDomain.Replace(".", "-") `
  --project $VpcProjectId `
  --dns-name $AdDnsDomain `
  --description "Active Directory forwarding zone" `
  --networks $VpcName `
  --visibility private `
  --forwarding-targets "$AddressOfDc1,$AddressOfDc2"

Criar uma senha de DSRM

Agora defina a senha do Directory Service Restore Mode (DSRM) e armazene-a no Secret Manager. Em seguida, conceda às VMs do controlador do domínio acesso temporário a esse secret para que elas possam usá-lo a fim de implantar a floresta do Active Directory.

Gere uma senha aleatória e armazene em um secret do Secret Manager:

# Generate a random password.
$DsrmPassword = [Guid]::NewGuid().ToString()+"-"+[Guid]::NewGuid().ToString()

$TempFile = New-TemporaryFile
Set-Content $TempFile "$DsrmPassword" -NoNewLine
& gcloud secrets create ad-password --data-file $TempFile
Remove-Item $TempFile

Crie a conta de serviço para as instâncias de VM do controlador do domínio:

$DcServiceAccount = gcloud iam service-accounts create ad-domaincontroller `
  --display-name "AD Domain Controller" `
  --format "value(email)"

Conceda permissão à conta de serviço para ler o secret pela próxima hora:

$Expiry = [DateTime]::UtcNow.AddHours(1).ToString("o")
& gcloud secrets add-iam-policy-binding ad-password `
  --member=serviceAccount:$($DcServiceAccount) `
  --role=roles/secretmanager.secretAccessor `
  --condition="title=Expires after 1h,expression=request.time < timestamp('$Expiry')"

Implantar controladores do domínio

Agora você implantará duas instâncias de VM e criará uma floresta e um domínio do Active Directory. Para minimizar o número de etapas manuais, use os scripts de inicialização.

No PowerShell, execute o seguinte comando para gerar um script de inicialização:

'
$ErrorActionPreference = "Stop"

#
# Only run the script if the VM is not a domain controller already.
#
if ((Get-CimInstance -ClassName Win32_OperatingSystem).ProductType -eq 2) {
    exit
}

#
# Read configuration from metadata.
#
Import-Module "${Env:ProgramFiles}\Google\Compute Engine\sysprep\gce_base.psm1"

$ActiveDirectoryDnsDomain     = Get-MetaData -Property "attributes/ActiveDirectoryDnsDomain" -instance_only
$ActiveDirectoryNetbiosDomain = Get-MetaData -Property "attributes/ActiveDirectoryNetbiosDomain" -instance_only
$ActiveDirectoryFirstDc       = Get-MetaData -Property "attributes/ActiveDirectoryFirstDc" -instance_only
$ProjectId                    = Get-MetaData -Property "project-id" -project_only
$Hostname                     = Get-MetaData -Property "hostname" -instance_only
$AccessToken                  = (Get-MetaData -Property "service-accounts/default/token" | ConvertFrom-Json).access_token

#
# Read the DSRM password from secret manager.
#
$Secret = (Invoke-RestMethod `
    -Headers @{
        "Metadata-Flavor" = "Google";
        "x-goog-user-project" = $ProjectId;
        "Authorization" = "Bearer $AccessToken"} `
    -Uri "https://secretmanager.googleapis.com/v1/projects/$ProjectId/secrets/ad-password/versions/latest:access")
$DsrmPassword = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($Secret.payload.data))
$DsrmPassword = ConvertTo-SecureString -AsPlainText $DsrmPassword -force

#
# Promote.
#
Write-Host "Setting administrator password..."
Set-LocalUser -Name Administrator -Password $DsrmPassword

if ($ActiveDirectoryFirstDc -eq $env:COMPUTERNAME) {
    Write-Host "Creating a new forest $ActiveDirectoryDnsDomain ($ActiveDirectoryNetbiosDomain)..."
    Install-ADDSForest `
        -DomainName $ActiveDirectoryDnsDomain `
        -DomainNetbiosName $DomainNetbiosName `
        -SafeModeAdministratorPassword $DsrmPassword `
        -DomainMode Win2008R2 `
        -ForestMode Win2008R2 `
        -InstallDns `
        -CreateDnsDelegation:$False `
        -NoRebootOnCompletion:$True `
        -Confirm:$false
}
else {
    do {
        Write-Host "Waiting for domain to become available..."
        Start-Sleep -s 60
        & ipconfig /flushdns | Out-Null
        & nltest /dsgetdc:$ActiveDirectoryDnsDomain | Out-Null
    } while ($LASTEXITCODE -ne 0)

    Write-Host "Adding DC to $ActiveDirectoryDnsDomain ($ActiveDirectoryNetbiosDomain)..."
    Install-ADDSDomainController `
        -DomainName $ActiveDirectoryDnsDomain `
        -SafeModeAdministratorPassword $DsrmPassword `
        -InstallDns `
        -Credential (New-Object System.Management.Automation.PSCredential ("Administrator@$ActiveDirectoryDnsDomain", $DsrmPassword)) `
        -NoRebootOnCompletion:$true  `
        -Confirm:$false
}

#
# Configure DNS.
#
Write-Host "Configuring DNS settings..."
Get-Netadapter| Disable-NetAdapterBinding -ComponentID ms_tcpip6
Set-DnsClientServerAddress  `
    -InterfaceIndex (Get-NetAdapter -Name Ethernet).InterfaceIndex `
    -ServerAddresses 127.0.0.1

#
# Enable LSA protection.
#
New-ItemProperty `
    -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" `
    -Name "RunAsPPL" `
    -Value 1 `
    -PropertyType DWord

Write-Host "Restarting to apply all settings..."
Restart-Computer
' | Out-File dc-startup.ps1 -Encoding ASCII

O script faz o seguinte:

Lê a senha do DSRM do Secret Manager.
Promove a VM a controlador do domínio.
Define as configurações de DNS para que cada controlador do domínio use o endereço de loopback como um servidor DNS.
Desativa o IPv6.
Ativa a proteção de LSA.

Criar uma instância de VM para o primeiro controlador de domínio:

$Subnet = "projects/$VpcProjectId/regions/$Region/subnetworks/domain-controllers"
$Metadata = `
  "ActiveDirectoryDnsDomain=$AdDnsDomain",
  "ActiveDirectoryNetbiosDomain=$AdNetbiosDomain",
  "ActiveDirectoryFirstDc=dc-1",
  "sysprep-specialize-script-ps1=Install-WindowsFeature AD-Domain-Services; Install-WindowsFeature DNS",
  "disable-account-manager=true" -join ","

& gcloud compute instances create dc-1  `
  --image-family windows-2022 `
  --image-project windows-cloud `
  --machine-type n2-standard-8 `
  --tags ad-domaincontroller `
  --metadata "$Metadata" `
  --metadata-from-file windows-startup-script-ps1=dc-startup.ps1 `
  --no-address `
  --network-interface "no-address,private-network-ip=$AddressOfDc1,subnet=$Subnet" `
  --service-account $DcServiceAccount `
  --scopes cloud-platform `
  --zone $Zones[0] `
  --shielded-integrity-monitoring `
  --shielded-secure-boot `
  --shielded-vtpm `
  --deletion-protection

Este comando faz o seguinte:

Cria uma VM protegida do Windows Server 2022.
Atribui a conta de serviço ad-domaincontroller à VM para que ela possa acessar a senha do DSRM.
Configura o agente convidado para desativar o gerente de contas. Para mais informações sobre como configurar o agente convidado, consulte Como ativar e desativar recursos de instância do Windows.
Deixa a VM instalar os recursos do Windows AD-Domain-Services e DNS durante a fase de especialização do sysprep.
Deixa a VM executar o script de inicialização criado anteriormente.

Crie outra instância de VM para o segundo controlador do domínio e coloque-a em uma zona diferente:

& gcloud compute instances create dc-2  `
  --image-family windows-2022 `
  --image-project windows-cloud `
  --machine-type n2-standard-8 `
  --tags ad-domaincontroller `
  --metadata "$Metadata" `
  --metadata-from-file windows-startup-script-ps1=dc-startup.ps1 `
  --no-address `
  --network-interface "no-address,private-network-ip=$AddressOfDc2,subnet=$Subnet" `
  --service-account $DcServiceAccount `
  --scopes cloud-platform `
  --zone $Zones[1] `
  --shielded-integrity-monitoring `
  --shielded-secure-boot `
  --shielded-vtpm `
  --deletion-protection

Monitore o processo de inicialização do primeiro controlador de domínio visualizando a saída da porta serial:
```
& gcloud compute instances tail-serial-port-output dc-1 --zone $Zones[0]
```
Aguarde cerca de 10 minutos até ver a mensagem Restarting to apply all settings... e pressione Ctrl+C.
Monitore o processo de inicialização do segundo controlador do domínio visualizando a saída da porta serial:
```
& gcloud compute instances tail-serial-port-output dc-2 --zone $Zones[1]
```
Aguarde cerca de 10 minutos até ver a mensagem Restarting to apply all settings... e pressione Ctrl+C.

A floresta e o domínio do Active Directory agora estão prontos para o uso.

Conectar-se a um controlador do domínio

Agora é possível personalizar a floresta do Active Directory conectando-se a um dos controladores do domínio.

No PowerShell, acesse a senha do usuário Administrator:

gcloud secrets versions access latest --secret ad-password

Conecte-se a dc-1 usando RDP e faça login como o usuário Administrator.

Como a instância de VM não tem endereços IP públicos, você precisa se conectar pelo encaminhamento de TCP do Identity-Aware Proxy.

A seguir

Saiba mais sobre os padrões de uso do Active Directory em um ambiente híbrido.
Configurar o Active Directory para VMs para ingressar automaticamente em um domínio.
Saiba mais sobre como usar o Active Directory em firewalls.