Esta página se ha traducido con Cloud Translation API.

Desplegar 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 siguiendo las prácticas recomendadas descritas en el artículo Prácticas recomendadas para ejecutar Active Directory en Google Cloud.

Esta guía está dirigida a administradores e ingenieros de DevOps. Se da por supuesto que tienes un conocimiento sólido de Active Directory y nociones básicas sobreGoogle Cloud redes y seguridad.

Arquitectura

El despliegue consta de dos proyectos:

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

Esta arquitectura te permite hacer lo siguiente:

Implementa cargas de trabajo de Windows adicionales en proyectos independientes y permite que usen la red de VPC compartida y el bosque de Active Directory.
Integra el bosque de Active Directory con un bosque local para implementar el patrón de bosque de recursos.

Antes de empezar

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

Intervalos 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 de los controladores de dominio del tráfico de otros servidores cuando gestionas reglas de firewall o analizas registros de red.
  
  Recomendamos un intervalo CIDR de subred de tamaño /28 o /29.
- Subred de recursos. Esta subred contiene servidores y estaciones de trabajo administrativas. Usa un intervalo CIDR de subred que sea lo suficientemente grande para alojar todos los servidores que quieras desplegar.
Asegúrate de que tus subredes no se solapen con ninguna subred local y de que haya espacio suficiente para crecer.
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.

Implementar una red compartida

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

Crear un proyecto

Ahora, crea un proyecto y úsalo para desplegar una red de VPC compartida.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Cloud DNS APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

Para obtener los permisos que necesitas para desplegar una red compartida, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto o en la carpeta principal:

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

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Eliminar la VPC predeterminada

De forma predeterminada, Compute Engine crea una red predeterminada en cada proyecto nuevo que crees. Esta red está configurada en modo automático, lo que significa que se preasigna una subred a cada región y se le asigna automáticamente un intervalo CIDR.

En esta sección, sustituirás esta red VPC por una red de modo personalizado que contenga dos subredes y que use intervalos CIDR personalizados.

En la Google Cloud consola, abre Cloud Shell.

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

Elimina todas las reglas de cortafuegos asociadas a 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 }

Elimina la VPC predeterminada:

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

Crear una red VPC en modo personalizado

Ahora, crea 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"
```
Haz los cambios siguientes:
- VPC_NAME: el nombre de la VPC.
- REGION: la región en la que se van a implementar los controladores de dominio de Active Directory.
- DC_CIDR: el intervalo de subredes que se va a usar para la subred de los controladores de dominio.
- RESOURCES_CIDR: el intervalo de subredes que se va a usar 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 la función Acceso privado de Google para que Windows se 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

Implementar subredes y reglas de cortafuegos

Ahora, crea reglas de cortafuegos para permitir la comunicación de Active Directory en la VPC.

Permite las 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

Permite las consultas de DNS de Cloud DNS a los 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 cortafuegos es necesaria para que funcione la zona de reenvío de DNS privado.

Permitir 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 inicios de sesión de Active Directory desde las máquinas virtuales que se encuentran 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 tienes previsto configurar LDAP seguro, permite las conexiones de LDAP seguro 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 cortafuegos si tienes previsto configurar LDAP seguro.

(Opcional) Crea una regla de cortafuegos que registre todos los intentos de acceso fallidos. Los registros pueden ser útiles para diagnosticar problemas de conectividad, pero pueden generar 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
```

Desplegar el bosque de Active Directory

En esta sección, crearás un proyecto de servicio y lo asociarás al proyecto del host de la VPC compartida que has creado anteriormente. A continuación, usa el proyecto de servicio para implementar un nuevo bosque de Active Directory con dos controladores de dominio.

Crear un proyecto

Ahora, crea un proyecto y úsalo para desplegar 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.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Secret Manager APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

Para obtener los permisos que necesitas para implementar el bosque de Active Directory, pide al administrador que te conceda las siguientes funciones de IAM en el proyecto:

Administrador de instancias de Compute (v. 1) (roles/compute.instanceAdmin.v1)
Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Administrador de Secret Manager (roles/secretmanager.admin)
Usuario de túneles protegidos mediante IAP (roles/iap.tunnelResourceAccessor)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Preparar la configuración

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

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

Activar Cloud Shell
Inicia PowerShell:
```
pwsh
```
Configura gcloud CLI para usar el nuevo proyecto:
```
gcloud config set project DC_PROJECT_ID
```
Sustituye 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"
```
Haz los cambios siguientes:
- DNS_DOMAIN: nombre del dominio raíz del bosque de Active Directory; por ejemplo, cloud.example.com.
- NETBIOS_DOMAIN: nombre de dominio NetBIOS del dominio raíz del bosque. Por ejemplo, CLOUD.
- VPCHOST_PROJECT_ID: el ID del proyecto host de la VPC que has creado anteriormente.
- VPC_NAME: nombre de la red de VPC compartida que has creado anteriormente.
- REGION: región en la que se desplegarán 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 ampliar la VPC y tu dominio para cubrir más regiones 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"
```

Crear una zona de reenvío de DNS privada

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.

Asocia 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 la VPC y configura la zona para que reenvíe las 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"

Crear una contraseña de DSRM

Ahora puedes definir la contraseña del modo de restauración de servicios de directorio (DSRM) y almacenarla en Secret Manager. A continuación, concede a las VMs del controlador de dominio acceso temporal a este secreto para que puedan usarlo para implementar el bosque de Active Directory.

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

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

Implementar controladores de dominio

Ahora, despliega dos instancias de VM y crea un bosque y un dominio de Active Directory. Para minimizar el número de pasos manuales, puedes usar 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 $ActiveDirectoryNetbiosDomain `
        -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 de Secret Manager.
Promueve la máquina virtual a controlador de dominio.
Configura los ajustes de DNS para que cada controlador de dominio use la dirección de bucle de retorno 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 hace lo siguiente:

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 invitado para inhabilitar el administrador de cuentas. Para obtener más información sobre cómo configurar el agente invitado, consulta el artículo Habilitar e inhabilitar funciones de instancias Windows.
Permite que la VM instale las funciones de Windows AD-Domain-Services y DNS durante la fase de especialización de sysprep.
Deja que la VM ejecute la secuencia de comandos de inicio que has creado anteriormente.

Crea otra instancia de VM para el segundo controlador de dominio y colócala en otra zona:

& 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

Monitoriza el proceso de inicialización del primer controlador de dominio viendo la salida de su puerto 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.... A continuación, pulsa Ctrl+C.
Monitoriza el proceso de inicialización del segundo controlador de dominio consultando la salida de su puerto 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.... A continuación, pulsa Ctrl+C.

El bosque y el dominio de Active Directory ya se pueden usar.

Conectarse 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 del usuario Administrator:
```
gcloud secrets versions access latest --secret ad-password
```
Conéctate a dc-1 mediante RDP e inicia sesión como usuario de Administrator.

Como la instancia de VM no tiene una dirección IP pública, debes conectarte a través del reenvío de TCP de Identity-Aware Proxy.

Siguientes pasos

Consulta más información sobre los patrones para usar Active Directory en un entorno híbrido.
Configura Active Directory para que las máquinas virtuales se unan automáticamente a un dominio.
Más información sobre cómo usar Active Directory en cortafuegos

Desplegar un bosque de Active Directory en Compute Engine Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Arquitectura

Antes de empezar

Implementar una red compartida

Crear un proyecto

Eliminar la VPC predeterminada

Crear una red VPC en modo personalizado

Implementar subredes y reglas de cortafuegos

Desplegar el bosque de Active Directory

Crear un proyecto

Preparar la configuración

Crear una zona de reenvío de DNS privada

Crear una contraseña de DSRM

Implementar controladores de dominio

Conectarse a un controlador de dominio

Siguientes pasos

Desplegar un bosque de Active Directory en Compute Engine