Implementa un bosque de Active Directory en Compute Engine

Last reviewed 2024-07-11 UTC

En este documento, se describe cómo implementar un bosque de Active Directory en Compute Engine de una manera que siga las prácticas recomendadas que se describen en Prácticas recomendadas para ejecutar Active Directory en Google Cloud.

Esta guía está dirigida a administradores e ingenieros de DevOps. Se da por hecho que cuentas con conocimientos sólidos de Active Directory y conocimientos básicos de las herramientas de redes y la seguridad de Google Cloud.

Arquitectura

La implementación consta de dos proyectos:

Un proyecto host que contiene una red de VPC compartida, una zona de reenvío de DNS privado y reglas de firewall para Active Directory
Un proyecto de servicio que contiene dos controladores de dominio que se implementan en dos zonas.

Esta arquitectura te permite hacer lo siguiente:

Implementar cargas de trabajo adicionales de Windows en proyectos diferentes y permitir que usen la red de VPC compartida y el bosque de Active Directory.
Integra el bosque de Active Directory a un bosque local existente para implementar el patrón de bosques de recursos.

Antes de comenzar

Para seguir las instrucciones de esta guía, asegúrate de tener lo siguiente:

Rangos de CIDR de subred para dos subredes:
- Subred de controladores de dominio. Esta subred contiene los controladores de dominio. Usar una subred dedicada para los controladores de dominio te ayuda a distinguir el tráfico del controlador de dominio de otro tráfico del servidor cuando administras reglas de firewall o analizas registros de red.
  
  Recomendamos un rango de CIDR de subred con el tamaño /28 o /29.
- Recurso o subred. Esta subred contiene servidores y estaciones de trabajo administrativas. Usa un rango de CIDR de subred que sea lo suficientemente grande como para admitir todos los servidores que planeas implementar.
Asegúrate de que tus subredes no se superpongan con ninguna subred local y permitan suficiente espacio para el crecimiento.
Un nombre de dominio DNS y un nombre de dominio NetBIOS para el dominio raíz del bosque de Active Directory Para obtener más información sobre cómo elegir un nombre, consulta las Convenciones de nomenclatura de Microsoft.

Implementa una red compartida

En esta sección, crearás un proyecto nuevo y lo usarás para implementar una red de VPC compartida. Más adelante, usarás esta red para implementar los controladores de dominio de Active Directory.

Crea un proyecto

Ahora crearás un proyecto nuevo y lo usarás para implementar una red de VPC compartida.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Cloud DNS APIs.
Enable the APIs

Para obtener los permisos que necesitas para implementar una red compartida, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto o la carpeta superior:

Administrador de la red de Compute (roles/compute.networkAdmin)
Administrador de seguridad de Compute (roles/compute.securityAdmin)
Administrador de VPC compartida de Compute (roles/compute.xpnAdmin)
Administrador de DNS(roles/dns.admin)

Si quieres obtener más información para otorgar funciones, consulta Administra el acceso.

También puedes obtener los permisos necesarios a través de funciones personalizadas o cualquier otro rol predefinido.

Borra la VPC predeterminada

De forma predeterminada, Compute Engine crea una red predeterminada en cada proyecto nuevo que crees. Esta red se configura en modo automático, lo que significa que una subred está preasignada para cada región y tiene asignada automáticamente un rango de CIDR.

En esta sección, reemplazarás esta red de VPC por una red de modo personalizado que contiene dos subredes y que usa rangos de CIDR personalizados.

En la consola de Google Cloud, abre Cloud Shell.

Activa Cloud Shell
Inicia PowerShell:
```
pwsh
```
Configura gcloud CLI para usar el proyecto nuevo:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el ID de tu proyecto.

Borra todas las reglas de firewall que están asociadas con la VPC predeterminada:

$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 }

Borra la VPC predeterminada:

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

Crea una red de VPC en modo personalizado.

Ahora crearás una red de VPC en modo personalizado en tu proyecto host de VPC.

En PowerShell, inicializa las siguientes variables:
```
$VpcName = "VPC_NAME"
$Region = "REGION"
$SubnetRangeDomainControllers = "DC_CIDR"
$SubnetRangeResources = "RESOURCES_CIDR"
```
Reemplaza lo siguiente:
- VPC_NAME: El nombre de la VPC.
- REGION por la región en la que se implementan los controladores de dominio de Active Directory
- DC_CIDR: El rango de subred a utilizar para la subred de los controladores de dominio.
- RESOURCES_CIDR con el rango de subred a utilizar para la subred de recursos.
Ejemplo:
```
$VpcName = "ad"
$Region = "us-central1"
$SubnetRangeDomainControllers = "10.0.0.0/28"
$SubnetRangeResources = "10.0.1.0/24"
```

Crea la VPC y configúrala para que se use como red de VPC compartida:

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

Crea las subredes y habilita el Acceso privado a Google para que Windows pueda activar sin acceso a 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

Implementa subredes y reglas de firewall

Ahora crearás reglas de firewall para permitir la comunicación de Active Directory dentro de la VPC.

Permite conexiones RDP a todas las instancias de VM a través del reenvío de TCP de Cloud IAP:

& 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 de DNS de Cloud DNS a controladores de dominio.

& 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

Esta regla de firewall es obligatoria para que funcione la zona de reenvío de DNS privada.

Permite la replicación de Active Directory entre controladores de dominio:

& 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

Permite los accesos de Active Directory desde las VMs que están en la subred de recursos a los controladores de dominio:

& 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

Si planeas configurar LDAP seguro, permite conexiones LDAP seguras desde las VMs que están en la subred de recursos a los controladores de dominio:

& 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

Solo necesitas esta regla de firewall si planeas configurar LDAP seguro.

Crea una regla de firewall que registre todos los intentos de acceso fallidos (opcional). Los registros pueden ser útiles para diagnosticar problemas de conectividad, pero pueden producir un volumen significativo de datos 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

Implementa el bosque de Active Directory

En esta sección, crearás un proyecto de servicio nuevo y lo vincularás al proyecto host de VPC compartida que creaste antes. Luego, usarás el proyecto de servicio para implementar un bosque de Active Directory nuevo con dos controladores de dominio.

Crea un proyecto

Ahora, crearás un proyecto nuevo y lo usarás para implementar las VMs del controlador de dominio de Active Directory.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Secret Manager APIs.
Enable the APIs

Para obtener los permisos que necesitas para implementar el bosque de Active Directory, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1)
Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Administrador de Secret Manager (roles/secretmanager.admin)
Usuario de túnel protegido con IAP (roles/iap.tunnelResourceAccessor)

Si quieres obtener más información para otorgar funciones, consulta Administra el acceso.

También puedes obtener los permisos necesarios a través de funciones personalizadas o cualquier otro rol predefinido.

Prepara la configuración

El siguiente paso es preparar la configuración para la implementación de Active Directory.

Si cerraste la sesión de PowerShell, abre Cloud Shell.

Activa Cloud Shell
Inicia PowerShell:
```
pwsh
```
Configura gcloud CLI para usar el proyecto nuevo:
```
gcloud config set project DC_PROJECT_ID
```
Reemplaza DC_PROJECT_ID por el ID de tu proyecto.
Usa PowerShell para crear las siguientes variables:
```
$AdDnsDomain = "DNS_DOMAIN"
$AdNetbiosDomain = "NETBIOS_DOMAIN"
$VpcProjectId = "VPCHOST_PROJECT_ID"
$VpcName = "VPC_NAME"
$Region = "REGION"
$Zones = "REGION-a", "REGION-b"
```
Reemplaza lo siguiente:
- DNS_DOMAIN: Es el nombre de dominio raíz de bosque del bosque de Active Directory, por ejemplo, cloud.example.com.
- NETBIOS_DOMAIN: Es el nombre de dominio de NetBIOS para el dominio raíz del bosque, por ejemplo, CLOUD.
- VPCHOST_PROJECT_ID: es el ID del proyecto host de VPC que creaste antes.
- VPC_NAME: Nombre de la red de VPC compartida que creaste antes.
- REGION: la región en la que se implementan los controladores de dominio de Active Directory Ten en cuenta que los nombres de las zonas se basan en los nombres de la región que especifiques. Puedes extender la VPC y tu dominio para cubrir regiones adicionales en cualquier momento.
Ejemplo:
```
$AdDnsDomain = "cloud.example.com"
$AdNetbiosDomain = "CLOUD"
$VpcProjectId = "vpc-project-123"
$VpcName = "ad"
$Region = "us-west1"
$Zones = "us-west1-a", "us-west1-b"
```

Crea una zona de desvío de DNS privado

Ahora, reserva dos direcciones IP estáticas para tus controladores de dominio y crea una zona de reenvío de DNS privada que reenvíe todas las consultas de DNS del dominio de Active Directory a estas direcciones IP.

Adjunta el proyecto a la red de VPC compartida:

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

Reserva dos direcciones IP internas estáticas en la subred de los controladores de dominio:

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

Crea una zona de reenvío privada de Cloud DNS en el proyecto host de VPC y configura la zona para reenviar consultas de DNS a las dos direcciones IP reservadas:

& 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"

Crea una contraseña de DSRM

Ahora debes definir la contraseña del Modo de restablecimiento del servicio de directorio (DSRM) y almacenarla en Secret Manager. Luego, otorga acceso temporal a este Secret a las VMs del controlador de dominio para que puedan usarlo para implementar el bosque de Active Directory.

Genera una contraseña aleatoria y almacénala en un Secret de 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

Crea la cuenta de servicio para las instancias de VM del controlador de dominio:

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

Otorga permiso a la cuenta de servicio para leer el Secret durante la 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')"

Implementa controladores de dominio

Ahora implementará dos instancias de VM y creará un bosque y un dominio de Active Directory nuevos. Para minimizar la cantidad de pasos manuales, usa secuencias de comandos de inicio.

En PowerShell, ejecuta el siguiente comando para generar una secuencia de comandos de inicio:

'
$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

La secuencia de comandos hace lo siguiente:

Lee la contraseña de DSRM desde Secret Manager.
Asciende la VM a un controlador de dominio.
Configura la configuración de DNS para que cada controlador de dominio use la dirección de bucle invertido como servidor DNS.
Inhabilita IPv6.
Habilita la protección de LSA.

Crea una instancia de VM para el primer controlador de dominio:

$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 realiza las siguientes acciones:

Crea una VM de Windows Server 2022 protegida:
Asigna la cuenta de servicio ad-domaincontroller a la VM para que pueda acceder a la contraseña de DSRM.
Configura el agente de invitado para inhabilitar el administrador de cuentas. Para obtener más información sobre la configuración del agente de invitado, consulta Habilita o inhabilita funciones de instancias de Windows.
Permite que la VM instale las funciones de Windows AD-Domain-Services y DNS durante la fase de especialización de sysprep.
Permite que la VM ejecute la secuencia de comandos de inicio que creaste anteriormente.

Crea otra instancia de VM para el segundo controlador de dominio y colócala en una 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

Supervisa el proceso de inicialización del primer controlador de dominio cuando ves su salida de puerto en serie:
```
& gcloud compute instances tail-serial-port-output dc-1 --zone $Zones[0]
```
Espera unos 10 minutos hasta que veas el mensaje Restarting to apply all settings... y presiona Ctrl+C.
Supervisa el proceso de inicialización del segundo controlador de dominio cuando ves su salida de puerto en serie:
```
& gcloud compute instances tail-serial-port-output dc-2 --zone $Zones[1]
```
Espera unos 10 minutos hasta que veas el mensaje Restarting to apply all settings... y presiona Ctrl+C.

El bosque y el dominio de Active Directory ya están listos para usar.

Conéctate a un controlador de dominio

Ahora puedes personalizar el bosque de Active Directory conectándote a uno de los controladores de dominio.

En PowerShell, accede a la contraseña para el usuario Administrator:
```
gcloud secrets versions access latest --secret ad-password
```
Conéctate a dc-1 a través de RDP y accede como el usuario Administrator.

Debido a que la instancia de VM no tiene direcciones IP públicas, debes conectarte a través del reenvío de TCP de Identity-Aware Proxy.

¿Qué sigue?

Obtén más información sobre los patrones para usar Active Directory en un entorno híbrido.
Configura Active Directory para las VM a fin de que se unan automáticamente a un dominio
Obtén más información para usar Active Directory entre firewalls.