Configurazione di Active Directory per l'aggiunta automatica delle VM a un dominio


Questo tutorial mostra come configurare Active Directory e Compute Engine in modo che le istanze di macchine virtuali (VM) Windows possano aggiungere automaticamente un dominio Active Directory.

L'automazione del processo di unione delle VM Windows ad Active Directory consente di semplificare il processo di provisioning dei server Windows. L'approccio consente inoltre di sfruttare la scalabilità automatica senza sacrificare i vantaggi dell'utilizzo di Active Directory per gestire l'accesso e la configurazione.

Questo tutorial è destinato agli amministratori di sistema e presuppone che tu conosca già Active Directory e il networking di Google Cloud.

La configurazione creata in questo tutorial può essere la base per il lavoro aggiuntivo svolto con i server Windows in Google Cloud. Ad esempio, al termine di questo tutorial, puoi eseguire il deployment delle applicazioni ASP.NET con l'autenticazione Windows in container Windows.

Se utilizzi Microsoft AD gestito e non hai bisogno della pulizia automatica degli account computer inattivi, valuta la possibilità di unire le VM Windows utilizzando la funzionalità di aggiunta automatica dei domini. Per ulteriori informazioni, consulta Unire automaticamente una VM Windows a un dominio.

Obiettivi

  • Esegui il deployment di un'app Cloud Run che consenta alle istanze VM di progetti selezionati di aggiungere automaticamente il tuo dominio Active Directory.
  • Crea un job Cloud Scheduler che analizzi periodicamente il tuo dominio Active Directory per individuare account di computer inattivi e li rimuove.
  • Verifica la configurazione creando un gruppo di istanze gestite con scalabilità automatica di istanze VM aggiunte al dominio.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Le istruzioni 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. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

Questo tutorial presuppone che tu abbia già eseguito il deployment di Active Directory in Google Cloud utilizzando Managed Service for Microsoft Active Directory (Managed Microsoft AD) o eseguendo il deployment di controller di dominio autogestiti su Google Cloud.

Per completare questo tutorial, assicurati di avere quanto segue:

  • Accesso amministrativo al dominio Active Directory, inclusa la possibilità di creare utenti, gruppi e unità organizzative (UO).
  • Un intervallo IP CIDR /28 inutilizzato nel VPC in cui viene eseguito il deployment dei controller di dominio Active Directory. che serve per configurare l'accesso VPC serverless.
  • Una subnet in cui esegui il deployment delle istanze Windows. La subnet deve essere configurata in modo da utilizzare l'accesso privato Google.

Se utilizzi un controller di dominio autogestito, devi disporre anche di quanto segue:

Implementazione di questo approccio

In un ambiente on-premise, è possibile utilizzare i file di risposta (unattend.xml) e la personalizzazione JoinDomain per aggiungere automaticamente nuovi computer a un dominio. Sebbene sia possibile utilizzare lo stesso processo in Google Cloud, questo approccio presenta diverse limitazioni:

  • L'utilizzo di un file unattend.xml personalizzato richiede la gestione di un'immagine Compute Engine personalizzata. Mantenere aggiornata un'immagine personalizzata con gli aggiornamenti di Windows richiede una manutenzione continua o un lavoro iniziale per configurare l'automazione. A meno che tu non abbia bisogno di gestire un'immagine personalizzata per altri motivi, questo sforzo aggiuntivo potrebbe non essere giustificato.
  • L'utilizzo della personalizzazione JoinDomain associa un'immagine a un singolo dominio Active Directory perché il nome di dominio deve essere specificato in unattend.xml. Se gestisci più domini o foreste di Active Directory (ad esempio, per ambienti di test e produzione separati), potrebbe essere necessario mantenere più immagini personalizzate per ogni dominio.
  • L'aggiunta di un computer Windows a un dominio richiede credenziali utente con autorizzazioni per creare un oggetto computer nella directory. Se utilizzi la personalizzazione JoinDomain in unattend.xml, devi incorporare queste credenziali come testo non crittografato in unattend.xml. Queste credenziali incorporate possono trasformare l'immagine in un potenziale bersaglio per gli utenti malintenzionati. Anche se puoi controllare l'accesso all'immagine impostando le autorizzazioni di Identity and Access Management (IAM) appropriate, la gestione dell'accesso a un'immagine personalizzata aggiunge complessità non necessarie.

L'approccio utilizzato in questo tutorial non utilizza file di risposta e, pertanto, non richiede immagini appositamente preparate. Utilizza invece il seguente scriptlet specialize sysprep quando crei un'istanza VM:

iex((New-Object System.Net.WebClient).DownloadString('https://[DOMAIN]'))

Questo scriptlet speciale sysprep avvia un processo illustrato nel seguente diagramma.

Processo avviato dallo scriptlet sysprep specialize.

La procedura funziona nel seguente modo:

  1. Dopo la creazione di un'istanza VM, Windows si avvia per la prima volta. Come parte del pass di configurazione Specialize, Windows esegue lo scriptlet Specialize sysprep. Lo scriptlet specializzato richiama l'app Cloud Run register-computer e scarica uno script PowerShell che controlla il processo di unione dei domini.
  2. Windows richiama lo script PowerShell scaricato.
  3. Lo script PowerShell chiama il server di metadati per ottenere un token ID che identifica in modo sicuro l'istanza VM.
  4. Lo script chiama di nuovo l'app register-computer, passando il token ID per l'autenticazione.
  5. L'app convalida il token ID ed estrae nome, zona e ID progetto Google Cloud dell'istanza VM.
  6. L'app verifica che il dominio Active Directory sia configurato in modo da consentire alle istanze VM del progetto specificato di unirsi al dominio. Per completare questa verifica, l'app individua e si connette a un controller di dominio Active Directory per cercare un'unità organizzativa (UO) il cui nome corrisponde all'ID progetto Google Cloud del token ID. Se viene trovata una UO corrispondente, le istanze VM del progetto sono autorizzate a far parte del dominio Active Directory nella UO specificata.
  7. L'app verifica che il progetto Google Cloud sia configurato in modo da consentire alle istanze VM di partecipare ad Active Directory. Per completare questa verifica, l'app controlla se può accedere all'istanza VM utilizzando l'API Compute Engine.
  8. Se tutti i controlli hanno esito positivo, l'app predispone un account computer in Active Directory. L'app salva il nome, la zona e l'ID dell'istanza VM come attributi nell'oggetto dell'account computer in modo che possa essere associata all'istanza VM.
  9. Utilizzando il protocollo per la configurazione della password Kerberos, l'app assegna quindi una password casuale all'account del computer.
  10. Il nome del computer e la password vengono restituiti all'istanza Windows su un canale protetto da TLS.
  11. Utilizzando l'account del computer fornito, lo script PowerShell unisce il computer al dominio.
  12. Una volta completato il pass per la configurazione Speciale, la macchina si riavvia da sola.

La parte restante di questo tutorial illustra i passaggi necessari per configurare l'unione automatica dei domini.

Preparazione del dominio Active Directory

Per prima cosa, prepara il tuo dominio Active Directory. Per completare questo passaggio, devi avere una macchina che dispone dell'accesso amministrativo al dominio Active Directory.

(Facoltativo) Limita gli utenti che possono aggiungere computer al dominio

Potrebbe essere opportuno limitare gli utenti che possono aggiungere computer al dominio. Per impostazione predefinita, la configurazione dell'oggetto Criteri di gruppo (GPO) per il criterio del controller di dominio predefinito concede il diritto utente Add workstations to domain a tutti gli utenti autenticati. Chiunque disponga di questo diritto può aggiungere computer al dominio. Poiché stai automatizzando il processo di aggiunta dei computer al tuo dominio Active Directory, la concessione universalmente di questo livello di accesso rappresenta un rischio per la sicurezza superfluo.

Per limitare gli utenti che possono aggiungere computer al tuo dominio Active Directory, modifica la configurazione predefinita del GPO del criterio del controller di dominio predefinito:

  1. Utilizzando un client RDP, accedi a una macchina con accesso amministrativo al tuo dominio Active Directory.
  2. Apri la Console Gestione Criteri di gruppo (GPMC).
  3. Vai a Foresta > Domini > domain-name > Oggetti Criteri di gruppo, dove domain-name è il nome del tuo dominio Active Directory.
  4. Fai clic con il pulsante destro del mouse su Default Domain Controller Policy (Criterio controller di dominio predefinito) e scegli Edit (Modifica).
  5. Nella console dell'Editor Gestione Criteri di gruppo, vai a Configurazione computer > Criteri > Impostazioni di Windows > Impostazioni di sicurezza > Criteri locali > Assegnazione diritti utente.
  6. Fai doppio clic su Aggiungi workstation al dominio.
  7. In Proprietà, rimuovi Authenticated Users (Utenti autenticati) dall'elenco.
  8. Per consentire agli amministratori di aggiungere il dominio manualmente (facoltativo), fai clic su Aggiungi utente o gruppo, quindi aggiungi un gruppo amministrativo all'elenco.
  9. Fai clic su Ok.

Ora puoi chiudere la console dell'editor di Gestione Criteri di gruppo e la console GPMC.

Inizializzare una struttura di directory

Ora crei una UO che funge da contenitore per tutte le UO specifiche del progetto:

  1. Utilizzando un client RDP, accedi a una macchina con accesso amministrativo al tuo dominio Active Directory.
  2. Apri una sessione di PowerShell elevata.
  3. Crea una nuova unità organizzativa:

    $ParentOrgUnitPath = (Get-ADDomain).ComputersContainer
    $ProjectsOrgUnitPath = New-ADOrganizationalUnit `
      -Name 'Projects' `
      -Path $ParentOrgUnitPath `
      -PassThru
    

Creare un account utente Active Directory

Per accedere ad Active Directory e agli account computer in fase preliminare, l'app register-computer richiede un account utente Active Directory:

  1. Crea un account utente Active Directory denominato register-computer, assegnagli una password casuale e inseriscila nell'UO Projects:

    # Generate a random password
    $Password = [Guid]::NewGuid().ToString()+"-"+[Guid]::NewGuid().ToString()
    
    # 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 `
        -PassThru
    
  2. Concedi all'account register-computer l'insieme minimo di autorizzazioni necessarie per gestire gli account e i gruppi dei computer nella UO e nelle UO secondarie Projects:

    $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 del comando potrebbe richiedere alcuni minuti.

  3. Mostra il percorso UO Projects e la password generata dell'account utente register-computer Active Directory. 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 configuri il progetto del tuo dominio:

  • Se utilizzi Microsoft AD gestito, il progetto del dominio è il progetto in cui hai eseguito il deployment di Microsoft AD gestito.
  • Se utilizzi Active Directory autogestito, il progetto del tuo dominio è il progetto che esegue i controller di dominio Active Directory. Nel caso di un VPC condiviso, questo progetto deve essere uguale al progetto host del VPC.

Puoi utilizzare questo progetto di dominio per:

  • Crea un secret di Secret Manager che contiene la password dell'account utente Active Directory di register-computer.
  • Esegui il deployment dell'accesso VPC serverless per consentire a Cloud Run di accedere ad Active Directory.
  • Esegui il deployment dell'app register-computer.
  • Configurare Cloud Scheduler in modo che attivi la pulizia degli account computer inattivi.

Ti consigliamo di concedere l'accesso al progetto del dominio sulla base del privilegio minimo.

Crea un secret di Secret Manager

  1. Nella console Google Cloud, apri Cloud Shell.

    Apri Cloud Shell

  2. Avvia PowerShell:

    pwsh
    
  3. Inizializza la seguente variabile, sostituendo domain-project-id con l'ID del progetto del tuo dominio:

    $DomainProjectId = "domain-project-id"
    
  4. Imposta il progetto del dominio come progetto predefinito:

    & gcloud config set project $DomainProjectId
    
  5. Abilita l'API Secret Manager:

    & gcloud services enable secretmanager.googleapis.com
    
  6. Inserisci la password dell'account utente Active Directory di register-computer e memorizzala 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
    

Esegui il deployment dell'accesso VPC serverless

L'app register-computer deve comunicare con i controller di dominio Active Directory. Per consentire a Cloud Run di accedere alle risorse in un VPC, ora devi configurare l'accesso VPC serverless:

  1. Inizializza le seguenti variabili:

    $VpcName = "vpc-name"
    $ServerlessRegion = "serverless-region"
    $ServerlessIpRange = "serverless-ip-range"
    

    Sostituisci quanto segue:

    • vpc-name: il nome della rete VPC che contiene i controller di dominio Active Directory.
    • serverless-region: la regione in cui eseguire il deployment di Cloud Run. Scegli una regione che supporti sia Cloud Run sia l'accesso VPC serverless. La regione non deve necessariamente corrispondere a quella in cui prevedi di eseguire il deployment delle istanze VM.

    • serverless-ip-range: utilizzato dall'accesso VPC serverless per abilitare la comunicazione tra Cloud Run e le risorse nel tuo VPC. Impostato su un intervallo IP CIDR non prenotato /28. Non deve sovrapporsi ad alcuna subnet esistente nella tua rete VPC.

  2. Abilita le API di accesso VPC serverless:

    & gcloud services enable vpcaccess.googleapis.com
    
  3. Esegui il deployment dell'accesso VPC serverless:

    & gcloud compute networks vpc-access connectors create serverless-connector `
        --network $VpcName `
        --region $ServerlessRegion `
        --range $ServerlessIpRange
    

Concedi l'accesso a Kerberos e LDAP

Sebbene l'accesso VPC serverless consenta a Cloud Run di accedere alle risorse nel tuo VPC, la connettività agli endpoint Kerberos e LDAP dei controller di dominio è ancora soggetta alle regole firewall.

Devi creare una regola firewall che consenta alle risorse serverless di accedere ai controller di dominio utilizzando i seguenti protocolli: LDAP (TCP/389), LDAPS (TCP/636), Kerberos (UDP/88, TCP/88) o modifica della password Kerberos (UDP/464, TCP/464). Puoi applicare la regola in base a un tag di rete che hai assegnato ai controller di dominio oppure puoi applicarla utilizzando un account di servizio.

  • Per applicare la regola firewall, esegui uno dei seguenti comandi in Cloud Shell:

    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 controller di dominio.
    • vpc-project-id: l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; in caso contrario, 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 dell'account di servizio utilizzato dalle VM del controller di dominio.
    • vpc-project-id: l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; in caso contrario, utilizza l'ID del progetto del dominio.

Esegui il deployment dell'app Cloud Run

Ora configuri Cloud Build per eseguire il deployment dell'app register-computer in Cloud Run:

  1. 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
    
  2. Inizializza le seguenti variabili:

    $AdDomain = "dns-domain-name"
    $AdNetbiosDomain = "netbios-domain-name"
    $ProjectsOrgUnitPath = "projects-ou-distinguished-name"
    

    Sostituisci quanto segue:

    • 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 UO Projects.
  3. Abilita le API Cloud Run e Cloud Build:

    & gcloud services enable run.googleapis.com cloudbuild.googleapis.com
    
  4. Crea un account di servizio register-computer-app per l'app Cloud Run:

    & gcloud iam service-accounts create register-computer-app `
      --display-name="register computer Cloud Run app"
    
  5. Consenti all'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"
    
  6. Concedi a Cloud Build le autorizzazioni necessarie per 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:$DomainProjectNumber@cloudbuild.gserviceaccount.com" `
      --role "roles/iam.serviceAccountUser"
    
    & gcloud projects add-iam-policy-binding $DomainProjectId `
      --member "serviceAccount:$DomainProjectNumber@cloudbuild.gserviceaccount.com" `
      --role roles/run.admin
    
  7. Utilizza il file cloudbuild.yaml come 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 | Set-Content .\cloudbuild.hydrated.yaml
    
  8. Crea l'app ed eseguine il deployment in Cloud Run:

    & gcloud builds submit . `
      --config cloudbuild.hydrated.yaml `
      --substitutions _IMAGE_TAG=$(git rev-parse --short HEAD)
    

    Il deployment può richiedere un paio di minuti.

  9. 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 da aggiungere ad Active Directory.

  10. Richiama l'app Cloud Run per verificare che il deployment abbia funzionato:

    Invoke-RestMethod $RegisterUrl
    

    Viene visualizzato uno script PowerShell. La VM esegue questo script durante la fase di specializzazione che lo unisce al dominio.

Abilitazione di un progetto per l'unione automatica dei domini

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 dei domini. Questa misura di sicurezza contribuisce a impedire l'accesso al tuo dominio alle VM collegate a progetti non autorizzati.

Per abilitare un progetto per l'unione automatica dei domini, devi:

  • Crea una UO in Active Directory il cui nome corrisponda al tuo ID progetto Google Cloud.
  • Concedi all'app register-computer l'accesso al progetto Google Cloud.

Per prima cosa, crea la UO:

  1. Utilizzando un client RDP, accedi a una macchina con accesso amministrativo al tuo dominio Active Directory.
  2. Nello snapshot MMC Utenti e computer di Active Directory, vai all'UO Projects.
  3. Fai clic con il pulsante destro del mouse sull'unità organizzativa e seleziona Nuova > Unità organizzativa.
  4. Nella finestra di dialogo Nuovo oggetto, inserisci l'ID del progetto Google Cloud in cui eseguire il deployment delle VM.
  5. Fai clic su Ok.

Successivamente, concedi all'app register-computer l'accesso al progetto Google Cloud:

  1. In Cloud Shell, avvia PowerShell:

    pwsh
    
  2. Inizializza le seguenti variabili:

    $ProjectId = "project-id"
    $DomainProjectId = "domain-project-id"
    

    Sostituisci

    • project-id con l'ID del progetto Google Cloud in cui eseguire il deployment delle VM
    • domain-project-id con l'ID del progetto del dominio
  3. Concedi all'account di servizio register-computer-app il ruolo Compute Viewer nel 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 dei domini.

Test dell'aggiunta di domini in corso...

Ora puoi verificare se la configurazione funziona correttamente:

  • Creazione di una singola istanza VM che si unisce automaticamente al dominio Active Directory
  • Creazione di un gruppo di istanze VM gestite 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:

  1. Torna alla sessione di 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.
  2. Imposta progetto e zona predefiniti:

    & gcloud config set project $ProjectId
    & gcloud config set compute/zone $Zone
    
  3. 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)
    
  4. Crea un'istanza passando lo scriptlet Specializzazione che causa l'inserimento della VM nel dominio:

    VPC condiviso

    $VpchostProjectId = (gcloud compute shared-vpc get-host-project $ProjectId --format=value`(name`))
    & gcloud compute instances create join-01 `
        --image-family windows-2019-core `
        --image-project windows-cloud `
        --machine-type n1-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-2019-core `
        --image-project=windows-cloud `
        --machine-type=n1-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 --hostname al comando.

    Se utilizzi una versione di Windows Server precedente a Windows Server 2019, TLS 1.2 potrebbe essere disabilitato per impostazione predefinita e ciò può causare un errore dello scriptlet di specializzazione. Per attivare TLS 1.2, utilizza invece il seguente scriptlet:

    [Net.ServicePointManager]::SecurityProtocol=[Net.SecurityProtocolType]::Tls12;iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))
    
  5. 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 aggiunta ad Active Directory

  1. Utilizzando un client RDP, accedi a una macchina con accesso amministrativo al tuo dominio Active Directory.
  2. Apri lo snapshot MMC Utenti e computer di Active Directory.
  3. Nel menu, assicurati che l'opzione Visualizza > Funzionalità avanzate sia attivata.
  4. Vai all'UO denominata in base all'ID del progetto Google Cloud in cui hai creato l'istanza VM.
  5. Fai doppio clic sull'account join-01.
  6. Nella finestra di dialogo Proprietà, fai clic sulla scheda Editor attributi.

    Nell'account computer sono presenti inoltre attributi LDAP aggiuntivi. Questi attributi consentono di tenere traccia dell'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-cloudExtensionAttribute1 ID progetto Google Cloud
    msDS-cloudExtensionAttribute2 Zona Compute Engine
    msDS-cloudExtensionAttribute3 Nome istanza Compute Engine

    Gli attributi msDS-cloudExtensionAttribute sono attributi per uso generico e non vengono utilizzati da Active Directory.

Diagnostica errori

Se la tua istanza VM non è riuscita a unirsi al dominio, controlla il log dell'app register-computer:

  1. Nella console Google Cloud, vai a Cloud Run.

    Vai a Cloud Run

  2. Fai clic sull'app register-computer.

  3. Nel menu, fai clic su Log.

Elimina l'istanza

Dopo aver verificato che l'istanza VM sia aggiunta al dominio Active Directory, puoi eliminarla.

  • Elimina l'istanza:

    & gcloud compute instances delete join-01 --quiet
    

Crea e partecipa a un gruppo di istanze gestite

Puoi anche verificare che le istanze di un gruppo di istanze gestite possano unirsi automaticamente al tuo dominio.

  1. Crea un modello di istanza passando lo script specializzato che causa l'inserimento della VM nel dominio:

    VPC condiviso

    $VpchostProjectId = (gcloud compute shared-vpc get-host-project $ProjectId --format=value`(name`))
    & gcloud compute instance-templates create ad-2019core-n1-std-2 `
        --image-family windows-2019-core `
        --image-project windows-cloud `
        --no-address `
        --machine-type n1-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-n1-std-2 `
        --image-family windows-2019-core `
        --image-project windows-cloud `
        --no-address `
        --machine-type n1-standard-2 `
        --subnet projects/$ProjectId/regions/$Region/subnetworks/$Subnet `
        --metadata "sysprep-specialize-script-ps1=iex((New-Object System.Net.WebClient).DownloadString('$RegisterUrl'))"
    
  2. Crea un gruppo di istanze gestite che utilizza il modello di istanza:

    & gcloud compute instance-groups managed create group-01 `
        --template ad-2019core-n1-std-2 `
        --size=3
    

Attendi qualche minuto, quindi utilizza lo snapshot MMC Utenti e computer di Active Directory per verificare che siano stati creati quattro nuovi oggetti in Active Directory:

  • Tre account computer corrispondenti alle tre istanze VM del gruppo di istanze gestite.
  • Un gruppo denominato group-01 che contiene i 3 account computer. Se prevedi di utilizzare account di servizio gestiti di gruppo (gMSA), puoi utilizzare questo gruppo per concedere l'accesso a gMSA.

Dopo aver verificato che le istanze VM dei tuoi gruppi di istanze gestite possano essere aggiunte al dominio Active Directory, puoi eliminare il gruppo gestito e il modello di istanza seguendo questa procedura:

  1. In Cloud Shell, elimina il gruppo di istanze:

    & gcloud compute instance-groups managed delete group-01 --quiet
    
  2. Elimina il modello di istanza:

    & gcloud compute instance-templates delete ad-2019core-n1-std-2 --quiet
    

Pianificazione della pulizia degli account computer inattivi

L'automazione del processo di aggiunta dei computer al dominio riduce il problema di configurazione di nuovi server e ti consente di utilizzare server che fanno parte di un dominio in gruppi di istanze gestite. Nel corso del tempo, tuttavia, gli account computer inattivi possono accumularsi nel dominio.

Per evitare questo accumulo, ti consigliamo di configurare l'app register-computer in modo che analizzi periodicamente il dominio Active Directory per trovare e rimuovere automaticamente gli account inattivi.

L'app register-computer può utilizzare gli attributi msDS-cloudExtensionAttribute degli account computer per identificare quali account computer sono inattivi. Questi attributi contengono il nome del progetto, della zona e dell'istanza 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 la pulizia dell'account del computer, richiami l'endpoint /cleanup dell'app Cloud Run. Per impedire che utenti non autorizzati attivino una pulizia, questa richiesta deve essere autenticata utilizzando l'account di servizio register-computer-app.

Configura Cloud Scheduler

I passaggi seguenti mostrano come configurare Cloud Scheduler in combinazione con Pub/Sub per attivare automaticamente una pulizia ogni 24 ore:

  1. In Cloud Shell, abilita l'API Cloud Scheduler nel progetto del tuo dominio:

    & gcloud services enable cloudscheduler.googleapis.com
    
  2. Imposta AppEngineLocation su una località App Engine valida in cui eseguire il deployment di Cloud Scheduler:

    $AppEngineLocation = "location"
    

    Sostituisci location con la regione App Engine selezionata per le risorse VPC, ad esempio us-central. Se quella regione non è disponibile come località App Engine, scegli una località geograficamente vicina a te. Per ulteriori informazioni, consulta Regioni e zone.

  3. Inizializza App Engine:

    & gcloud app create --region $AppEngineLocation --project $DomainProjectId
    
  4. 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 $DomainProjectId
    

    Questo job chiama l'app register-computer una volta ogni 24 ore e utilizza l'account di servizio register-computer-app per l'autenticazione.

Attiva una pulizia

Per verificare la configurazione per la pulizia degli account computer inattivi, puoi attivare manualmente il job Cloud Scheduler.

  1. Nella console Google Cloud, vai a Cloud Scheduler.

    Vai a Cloud Scheduler

  2. Per il job cleanup-computer-accounts che hai creato, fai clic su Esegui ora.

    Dopo alcuni secondi, la colonna Risultato mostra Success, 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 su quali account sono stati eliminati, controlla i log dell'app register-computer.

  1. Nella console Google Cloud, vai a Cloud Run.

    Vai a Cloud Run

  2. Fai clic sull'app register-computer.

  3. Nel menu, fai clic su Log.

    Le voci di log indicano che gli account computer delle istanze VM utilizzate per testare l'unione dei domini sono stati identificati come inattivi e rimossi.

Esegui la pulizia

Se utilizzi questo tutorial come base per altri tutorial, leggi gli altri tutorial su quando eseguire la procedura di pulizia di questo tutorial.

Se non vuoi mantenere la configurazione di Google Cloud utilizzata per questo tutorial, puoi ripristinarla procedendo nel seguente modo:

  1. In Cloud Shell, elimina il job Cloud Scheduler:

    & gcloud scheduler jobs delete cleanup-computer-accounts `
      --project $DomainProjectId
    
  2. Elimina l'app Cloud Run:

    & gcloud run services delete register-computer `
      --platform managed `
      --project $DomainProjectId `
      --region $ServerlessRegion
    
  3. Elimina il secret di Secret Manager:

    gcloud secrets delete ad-password --project $DomainProjectId
    
  4. Elimina la regola firewall per l'accesso LDAP e Kerberos:

    gcloud compute firewall-rules delete allow-adkrb-from-serverless-to-dc --project=vpc-project-id
    

    Sostituisci vpc-project-id con l'ID del progetto in cui è definito il VPC. Se utilizzi un VPC condiviso, utilizza il progetto host VPC; in caso contrario, utilizza l'ID del progetto del dominio.

  5. Elimina l'accesso VPC serverless:

    gcloud compute networks vpc-access connectors delete serverless-connector --region $ServerlessRegion --quiet
    

Ripristina modifiche di Active Directory

  1. Utilizzando un client RDP, accedi a una macchina con accesso amministrativo al tuo dominio Active Directory.
  2. Nello snapshot MMC Utenti e computer di Active Directory, vai all'UO Projects.
  3. Elimina l'account utente Active Directory register-computer.
  4. Elimina l'UO che hai creato per testare l'unione automatica dei domini.

Passaggi successivi