Esegui il deployment di una foresta Active Directory su Compute Engine

Last reviewed 2024-07-11 UTC

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 ad amministratori e DevOps Engineer. Si presume che tu abbia una conoscenza approfondita di Active Directory e una conoscenza di base di la sicurezza e il networking di Google Cloud.

Architettura

Il deployment è costituito da due progetti:

• Un progetto host che contiene una rete VPC condivisa, una zona di inoltro DNS privata 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 altri carichi di lavoro Windows in progetti separati e consenti loro 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 foresta di risorse.

Nota: questa guida descrive come implementare una foresta Active Directory per la quale gestisci autonomamente i controller di dominio. Valuta la possibilità di utilizzare AD gestito per eseguire il deployment di un forest di Active Directory completamente gestito, a meno che alcuni dei tuoi requisiti non possano essere soddisfatti utilizzando AD gestito.

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 sottorete contiene i controller di dominio. L'utilizzo di una subnet dedicata per i controller di dominio ti consente di distinguere il traffico dei controller di dominio da quello di altri server quando gestisci le regole del firewall o analizzi i log di rete.

    Ti consigliamo un intervallo CIDR della sottorete di dimensioni /28 o /29.

  • Subnet di risorse. Questa subnet contiene server e stazioni di lavoro amministrative. Utilizza un intervallo CIDR della subnet sufficientemente ampio da contenere tutti i server che prevedi di implementare.

  Assicurati che le subnet non si sovrappongano a subnet on-premise e lascia sufficiente spazio 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 Convenzioni di denominazione di Microsoft.

Eseguire il deployment di 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:

• Amministratore rete Compute (roles/compute.networkAdmin)
• Amministratore della sicurezza di Compute (roles/compute.securityAdmin)
• Amministratore VPC condivisa Compute (roles/compute.xpnAdmin)
• Amministratore DNS (roles/dns.admin)

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

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Elimina la VPC predefinita

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 assegnata automaticamente un intervallo CIDR.

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

1. Nella console Google Cloud, apri Cloud Shell.

   Attivare 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 alla VPC predefinita:

   $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 della 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 per l'utilizzo 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 le regole firewall per consentire la comunicazione di Active Directory all'interno del VPC.

1. Consenti le 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 le 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 inoltro DNS privata.

3. Consenti la replica di Active Directory tra i 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
   

4. Consenti gli accessi di Active Directory dalle VM 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 sicure dalle VM che si trovano nella sottorete 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 Secure LDAP.

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 VPC condiviso creato in precedenza. Poi utilizzi il progetto di servizio per eseguire il deployment di 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 dei controller di dominio 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:

• Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1)
• Amministratore account di servizio (roles/iam.serviceAccountAdmin)
• Utente account di servizio (roles/iam.serviceAccountUser)
• Amministratore di 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 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 PowerShell, apri Cloud Shell.

   Attivare 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 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: il nome della rete VPC condiviso creata in precedenza.
   • REGION: regione in cui eseguire il deployment dei controller di dominio Active Directory. Tieni presente che i nomi delle zone si basano sui nomi delle regioni specificate. 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"
   

Creare una zona di inoltro DNS privata

Ora prenota due indirizzi IP statici per i controller di dominio e crea una zona di inoltro DNS privata 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 privata Cloud DNS nel progetto host VPC e configurala in modo da 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 archiviala in Secret Manager. Poi, devi concedere alle VM del controller di dominio l'accesso temporaneo a questo segreto in modo che possano utilizzarlo per eseguire il deployment della foresta Active Directory.

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

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

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

Esegui il deployment dei controller di dominio

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

1. In PowerShell, esegui il seguente 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 $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.
   • Esegui la promozione della VM a un controller di dominio.
   • Configura le impostazioni DNS in modo che ogni controller di dominio utilizzi l'indirizzo 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 l'account di servizio ad-domaincontroller alla VM in modo che possa accedere alla password DSRM.
   • Configura l'agente ospite per disattivare l'amministratore dell'account. Per ulteriori informazioni sulla configurazione dell'agente guest, consulta Attivare e disattivare le funzionalità delle istanze Windows.
   • Lascia che la VM installi le funzionalità di Windows AD-Domain-Services e DNS durante la fase di specializzazione di sysprep.
   • Lascia che la VM esegua lo script di avvio che hai 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 la procedura 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 la procedura 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.

Connettiti a un controller di dominio

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

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 consentire alle VM di partecipare automaticamente a un dominio.
• Scopri di più sull'utilizzo di Active Directory su più firewall.