Questo documento mostra come configurare Active Directory e Compute Engine in modo che le istanze di macchine virtuali (VM) Windows possano unirsi automaticamente a un dominio Active Directory.
L'automazione del processo di aggiunta delle VM Windows ad Active Directory consente di semplificare il processo di provisioning dei server Windows. Questo approccio ti consente anche di sfruttare la scalabilità automatica senza sacrificare i vantaggi dell'utilizzo di Active Directory per gestire l'accesso e la configurazione.
Questo documento è rivolto agli amministratori di sistema e presuppone che tu abbia familiarità con Active Directory e il networking di Google Cloud .
La configurazione che crei seguendo la procedura descritta in questo documento può essere la base di un lavoro aggiuntivo che svolgi con Windows Server in Google Cloud. Ad esempio, dopo aver completato questa procedura, puoi eseguire il deployment di applicazioni ASP.NET con l'autenticazione Windows nei container Windows.
Se utilizzi Managed Microsoft AD e non hai bisogno della pulizia automatica degli account computer inattivi, valuta la possibilità di unire le VM Windows utilizzando la funzionalità di unione automatica al dominio. Per ulteriori informazioni, vedi Aggiungi automaticamente una VM Windows a un dominio.
Obiettivi
- Esegui il deployment di un'app Cloud Run che consente alle istanze VM dei progetti selezionati di unirsi automaticamente al tuo dominio Active Directory.
- Crea un job Cloud Scheduler che esegue periodicamente la scansione del tuo dominio Active Directory alla ricerca di account computer inattivi e li rimuove.
- Testa la configurazione creando un gruppo di istanze gestite (MIG) con scalabilità automatica di istanze VM aggiunte al dominio.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
Le istruzioni riportate in questo documento sono progettate per mantenere l'utilizzo delle risorse entro i limiti del livello Always Free di Google Cloud.
Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.
Al termine di questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse create. Per ulteriori informazioni, consulta Esegui la pulizia.
Prima di iniziare
Questo documento presuppone che tu abbia già eseguito il deployment di Active Directory su Google Cloud utilizzando Managed Service for Microsoft Active Directory (Managed Microsoft AD) o eseguendo il deployment di domain controller autogestiti su Google Cloud.
Per completare le procedure, assicurati di disporre di quanto segue:
- Accesso amministrativo al dominio Active Directory, inclusa la possibilità di creare utenti, gruppi e unità organizzative (UO).
- Un intervallo IP CIDR /28 non utilizzato nel VPC in cui sono distribuiti i domain controller Active Directory. Utilizza questo intervallo IP per configurare l'accesso VPC serverless.
- Una subnet in cui eseguire il deployment delle istanze Windows. La subnet deve essere configurata per utilizzare l'accesso privato Google.
Se utilizzi un domain controller autogestito, devi disporre anche di quanto segue:
- Una zona di forwarding DNS privato che inoltra le query DNS ai domain controller Active Directory.
Implementazione di questo approccio
In un ambiente on-premise, potresti fare affidamento sui
file di risposta
(unattend.xml) e sulla
personalizzazione di JoinDomain
per aggiungere automaticamente nuovi computer a un dominio. Sebbene tu possa utilizzare lo stesso processo in Google Cloud, questo approccio presenta diverse limitazioni:
- L'utilizzo di un file
unattend.xmlpersonalizzato richiede la gestione di un'immagine Compute Engine personalizzata. Per mantenere aggiornata un'immagine personalizzata utilizzando Windows Update, è necessaria una manutenzione continua o un lavoro iniziale per configurare l'automazione. A meno che tu non debba mantenere un'immagine personalizzata per altri motivi, questo sforzo aggiuntivo potrebbe non essere giustificato. - L'utilizzo della personalizzazione
JoinDomainassocia un'immagine a un singolo dominio Active Directory perché il nome di dominio deve essere specificato inunattend.xml. Se gestisci più domini o foreste Active Directory (ad esempio, per ambienti di test e di produzione separati), potresti dover gestire più immagini personalizzate per ogni dominio. - Per unire un computer Windows a un dominio sono necessarie le credenziali utente con le autorizzazioni per creare un oggetto computer nella directory. Se utilizzi la personalizzazione
JoinDomaininunattend.xml, devi incorporare queste credenziali come testo non crittografato inunattend.xml. Queste credenziali incorporate possono trasformare l'immagine in un potenziale bersaglio per gli utenti malintenzionati. Sebbene tu possa controllare l'accesso all'immagine impostando le autorizzazioni di Identity and Access Management (IAM) appropriate, la gestione dell'accesso a un'immagine personalizzata aggiunge una complessità non necessaria.
L'approccio descritto in questo documento non utilizza file di risposta e pertanto non richiede immagini preparate in modo speciale. Utilizza invece il seguente scriptlet di specializzazione sysprep quando crei un'istanza VM:
iex((New-Object System.Net.WebClient).DownloadString('https://DOMAIN'))
Questo scriptlet di specializzazione sysprep avvia un processo illustrato nel seguente diagramma.
La procedura funziona nel seguente modo:
- Dopo aver creato un'istanza VM, Windows viene avviato per la prima volta. Nell'ambito della fase di configurazione specialize, Windows esegue lo scriptlet sysprep specialize. Lo scriptlet specialize richiama l'app Cloud Run
register-computere scarica uno script PowerShell che controlla il processo di aggiunta al dominio. - Windows richiama lo script PowerShell scaricato.
- Lo script PowerShell chiama il server di metadati per ottenere un token ID che identifica in modo sicuro l'istanza VM.
- Lo script chiama nuovamente l'app
register-computer, passando il token ID per autenticarsi. - L'app convalida il token ID ed estrae il nome, la zona e l' Google Cloud ID progetto dell'istanza VM.
- L'app verifica che il dominio Active Directory sia configurato per consentire alle istanze VM del progetto specificato di unirsi al dominio. Per completare questa verifica, l'app individua e si connette a un domain controller Active Directory per verificare la presenza di un'unità organizzativa (UO) il cui nome corrisponde all'ID progetto Google Cloud dal token ID. Se viene trovata una UO corrispondente, le istanze VM del progetto sono autorizzate a unirsi al dominio Active Directory nell'UO specificata.
- L'app verifica che il progetto Google Cloud sia configurato per consentire alle istanze VM di unirsi ad Active Directory. Per completare questa verifica, l'app controlla se può accedere all'istanza VM utilizzando l'API Compute Engine.
- Se tutti i controlli vengono superati, l'app esegue la pre-installazione di un account computer in Active Directory. L'app salva il nome, la zona e l'ID dell'istanza VM come attributi nell'oggetto account computer in modo che possa essere associato all'istanza VM.
- Utilizzando il protocollo di impostazione della password Kerberos, l'app assegna una password casuale all'account computer.
- Il nome e la password del computer vengono restituiti all'istanza Windows tramite un canale sicuro protetto da TLS.
- Utilizzando l'account del computer preconfigurato, lo script di PowerShell unisce il computer al dominio.
- Al termine della fase di configurazione specialize, la macchina si riavvia.
Il resto di questa procedura illustra i passaggi necessari per configurare l'unione automatica dei domini.
Preparazione del dominio Active Directory
Innanzitutto, devi preparare il dominio Active Directory. Per completare questo passaggio, devi disporre di un computer con accesso amministrativo al tuo dominio Active Directory.
(Facoltativo) Limita gli utenti che possono unire computer al dominio
Potresti voler limitare gli utenti che possono unire computer al dominio. Per impostazione predefinita, la configurazione dell'oggetto Criteri di gruppo (GPO) per il criterio del domain controller predefinito concede il diritto utente Add workstations to domain a tutti gli utenti autenticati.
Chiunque disponga di questo diritto utente può unire computer al dominio. Poiché stai automatizzando il processo di unione dei computer al tuo dominio Active Directory, concedere universalmente questo livello di accesso è un rischio per la sicurezza non necessario.
Per limitare gli utenti che possono unire computer al tuo dominio Active Directory, modifica la configurazione predefinita del GPO Default Domain Controller Policy:
- Utilizzando un client RDP, accedi a una macchina che dispone dell'accesso amministrativo al tuo dominio Active Directory.
- Apri la Console Gestione Criteri di gruppo (GPMC).
- Vai a Foresta > Domini > domain-name > Oggetti Criteri di gruppo, dove domain-name è il nome del tuo dominio Active Directory.
- Fai clic con il tasto destro del mouse su Default Domain Controller Policy (Policy predefinita del domain controller) e poi su Edit (Modifica).
- Nella console Editor Gestione Criteri di gruppo, vai a Configurazione computer > Criteri > Impostazioni di Windows > Impostazioni di sicurezza > Criteri locali > Assegnazione diritti utente.
- Fai doppio clic su Aggiungi workstation al dominio.
- In Proprietà, rimuovi Utenti autenticati dall'elenco.
- Per consentire agli amministratori di accedere manualmente al dominio (facoltativo), fai clic su Aggiungi utente o gruppo, quindi aggiungi un gruppo amministrativo all'elenco.
- Fai clic su OK.
Ora puoi chiudere la console dell'Editor Gestione Criteri di gruppo e la GPMC.
Inizializza una struttura di directory
Ora devi creare un'UO che funga da container per tutte le UO specifiche del progetto:
- Utilizzando un client RDP, accedi a una macchina che dispone dell'accesso amministrativo al tuo dominio Active Directory.
- Apri una sessione di PowerShell con privilegi elevati.
Crea una nuova unità organizzativa:
$ParentOrgUnitPath = (Get-ADDomain).ComputersContainer $ProjectsOrgUnitPath = New-ADOrganizationalUnit ` -Name 'Projects' ` -Path $ParentOrgUnitPath ` -PassThru
Crea un account utente Active Directory
Per accedere ad Active Directory e preconfigurare gli account computer, l'app register-computer
ha bisogno di un account utente Active Directory:
Crea un account utente Active Directory denominato
register-computer, assegna una password casuale e inseriscilo nell'UOProjects:# Generate a random password Add-Type -AssemblyName System.Web $Password = [System.Web.Security.Membership]::GeneratePassword(64, 3) # Create user $UpnSuffix = (Get-ADDomain).DNSRoot $RegisterComputerUser = New-ADUser ` -Name "register-computer Cloud Run app" ` -GivenName "Register" ` -Surname "Computer" ` -Path $ProjectsOrgUnitPath ` -SamAccountName "register-computer" ` -UserPrincipalName "register-computer@$UpnSuffix" ` -AccountPassword (ConvertTo-SecureString "$Password" -AsPlainText -Force) ` -PasswordNeverExpires $True ` -Enabled $True ` -PassThruConcedi all'account
register-computerl'insieme minimo di autorizzazioni necessarie per gestire gli account e i gruppi di computer nell'UOProjectse nelle UO secondarie:$AcesForContainerAndDescendents = @( "CCDC;Computer", # Create/delete computers "CCDC;Group" # Create/delete users ) $AcesForDescendents = @( "LC;;Computer" , # List child objects "RC;;Computer" , # Read security information "WD;;Computer" , # Change security information "WP;;Computer" , # Write properties "RP;;Computer" , # Read properties "CA;Reset Password;Computer", # ... "CA;Change Password;Computer", # ... "WS;Validated write to service principal name;Computer", "WS;Validated write to DNS host name;Computer", "LC;;Group", # List child objects "RC;;Group", # Read security information "WD;;Group", # Change security information "WP;;Group", # Write properties "RP;;Group" # Read properties ) $AcesForContainerAndDescendents | % { dsacls.exe $ProjectsOrgUnitPath /G "${RegisterComputerUser}:${_}" /I:T | Out-Null } $AcesForDescendents | % { dsacls.exe $ProjectsOrgUnitPath /G "${RegisterComputerUser}:${_}" /I:S | Out-Null }Il completamento di questo comando potrebbe richiedere alcuni minuti.
Concedi all'account
register-computerl'autorizzazione per eliminare i record DNS:Microsoft Active Directory gestito
Add-ADGroupMember -Identity "Cloud Service DNS Administrators" -Members ${RegisterComputerUser}Dominio autogestito
$DnsPartition=(Get-ADDomain).SubordinateReferences | Where-Object {$_.StartsWith('DC=DomainDnsZones')} $DnsContainer="DC=$((Get-ADDomain).DNSRoot),CN=MicrosoftDNS,$DnsPartition" dsacls $DnsContainer /G "${RegisterComputerUser}:SD" /I:SMostra il percorso dell'UO
Projectse la password generata dell'account utente Active Directoryregister-computer. Prendi nota dei valori, perché ti serviranno in un secondo momento.Write-Host "Password: $Password" Write-Host "Projects OU: $ProjectsOrgUnitPath"
Preparazione del progetto Google Cloud
Ora configura il progetto di dominio:
- Se utilizzi Managed Microsoft AD, il progetto di dominio è quello in cui hai eseguito il deployment di Managed Microsoft AD.
- Se utilizzi Active Directory autogestito, il progetto di dominio è il progetto che esegue i domain controller Active Directory. Nel caso di un VPC condiviso, questo progetto deve essere lo stesso del progetto host VPC.
Utilizza questo progetto di dominio per:
- Crea un secret di Secret Manager contenente la password dell'account utente Active Directory
register-computer. - Esegui il deployment dell'app
register-computer. - Configura Cloud Scheduler in modo che attivi le pulizie degli account computer obsoleti.
Ti consigliamo di concedere l'accesso al progetto di dominio in base al principio del privilegio minimo.
Crea un secret di Secret Manager
Nella console Google Cloud , apri Cloud Shell.
Avvia PowerShell:
pwsh
Inizializza la seguente variabile, sostituendo
domain-project-idcon l'ID del progetto di dominio:$DomainProjectId = "
domain-project-id"Imposta il progetto di dominio come progetto predefinito:
& gcloud config set project $DomainProjectId
Abilita l'API Secret Manager:
& gcloud services enable secretmanager.googleapis.com
Inserisci la password dell'account utente Active Directory
register-computere archiviala in un secret di Secret Manager:$RegisterComputerCredential = (Get-Credential -Credential 'register-computer') $TempFile = New-TemporaryFile Set-Content $TempFile $($RegisterComputerCredential.GetNetworkCredential().Password) -NoNewLine & gcloud secrets create ad-password --data-file $TempFile Remove-Item $TempFile
Concedi l'accesso a Kerberos e LDAP
Per gestire i join di dominio, l'app register-computer accede ai domain controller utilizzando i seguenti protocolli:
- LDAP (TCP/389) o LDAPS (TCP/636)
- Kerberos (UDP/88, TCP/88)
Modifica della password Kerberos (UDP/464, TCP/464)
Microsoft Active Directory gestito
Non è necessario configurare regole firewall.
Dominio autogestito
Crea una regola firewall che consenta l'accesso ai domain controller.
Puoi applicare la regola in base a un tag di rete che hai assegnato ai domain controller oppure puoi applicarla utilizzando un account di servizio.
Per tag di rete
& gcloud compute firewall-rules create allow-adkrb-from-serverless-to-dc `
--direction INGRESS `
--action allow `
--rules udp:88,tcp:88,tcp:389,tcp:636,udp:464,tcp:464 `
--source-ranges $ServerlessIpRange `
--target-tags dc-tag `
--network $VpcName `
--project vpc-project-id `
--priority 10000
Sostituisci quanto segue:
dc-tag: il tag di rete assegnato alle VM del domain controller.vpc-project-id: l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; altrimenti, utilizza l'ID del progetto di dominio.
Per account di servizio
& gcloud compute firewall-rules create allow-adkrb-from-serverless-to-dc `
--direction INGRESS `
--action allow `
--rules udp:88,tcp:88,tcp:389,tcp:636,udp:464,tcp:464 `
--source-ranges $ServerlessIpRange `
--target-service-accounts dc-sa `
--network $VpcName `
--project vpc-project-id `
--priority 10000
Sostituisci quanto segue:
dc-sa: l'indirizzo email del service account utilizzato dalle VM del domain controller.vpc-project-id: l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; altrimenti, utilizza l'ID del progetto di dominio.
Esegui il deployment dell'app Cloud Run
Ora configura Cloud Build per eseguire il deployment dell'app register-computer in Cloud Run:
In Cloud Shell, clona il repository GitHub:
& git clone https://github.com/GoogleCloudPlatform/gce-automated-ad-join.git cd gce-automated-ad-join/ad-joining
Inizializza le seguenti variabili:
$ServerlessRegion = "
serverless-region" $VpcName = "vpc-name" $VpcSubnet = "subnet-name" $AdDomain = "dns-domain-name" $AdNetbiosDomain = "netbios-domain-name" $ProjectsOrgUnitPath = "projects-ou-distinguished-name"Sostituisci quanto segue:
serverless-region: la regione in cui eseguire il deployment dell'appregister-computer. La regione non deve necessariamente essere la stessa in cui prevedi di eseguire il deployment delle istanze VM.vpc-name: il nome della rete VPC che contiene i domain controller Active Directory.subnet-name: la subnet divpc-nameda utilizzare per l'accesso VPC diretto. La subnet deve trovarsi nella stessa regione diserverless-region.dns-domain-name: il nome di dominio DNS del tuo dominio Active Directory.netbios-domain-name: il nome NetBIOS del tuo dominio Active Directory.projects-ou-distinguished-name: il nome distinto della tua UOProjects.
Abilita le API Cloud Run e Cloud Build:
& gcloud services enable run.googleapis.com cloudbuild.googleapis.com
Crea un account di servizio
register-computer-appper l'app Cloud Run:& gcloud iam service-accounts create register-computer-app ` --display-name="register computer Cloud Run app"
Crea un account di servizio
build-serviceper l'esecuzione dei trigger di build di Cloud Build:& gcloud iam service-accounts create build-service ` --display-name="Cloud Build build agent"
Consenti al account di servizio Cloud Run di leggere il secret che contiene la password di Active Directory:
& gcloud secrets add-iam-policy-binding ad-password ` --member "serviceAccount:register-computer-app@$DomainProjectId.iam.gserviceaccount.com" ` --role "roles/secretmanager.secretAccessor"
Concedi a Cloud Build le autorizzazioni necessarie per eseguire il deployment in Cloud Run:
$DomainProjectNumber = (gcloud projects describe $DomainProjectId --format='value(projectNumber)') & gcloud iam service-accounts add-iam-policy-binding register-computer-app@$DomainProjectId.iam.gserviceaccount.com ` --member "serviceAccount:build-service@$DomainProjectId.iam.gserviceaccount.com" ` --role "roles/iam.serviceAccountUser" & gcloud projects add-iam-policy-binding $DomainProjectId ` --member "serviceAccount:build-service@$DomainProjectId.iam.gserviceaccount.com" ` --role roles/cloudbuild.builds.builder & gcloud projects add-iam-policy-binding $DomainProjectId ` --member "serviceAccount:build-service@$DomainProjectId.iam.gserviceaccount.com" ` --role roles/run.admin
Utilizza il file
cloudbuild.yamlcome modello per creare una configurazione di build di Cloud Run personalizzata che corrisponda al tuo ambiente:$Build = (Get-Content cloudbuild.yaml) $Build = $Build.Replace('__SERVERLESS_REGION__', "$ServerlessRegion") $Build = $Build.Replace('__PROJECTS_DN__', "$ProjectsOrgUnitPath") $Build = $Build.Replace('__AD_DOMAIN__', "$AdDomain") $Build = $Build.Replace('__AD_NETBIOS_DOMAIN__', "$AdNetbiosDomain") $Build = $Build.Replace('__SERVICE_ACCOUNT_EMAIL__', "register-computer-app@$DomainProjectId.iam.gserviceaccount.com") $Build = $Build.Replace('__SERVERLESS_NETWORK__', "$VpcName") $Build = $Build.Replace('__SERVERLESS_SUBNET__', "$VpcSubnet") $Build | Set-Content .\cloudbuild.hydrated.yamlCrea l'app ed eseguine il deployment in Cloud Run:
& gcloud builds submit . ` --config cloudbuild.hydrated.yaml ` --substitutions _IMAGE_TAG=$(git rev-parse --short HEAD) ` --service-account "projects/$DomainProjectId/serviceAccounts/build-service@$DomainProjectId.iam.gserviceaccount.com" ` --default-buckets-behavior regional-user-owned-bucket
Il completamento del deployment può richiedere un paio di minuti.
Determina l'URL dell'app Cloud Run:
$RegisterUrl = (gcloud run services describe register-computer ` --platform managed ` --region $ServerlessRegion ` --format=value`(status.url`)) Write-Host $RegisterUrl
Prendi nota dell'URL. Ti servirà ogni volta che crei un'istanza VM che deve essere unita ad Active Directory.
Richiama l'app Cloud Run per verificare che il deployment sia stato eseguito correttamente:
Invoke-RestMethod $RegisterUrl
Viene visualizzato uno script di PowerShell. La VM esegue questo script durante la fase di specializzazione che la unisce al dominio.
Abilitazione di un progetto per l'unione automatica al dominio
L'app register-computer non consente alle istanze VM di unirsi a un dominio Active Directory, a meno che il progetto della VM non sia abilitato per l'unione automatica al dominio. Questa misura di sicurezza contribuisce a impedire alle VM connesse a progetti non autorizzati di accedere al tuo dominio.
Per abilitare un progetto per l'unione automatica al dominio, devi:
- Crea un'UO in Active Directory con un nome corrispondente all'ID progettoGoogle Cloud .
- Concedi all'app
register-computerl'accesso al progettoGoogle Cloud .
Innanzitutto, crea la UO:
- Utilizzando un client RDP, accedi a una macchina che dispone dell'accesso amministrativo al tuo dominio Active Directory.
- Nello snap-in MMC Utenti e computer di Active Directory, vai alla UO
Projects. - Fai clic con il tasto destro del mouse sulla UO e seleziona Nuovo > Unità organizzativa.
- Nella finestra di dialogo Nuovo oggetto, inserisci l'ID del progettoGoogle Cloud in cui eseguire il deployment delle VM.
- Fai clic su OK.
Successivamente, concedi all'app register-computer l'accesso al progettoGoogle Cloud :
In Cloud Shell, avvia PowerShell:
pwsh
Inizializza le seguenti variabili:
$ProjectId = "
project-id" $DomainProjectId = "domain-project-id"Sostituisci
project-idcon l'ID del progettoGoogle Cloud in cui eseguire il deployment delle VMdomain-project-idcon l'ID del progetto di dominio
Concedi al account di servizio
register-computer-appil ruoloCompute Viewersul progetto:& gcloud projects add-iam-policy-binding $ProjectId ` --member "serviceAccount:register-computer-app@$DomainProjectId.iam.gserviceaccount.com" ` --role "roles/compute.viewer"
Il tuo progetto è ora pronto per supportare l'unione automatica al dominio.
Test dell'unione al dominio
Ora puoi verificare che la configurazione funzioni correttamente:
- Creazione di una singola istanza VM che si unisce automaticamente al dominio Active Directory
- Creazione di un gruppo di istanze gestite di istanze VM che entrano automaticamente nel dominio Active Directory
Crea e unisci una singola istanza VM
Crea un'istanza VM che si unisce automaticamente al dominio Active Directory:
Torna alla sessione PowerShell in Cloud Shell e inizializza le seguenti variabili:
$Region = "vpc-region-to-deploy-vm" $Zone = "zone-to-deploy-vm" $Subnet = "vpc-subnet-to-deploy-vm" $ServerlessRegion = "
serverless-region"Sostituisci quanto segue:
vpc-region-to-deploy-vm: la regione in cui eseguire il deployment dell'istanza VM.vpc-subnet-to-deploy-vm: la subnet in cui eseguire il deployment dell'istanza VM.zone-to-deploy-vm: la zona in cui eseguire il deployment dell'istanza VM.serverless-region: la regione in cui hai eseguito il deployment dell'app Cloud Run.
Imposta il progetto e la zona predefiniti:
& gcloud config set project $ProjectId & gcloud config set compute/zone $Zone
Cerca di nuovo l'URL dell'app Cloud Run:
$RegisterUrl = (gcloud run services describe register-computer ` --platform managed ` --region $ServerlessRegion ` --format value`(status.url`) ` --project $DomainProjectId)
Crea un'istanza passando lo scriptlet di specializzazione che fa sì che la VM si unisca al dominio:
VPC condiviso
$VpchostProjectId = (gcloud compute shared-vpc get-host-project $ProjectId --format=value`(name`)) & gcloud compute instances create join-01 ` --image-family windows-2025-core ` --image-project windows-cloud ` --machine-type n2-standard-2 ` --no-address ` --subnet projects/$VpchostProjectId/regions/$Region/subnetworks/$Subnet ` --metadata "sysprep-specialize-script-ps1=iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))"VPC autonomo
& gcloud compute instances create join-01 ` --image-family=windows-2025-core ` --image-project=windows-cloud ` --machine-type=n2-standard-2 ` --no-address ` --subnet $Subnet ` --metadata "sysprep-specialize-script-ps1=iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))"Se vuoi utilizzare un nome host personalizzato, aggiungi un parametro
--hostnameal comando.Se utilizzi una versione di Windows Server precedente a Windows Server 2019, TLS 1.2 potrebbe essere disattivato per impostazione predefinita, il che può causare l'errore dello scriptlet di specializzazione. Per abilitare TLS 1.2, utilizza invece il seguente scriptlet:
[Net.ServicePointManager]::SecurityProtocol=[Net.SecurityProtocolType]::Tls12;iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))Monitora il processo di avvio:
& gcloud compute instances tail-serial-port-output join-01
Dopo circa un minuto, la macchina viene aggiunta al tuo dominio Active Directory. L'output è simile al seguente:
Domain : corp.example.com DomainController : dc-01.corp.example.com. OrgUnitPath : OU=test-project-123,OU=Projects,DC=corp,DC=example,DC=com WARNING: The changes will take effect after you restart the computer Computer successfully joined to domain
Per interrompere l'osservazione del processo di avvio, premi
CTRL+C.
Verifica che la VM sia unita ad Active Directory
- Utilizzando un client RDP, accedi a una macchina che dispone dell'accesso amministrativo al tuo dominio Active Directory.
- Apri lo snap-in MMC Utenti e computer di Active Directory.
- Nel menu, assicurati che l'opzione Visualizza > Funzionalità avanzate sia attiva.
- Vai alla UO con il nome dell'ID progetto Google Cloud in cui hai creato un'istanza VM.
- Fai doppio clic sull'account
join-01. Nella finestra di dialogo Properties (Proprietà), fai clic sulla scheda Attribute Editor (Editor attributi).
L'account del computer è annotato con attributi LDAP aggiuntivi. Questi attributi ti consentono di monitorare l'associazione tra l'oggetto computer e l'istanza Compute Engine.
Verifica che l'elenco contenga i seguenti attributi e valori LDAP.
Attributo LDAP Valore msDS-cloudExtensionAttribute1ID progettoGoogle Cloud msDS-cloudExtensionAttribute2Zona Compute Engine msDS-cloudExtensionAttribute3Nome istanza Compute Engine Gli attributi
msDS-cloudExtensionAttributesono attributi per uso generico e non vengono utilizzati da Active Directory.
Diagnostica gli errori
Se l'istanza VM non è riuscita ad aggiungersi al dominio, controlla il log dell'app register-computer:
Nella console Google Cloud , vai a Cloud Run.
Fai clic sull'app
register-computer.Nel menu, fai clic su Log.
Elimina l'istanza
Dopo aver verificato che l'istanza VM è unita al dominio Active Directory, elimina l'istanza.
Elimina l'istanza:
& gcloud compute instances delete join-01 --quiet
Crea un gruppo di istanze gestite e unisciti al gruppo
Puoi anche verificare che le istanze di un MIG possano unirsi automaticamente al tuo dominio.
Crea un template di istanza passando lo script di specializzazione che fa sì che la VM si unisca al dominio:
VPC condiviso
$VpchostProjectId = (gcloud compute shared-vpc get-host-project $ProjectId --format=value`(name`)) & gcloud compute instance-templates create ad-2019core-n2-std-2 ` --image-family windows-2025-core ` --image-project windows-cloud ` --no-address ` --machine-type n2-standard-2 ` --subnet projects/$VpchostProjectId/regions/$Region/subnetworks/$Subnet ` --metadata "sysprep-specialize-script-ps1=iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))"VPC autonomo
& gcloud compute instance-templates create ad-2019core-n2-std-2 ` --image-family windows-2025-core ` --image-project windows-cloud ` --no-address ` --machine-type n2-standard-2 ` --subnet projects/$ProjectId/regions/$Region/subnetworks/$Subnet ` --metadata "sysprep-specialize-script-ps1=iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))"Crea un gruppo di istanze gestite che utilizza il template di istanza:
& gcloud compute instance-groups managed create group-01 ` --template ad-2019core-n2-std-2 ` --size=3
Attendi qualche minuto, quindi utilizza lo snap-in MMC Utenti e computer di Active Directory per verificare che in Active Directory siano stati creati quattro nuovi oggetti:
- 3 account computer corrispondenti alle 3 istanze VM del gruppo di istanze gestite.
- 1 gruppo denominato
group-01che contiene i 3 account computer. Se prevedi di utilizzare service account gestiti di gruppo (gMSA), puoi utilizzare questo gruppo per concedere l'accesso ai gMSA.
Dopo aver verificato che le istanze VM dei tuoi MIG possono unirsi al tuo dominio Active Directory, puoi eliminare il gruppo gestito e il template di istanza seguendo questi passaggi:
In Cloud Shell, elimina il gruppo di istanze:
& gcloud compute instance-groups managed delete group-01 --quiet
Elimina il template di istanza:
& gcloud compute instance-templates delete ad-2019core-n2-std-2 --quiet
Pianificazione della pulizia degli account computer obsoleti
L'automazione del processo di unione dei computer al dominio riduce l'impegno necessario per configurare nuovi server e consente di utilizzare i server uniti al dominio nei gruppi di istanze gestite. Tuttavia, nel tempo, nel dominio possono accumularsi account computer obsoleti.
Per evitare questo accumulo, ti consigliamo di configurare l'app register-computer in modo che esegua periodicamente la scansione del tuo dominio Active Directory per trovare e rimuovere automaticamente gli account inattivi e i record DNS associati.
L'app register-computer può utilizzare gli attributi msDS-cloudExtensionAttribute degli account computer per identificare quali account computer sono inattivi. Questi attributi contengono il progetto, la zona e il nome dell'istanza VM corrispondente in Compute Engine. Per ogni account computer, l'app può verificare se l'istanza VM corrispondente è ancora disponibile. In caso contrario, l'account del computer viene considerato inattivo e rimosso.
Per attivare una pulizia degli account computer, richiama l'endpoint /cleanup dell'app Cloud Run. Per impedire agli utenti non autorizzati di attivare una pulizia, questa richiesta deve essere autenticata utilizzando il account di servizio register-computer-app.
Configura Cloud Scheduler
I passaggi seguenti mostrano come configurare Cloud Scheduler insieme a Pub/Sub per attivare automaticamente una pulizia una volta ogni 24 ore:
In Cloud Shell, abilita l'API Cloud Scheduler nel progetto del tuo dominio:
& gcloud services enable cloudscheduler.googleapis.com
Imposta
AppEngineLocationsu una località di App Engine valida in cui eseguire il deployment di Cloud Scheduler:$AppEngineLocation = "
location"Sostituisci
locationcon la regione App Engine che hai selezionato per le tue risorse VPC, ad esempious-central. Se questa regione non è disponibile come località di App Engine, scegli una località geograficamente vicina a te. Per maggiori informazioni, consulta Regioni e zone.Inizializza App Engine:
& gcloud app create --region $AppEngineLocation --project $DomainProjectId
Crea un job Cloud Scheduler:
& gcloud scheduler jobs create http cleanup-computer-accounts ` --schedule "every 24 hours" ` --uri "$RegisterUrl/cleanup" ` --oidc-service-account-email register-computer-app@$DomainProjectId.iam.gserviceaccount.com ` --oidc-token-audience "$RegisterUrl/" ` --project $DomainProjectIdQuesto job chiama l'app
register-computeruna volta ogni 24 ore e utilizza l'account di servizioregister-computer-appper l'autenticazione.
Attiva una pulizia
Per verificare la configurazione per la pulizia degli account computer inattivi, puoi attivare manualmente il job Cloud Scheduler.
Nella console Google Cloud , vai a Cloud Scheduler.
Per il job
cleanup-computer-accountsche hai creato, fai clic su Esegui ora.Dopo alcuni secondi, nella colonna Risultato viene visualizzato Operazione riuscita, a indicare che la pulizia è stata completata correttamente. Se la colonna dei risultati non si aggiorna automaticamente entro pochi secondi, fai clic sul pulsante Aggiorna.
Per maggiori dettagli sugli account che sono stati ripuliti, controlla i log dell'app register-computer.
Nella console Google Cloud , vai a Cloud Run.
Fai clic sull'app
register-computer.Nel menu, fai clic su Log.
Le voci di log indicano che gli account computer delle istanze VM utilizzate per testare l'unione al dominio sono stati identificati come inattivi e rimossi.
Esegui la pulizia
Se utilizzi questo documento come base per altre architetture di riferimento e deployment, leggi gli altri documenti per sapere quando eseguire i passaggi di pulizia.
Se non vuoi mantenere la configurazione Google Cloud utilizzata in questo documento, puoi ripristinarla nel seguente modo:
In Cloud Shell, elimina il job Cloud Scheduler:
& gcloud scheduler jobs delete cleanup-computer-accounts ` --project $DomainProjectId
Elimina l'app Cloud Run:
& gcloud run services delete register-computer ` --platform managed ` --project $DomainProjectId ` --region $ServerlessRegion
Elimina il secret di Secret Manager:
gcloud secrets delete ad-password --project $DomainProjectId
Elimina la regola firewall per l'accesso LDAP e Kerberos:
gcloud compute firewall-rules delete allow-adkrb-from-serverless-to-dc --project=
vpc-project-idSostituisci
vpc-project-idcon l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; altrimenti, utilizza l'ID del progetto di dominio.
Ripristina le modifiche di Active Directory
- Utilizzando un client RDP, accedi a una macchina che dispone dell'accesso amministrativo al tuo dominio Active Directory.
- Nello snap-in MMC Utenti e computer di Active Directory, vai alla UO
Projects. - Elimina l'account utente Active Directory
register-computer. - Elimina l'UO che hai creato per testare l'unione automatica al dominio.
Passaggi successivi
- Per unire le VM Windows a un dominio Managed Microsoft AD utilizzando l'unione automatica al dominio, consulta Aggiungi automaticamente una VM Windows a un dominio.
- Consulta le nostre best practice per il deployment di una foresta di risorse Active Directory su Google Cloud.
- Per ulteriori architetture di riferimento, diagrammi e best practice, esplora Cloud Architecture Center.