Esegui il deployment di una foresta Active Directory su Compute Engine

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

Questa guida è rivolta agli amministratori e agli engineer DevOps. Presuppone che tu abbia una solida conoscenza di Active Directory e una conoscenza di base diGoogle Cloud reti e sicurezza.

Architettura

Il deployment è costituito da due progetti:

• Un progetto host che contiene una rete VPC condivisa, una zona di inoltro DNS privato e regole firewall per Active Directory.
• Un progetto di servizio che contiene due controller di dominio di cui è stato eseguito il deployment in due zone.

Questa architettura ti consente di:

• Esegui il deployment di carichi di lavoro Windows aggiuntivi in progetti separati e consentigli di utilizzare la rete VPC condiviso e la foresta Active Directory.
• Integra la foresta Active Directory con una foresta on-premise esistente per implementare il pattern della foresta di risorse.

Prima di iniziare

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

• Intervalli CIDR delle subnet per due subnet:

  • Subnet dei 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 di altri server quando gestisci le regole firewall o analizzi i log di rete.

    Ti consigliamo un intervallo CIDR di subnet di dimensioni pari a /28 o /29.

  • Subnet delle risorse. Questa subnet contiene server e workstation amministrative. Utilizza un intervallo CIDR della subnet sufficientemente grande da ospitare tutti i server che prevedi di eseguire il deployment.

  Assicurati che le subnet non si sovrappongano a quelle on-premise e che ci sia spazio sufficiente per la crescita.

• Un nome di dominio DNS e un nome di dominio NetBIOS per il dominio radice della foresta Active Directory. Per ulteriori informazioni sulla scelta di un nome, consulta le convenzioni di denominazione di Microsoft.

Implementare una rete condivisa

In questa sezione, crei un nuovo progetto e lo utilizzi 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 crea un nuovo progetto e utilizzalo per eseguire il deployment di una rete VPC condiviso.

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

   Go to project selector

2. Make sure that billing is enabled for your Google Cloud project.

3. Enable the Compute Engine and Cloud DNS APIs.

   Enable the APIs

Per ottenere le autorizzazioni necessarie per eseguire il deployment di una rete condivisa, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto o nella cartella principale:

• Compute Network Admin (roles/compute.networkAdmin)
• Amministratore della sicurezza di Compute (roles/compute.securityAdmin)
• Amministratore VPC condiviso Compute (roles/compute.xpnAdmin)
• Amministratore DNS (roles/dns.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a 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 è preassegnata per ogni regione e le viene assegnato automaticamente un intervallo CIDR.

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

1. Nella Google Cloud console, apri Cloud Shell.

   Attiva Cloud Shell

2. Avvia PowerShell:

   pwsh
   

3. Configura gcloud CLI in modo da utilizzare il nuovo progetto:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto.

4. 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 }
   

5. Elimina il VPC predefinito:

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

Crea una rete VPC in modalità personalizzata

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

1. 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"
   

2. 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
   

3. Crea le subnet e abilita l'accesso privato Google in modo che Windows possa attivarsi 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 crea regole firewall per consentire la comunicazione di Active Directory all'interno del VPC.

1. 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
   

2. 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 per il funzionamento della zona di forwarding DNS privato.

3. Consenti la replica di Active Directory tra i domain controller:

   & 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
   

4. Consenti gli accessi ad Active Directory dalle VM che si trovano nella subnet delle risorse ai domain controller:

   & 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
   

5. Se prevedi di configurare LDAP sicuro, consenti le connessioni LDAP sicuro dalle VM che si trovano 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.

6. (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 Active Directory

In questa sezione, crei un nuovo progetto di servizio e lo colleghi al progetto host del VPC condiviso che hai creato in precedenza. Utilizza quindi il progetto di servizio per implementare una nuova foresta Active Directory con due domain controller.

Crea un progetto

Ora crea un nuovo progetto e utilizzalo per eseguire il deployment delle VM del domain controller Active Directory.

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

   Go to project selector

2. Make sure that billing is enabled for your Google Cloud project.

3. Enable the Compute Engine and Secret Manager APIs.

   Enable the APIs

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

• Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)
• Amministratore account di servizio (roles/iam.serviceAccountAdmin)
• Utente service account (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 Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a 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.

1. Se hai chiuso in precedenza la sessione di PowerShell, apri Cloud Shell.

   Attiva Cloud Shell

2. Avvia PowerShell:

   pwsh
   

3. Configura gcloud CLI in modo da utilizzare il nuovo progetto:

   gcloud config set project DC_PROJECT_ID
   

   Sostituisci DC_PROJECT_ID con l'ID del tuo progetto.

4. 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 radice 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 progetto del progetto host VPC che hai creato in precedenza.
   • VPC_NAME: il nome della rete VPC condiviso che hai creato in precedenza.
   • REGION: la regione in cui eseguire il deployment dei controller di dominio Active Directory. Tieni presente che i nomi delle zone si basano sui nomi della regione che specifichi. Puoi estendere il VPC e il tuo dominio per coprire altre regioni 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 inoltro DNS privato

Ora devi prenotare due indirizzi IP statici per i tuoi domain controller e creare una zona di inoltro con DNS privato che inoltra tutte le query DNS per il dominio Active Directory a questi indirizzi IP.

1. Collega il progetto alla rete VPC condiviso:

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

2. 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`)
   

3. Crea una zona di inoltro privato 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"
   

Creare una password DSRM

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

1. Genera una password casuale e archiviala 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
   

2. Crea il 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)"
   

3. Concedi all'account di servizio l'autorizzazione per 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')"
   

Esegna il deployment dei controller di dominio

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

1. In PowerShell, esegui il comando seguente 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 $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
   

   Lo script esegue le seguenti operazioni:

   • Leggi la password DSRM da 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.

2. 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 esegue le seguenti operazioni:

   • Crea una VM Windows Server 2022 protetta.
   • Assegna il account di servizio ad-domaincontroller alla VM in modo che possa accedere alla password DSRM.
   • Configura l'agente ospite per disattivare Gestione account. Per ulteriori informazioni sulla configurazione dell'agente guest, consulta Attivazione e disattivazione 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 creato in precedenza.

3. 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
   

4. 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 circa 10 minuti finché non viene visualizzato il messaggio Restarting to apply all settings..., quindi premi Ctrl+C.

5. 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 circa 10 minuti finché non viene visualizzato il messaggio Restarting to apply all settings..., quindi premi Ctrl+C.

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

Connettersi a un controller di dominio

Ora puoi personalizzare la foresta Active Directory connettendoti a uno dei domain controller.

1. In PowerShell, accedi alla password per l'utente Administrator:

   gcloud secrets versions access latest --secret ad-password
   

2. 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 in modo che si uniscano automaticamente a un dominio.
• Scopri di più sull'utilizzo di Active Directory tra i firewall.