Esegui il deployment di una foresta Active Directory su Compute Engine

Last reviewed 2023-05-10 UTC

Questo documento descrive come eseguire il deployment di una foresta Active Directory su Compute Engine secondo le best practice descritte in Best practice per l'esecuzione di Active Directory su Google Cloud.

Questa guida è rivolta agli amministratori e agli ingegneri DevOps. Si presume che tu abbia una buona conoscenza di Active Directory e una conoscenza di base del networking e della sicurezza di Google Cloud.

Architettura

Il deployment è costituito da due progetti:

Un progetto host che contiene una rete VPC condiviso, una zona di forwarding DNS privata e regole firewall per Active Directory.
Un progetto di servizio che contiene due controller di dominio di cui viene eseguito il deployment in due zone.

Questa architettura ti consente di:

Esegui il deployment di carichi di lavoro Windows aggiuntivi in progetti separati e consenti loro di utilizzare la rete VPC condiviso e la foresta Active Directory.
Integrare la foresta Active Directory con una foresta on-premise esistente per implementare il pattern risorsa-foresta.

Prima di iniziare

Per seguire le istruzioni riportate in questa guida, assicurati di disporre di quanto segue:

Intervalli CIDR di subnet per due subnet:
- Subnet controller di dominio. Questa subnet contiene i controller di dominio. L'utilizzo di una subnet dedicata per i controller di dominio consente di distinguere il traffico dei controller di dominio da quello dei server quando gestisci le regole firewall o analizzi i log di rete.
  
  Consigliamo un intervallo CIDR di una subnet di dimensioni pari a /28 o /29.
- Subnet delle risorse: Questa subnet contiene server e workstation amministrative. Utilizza un intervallo CIDR di una subnet di dimensioni sufficientemente grandi da contenere tutti i server di cui prevedi di eseguire il deployment.
Assicurati che non si sovrappongano ad alcuna subnet on-premise e lasci un margine sufficiente di crescita.
Un nome di dominio DNS e un nome di dominio NetBIOS per il dominio principale della foresta di Active Directory. Per ulteriori informazioni sulla scelta di un nome, consulta le convenzioni di denominazione di Microsoft.

Esegui il deployment di una rete condivisa

In questa sezione creerai un nuovo progetto e lo utilizzerai per eseguire il deployment di una rete VPC condiviso. In seguito, utilizzerai questa rete per eseguire il deployment dei controller di dominio Active Directory.

Crea un progetto

Ora puoi creare un nuovo progetto e utilizzarlo per eseguire il deployment di una rete VPC condiviso.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Compute Engine and Cloud DNS.
Abilita le API

Per ottenere le autorizzazioni necessarie per il deployment di una rete condivisa, chiedi all'amministratore di concederti i ruoli IAM seguenti sul progetto o sulla cartella padre:

Amministratore rete Compute (roles/compute.networkAdmin)
Amministratore sicurezza Compute (roles/compute.securityAdmin)
Amministratore VPC condiviso Compute (roles/compute.xpnAdmin)
DNS Administrator (Amministratore DNS) (roles/dns.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Elimina il VPC predefinito

Per impostazione predefinita, Compute Engine crea una rete predefinita in ogni nuovo progetto che crei. Questa rete è configurata in modalità automatica, il che significa che una subnet è preallocata per ogni regione e viene assegnato automaticamente un intervallo CIDR.

In questa sezione, sostituisci questa rete VPC con una rete in modalità personalizzata che contiene due subnet e utilizza intervalli CIDR personalizzati.

Nella console Google Cloud, apri Cloud Shell.

Attiva Cloud Shell
Avvia PowerShell:
```
pwsh
```
Configura gcloud CLI per utilizzare il nuovo progetto:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID del progetto.

Elimina tutte le regole firewall associate al VPC predefinito:

$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 il VPC predefinito:

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

Crea una rete VPC in modalità personalizzata

Ora puoi creare una rete VPC in modalità personalizzata nel progetto host VPC.

In PowerShell, inizializza le seguenti variabili:
```
$VpcName = "VPC_NAME"
$Region = "REGION"
$SubnetRangeDomainControllers = "DC_CIDR"
$SubnetRangeResources = "RESOURCES_CIDR"
```
Sostituisci quanto segue:
- VPC_NAME: il nome del VPC.
- REGION: la regione in cui eseguire il deployment dei controller di dominio Active Directory.
- DC_CIDR: l'intervallo di subnet da utilizzare per la subnet dei controller di dominio.
- RESOURCES_CIDR: l'intervallo di subnet da utilizzare per la subnet della risorsa.
Esempio:
```
$VpcName = "ad"
$Region = "us-central1"
$SubnetRangeDomainControllers = "10.0.0.0/28"
$SubnetRangeResources = "10.0.1.0/24"
```

Crea il VPC e configuralo in modo che venga utilizzato come rete VPC condiviso:

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

Crea le subnet e abilita l'accesso privato Google in modo che Windows possa attivare senza accesso 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

Esegui il deployment di subnet e regole firewall

Ora puoi creare regole firewall per consentire la comunicazione con Active Directory all'interno del VPC.

Consenti connessioni RDP a tutte le istanze VM tramite l'inoltro TCP di 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

Consenti query DNS da Cloud DNS ai controller di 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

Questa regola firewall è necessaria affinché la zona di forwarding DNS privata funzioni.

Consenti la replica di Active Directory tra controller di 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

Consenti gli accessi ad Active Directory dalle VM nella subnet delle risorse ai controller di 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

Se prevedi di configurare LDAP sicuro, consenti le connessioni LDAP sicure dalle VM nella subnet delle risorse ai controller di 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

Questa regola firewall è necessaria solo se prevedi di configurare LDAP sicuro.

(Facoltativo) Crea una regola firewall che registri tutti i tentativi di accesso non riusciti. I log possono essere utili per diagnosticare problemi di connettività, ma potrebbero produrre un volume significativo di dati di log.

& 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

Esegui il deployment della foresta di Active Directory

In questa sezione creerai un nuovo progetto di servizio e lo collegherai al progetto host del VPC condiviso che hai creato in precedenza. Potrai quindi utilizzare il progetto di servizio per eseguire il deployment di una nuova foresta di Active Directory con due controller di dominio.

Crea un progetto

Ora crei un nuovo progetto e lo utilizzi per eseguire il deployment delle VM controller di dominio Active Directory.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Compute Engine and Secret Manager.
Abilita le API

Per ottenere le autorizzazioni necessarie per il deployment della foresta di Active Directory, chiedi all'amministratore di concederti i ruoli IAM seguenti per il progetto:

Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1)
Amministratore account di servizio (roles/iam.serviceAccountAdmin)
Utente account di servizio (roles/iam.serviceAccountUser)
Amministratore Secret Manager (roles/secretmanager.admin)
Utente del tunnel con protezione IAP (roles/iap.tunnelResourceAccessor)

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche essere in grado di ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Prepara la configurazione

Il passaggio successivo consiste nel preparare la configurazione per il deployment di Active Directory.

Se hai già chiuso la sessione di PowerShell, apri Cloud Shell.

Attiva Cloud Shell
Avvia PowerShell:
```
pwsh
```
Configura gcloud CLI per utilizzare il nuovo progetto:
```
gcloud config set project DC_PROJECT_ID
```
Sostituisci DC_PROJECT_ID con l'ID del progetto.
Utilizza PowerShell per creare le seguenti variabili:
```
$AdDnsDomain = "DNS_DOMAIN"
$AdNetbiosDomain = "NETBIOS_DOMAIN"
$VpcProjectId = "VPCHOST_PROJECT_ID"
$VpcName = "VPC_NAME"
$Region = "REGION"
$Zones = "REGION-a", "REGION-b"
```
Sostituisci quanto segue:
- DNS_DOMAIN: il nome di dominio principale della foresta Active Directory, ad esempio cloud.example.com.
- NETBIOS_DOMAIN: il nome di dominio NetBIOS per il dominio principale della foresta, ad esempio CLOUD.
- VPCHOST_PROJECT_ID: l'ID del progetto host VPC creato in precedenza.
- VPC_NAME: nome della rete VPC condiviso creata in precedenza.
- REGION: regione in cui eseguire il deployment dei controller di dominio Active Directory. Nota che i nomi delle zone si basano sui nomi dell'area geografica da te specificata. Puoi estendere il VPC e il tuo dominio per coprire regioni aggiuntive in qualsiasi momento.
Esempio:
```
$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 di forwarding DNS privata

Ora prenoti due indirizzi IP statici per i controller di dominio e crei una zona di inoltro DNS privata che inoltra tutte le query DNS per il dominio Active Directory a questi indirizzi IP.

Associa il progetto alla rete VPC condiviso:

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

Prenota due indirizzi IP interni statici nella subnet dei controller di 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 di forwarding privata di Cloud DNS nel progetto host VPC e configura la zona per inoltrare le query DNS ai due indirizzi IP riservati:

& 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 password DSRM

Ora definisci la password della modalità di ripristino dei servizi directory (DSRM) e la archivi in Secret Manager. Successivamente, concedi alle VM del controller di dominio l'accesso temporaneo a questo secret, in modo che possano utilizzarlo per eseguire il deployment della foresta Active Directory.

Genera una password casuale e memorizzala in un secret di 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 l'account di servizio per le istanze VM del controller di dominio:

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

Concedi all'account di servizio l'autorizzazione a leggere il secret per l'ora successiva:

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

Esegui il deployment dei controller di dominio

Ora esegui il deployment di due istanze VM e crei una nuova foresta e un nuovo dominio di Active Directory. Per ridurre al minimo il numero di passaggi manuali, utilizza gli script di avvio.

In PowerShell, esegui questo comando per generare uno script di avvio:

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

Lo script svolge le seguenti operazioni:

Leggi la password DSRM di Secret Manager.
Promuovi la VM a controller di dominio.
Configura le impostazioni DNS in modo che ogni controller di dominio utilizzi l'indirizzo di loopback come server DNS.
Disattiva IPv6.
Attiva la protezione LSA.

Crea un'istanza VM per il primo controller di 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

Questo comando svolge le seguenti operazioni:

Crea una VM di Windows Server 2022 shielded.
Assegna l'account di servizio ad-domaincontroller alla VM in modo che possa accedere alla password DSRM.
Configura l'agente ospite in modo da disabilitare il gestore dell'account. Per ulteriori informazioni sulla configurazione dell'agente guest, consulta Abilitazione e disabilitazione delle funzionalità delle istanze Windows.
Consenti alla VM di installare le funzionalità di Windows AD-Domain-Services e DNS durante la fase di specializzazione di sysprep.
Consenti alla VM di eseguire lo script di avvio che hai creato in precedenza.

Crea un'altra istanza VM per il secondo controller di dominio e posizionala in una zona diversa:

& 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

Monitora il processo di inizializzazione del primo controller di dominio visualizzando l'output della porta seriale:
```
& gcloud compute instances tail-serial-port-output dc-1 --zone $Zones[0]
```
Attendi 10 minuti finché non viene visualizzato il messaggio Restarting to apply all settings..., quindi premi Ctrl+C.
Monitora il processo di inizializzazione del secondo controller di dominio visualizzando l'output della porta seriale:
```
& gcloud compute instances tail-serial-port-output dc-2 --zone $Zones[1]
```
Attendi 10 minuti finché non viene visualizzato il messaggio Restarting to apply all settings..., quindi premi Ctrl+C.

La foresta e il dominio di Active Directory sono ora pronti per l'uso.

Connettiti a un controller di dominio

Ora puoi personalizzare la foresta di Active Directory collegandoti a uno dei controller di dominio.

In PowerShell, accedi alla password per l'utente Administrator:
```
gcloud secrets versions access latest --secret ad-password
```
Connettiti a dc-1 utilizzando RDP e accedi come utente Administrator.

Poiché l'istanza VM non ha indirizzi IP pubblici, devi connetterti tramite l'inoltro TCP di Identity-Aware Proxy.

Passaggi successivi

Scopri di più sui pattern per l'utilizzo di Active Directory in un ambiente ibrido.
Configura Active Directory per le VM per l'aggiunta automatica a un dominio.
Scopri di più sull'utilizzo di Active Directory su più firewall.