Unire un pool in modalità ONTAP ad Active Directory

Questa pagina descrive come unire un pool in modalità ONTAP a un dominio Active Directory.

I pool di archiviazione Flex Unified in modalità ONTAP non utilizzano le policy di Active Directory. Per utilizzare Active Directory con i volumi SMB, unisci la macchina virtuale di archiviazione (SVM) ONTAP nel pool al tuo dominio Windows creando un server CIFS.

Per i prerequisiti di Active Directory e le regole firewall, consulta Integrazione di Google Cloud NetApp Volumes Active Directory.

Prima di iniziare

Completa i seguenti prerequisiti:

  1. Assicurati che la rete del pool di archiviazione possa connettersi ai controller di dominio e ai server DNS.

  2. Configura Cloud DNS per inoltrare le richieste DNS per il tuo dominio Windows ai tuoi server DNS Windows.

  3. Completa i prerequisiti descritti in Prima di iniziare.

  4. Raccogli le seguenti informazioni:

    1. AD_FQDN: il nome di dominio completo, ad esempio corp.example.com.

    2. AD_DNS_SERVERS: da uno a tre indirizzi IPv4 separati da virgole per i server DNS di Active Directory.

    3. AD_USERNAME e AD_PASSWORD: un account di dominio che può creare account computer, con un nome account SAM di 20 caratteri o meno.

    4. COMPUTER_NAME: un nome NetBIOS univoco per l'account computer all'interno del dominio, con un massimo di 15 caratteri.

    5. OU: Facoltativo: il nome distinto per l'unità organizzativa (OU) di destinazione, ad esempio OU=Computer,DC=corp,DC=example,DC=com.

Panoramica

Per unire un pool in modalità ONTAP a un dominio Active Directory, completa i seguenti passaggi:

  1. Configurare ontap_execute

  2. Cercare le risorse del pool

  3. Configura il DNS sulla SVM

  4. Partecipare al dominio

  5. Configurare l'accesso SMB

  6. Verificare l'aggiunta al dominio

Cercare risorse per piscine

Cerca le seguenti risorse del pool di archiviazione:

Nome SVM

Per cercare il nome della SVM:

 ontap_execute "vserver show -fields vserver,operational-state"

Prendi nota del nome del Vserver, ad esempio gcnv-7cf6ee41c1a94f0-svm-01. Utilizza questo nome come SVM_NAME nei passaggi successivi.

LIF di dati

Prima di unirti al dominio, verifica che le LIF dei dati possano raggiungere correttamente i server DNS e i domain controller.

 ontap_execute "network interface show -role data"

Per testare la connettività a un server DNS o a un controller di dominio, utilizza un'interfaccia LIF SAN con il flag -lif. I pool in modalità ONTAP espongono LIF SAN denominate SVM_NAME-san-1, SVM_NAME-san-2 e LIF aggiuntive in base alle necessità:

 ontap_execute "network ping -vserver SVM_NAME -destination DNS_OR_DC_IP -lif SVM_NAME-san-1"

Se il ping non va a buon fine, il pool di archiviazione non può connettersi al server DNS o al controller di dominio tramite la rete. Le macchine virtuali (VM) nel tuo VPC potrebbero comunque essere in grado di connettersi a questi host. Per ulteriori informazioni sulla risoluzione dei problemi di connettività, consulta Perché i NetApp Volumes non riescono a connettersi ad Active Directory e ad altre reti dietro il VPC.

Configura il DNS sulla SVM

Per configurare il DNS sulla SVM:

 ontap_execute "vserver services name-service dns create -vserver SVM_NAME -domains AD_FQDN -name-servers AD_DNS_SERVERS"

Se l'opzione di servizio dei nomi degli host non include DNS, aggiungila:

 ontap_execute "vserver services name-service ns-switch modify -vserver SVM_NAME -database hosts -sources dns,files"

Verifica la configurazione:

 ontap_execute "vserver services name-service dns show -vserver SVM_NAME"

Partecipare al dominio

Questa sezione descrive il comando ONTAP CLI, le limitazioni del proxy CLI e come unire il dominio utilizzando Python.

Comando CLI ONTAP

Su un sistema con accesso diretto alla CLI ONTAP, esegui questo comando:

 vserver cifs create -vserver SVM_NAME -cifs-server COMPUTER_NAME -domain AD_FQDN

Per includere parametri facoltativi, utilizza -ou OU e -default-site SITE. ONTAP ti chiede la password del dominio e il comando può richiedere diversi minuti.

Limitazioni del proxy CLI

Il proxy CLI ONTAP non è interattivo. Poiché il comando vserver cifs create richiede una password, non puoi completare l'aggiunta al dominio tramite il proxy. Utilizza invece l'API REST. L'equivalente API è POST /protocols/cifs/services.

Lo script annuncia AES-256 solo per la comunicazione Kerberos con Active Directory. Si tratta dell'impostazione consigliata per i domini moderni. Per pubblicizzare anche AES-128 o DES, aggiungi valori all'array advertised_kdc_encryptions nello script prima di eseguirlo o modifica il server CIFS dopo l'aggiunta al dominio utilizzando vserver cifs security modify -advertised-enc-types. DES non è consigliato perché utilizza una crittografia debole.

I valori validi per il tipo di crittografia sono aes-256, aes-128, rc4 e des. Se modifichi i tipi di crittografia pubblicizzati dopo l'aggiunta al dominio, ONTAP reimposta la password dell'account della macchina e richiede le credenziali di Active Directory.

Unirsi al dominio utilizzando Python

Salva lo script seguente come join_ad.py ed eseguilo con Python 3.8 o versioni successive. Lo script utilizza solo la libreria standard Python.

 #!/usr/bin/env python3
"""Join an ONTAP-mode SVM to Active Directory by creating a CIFS server."""

import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request

# Required environment variables.
REQUIRED = (
    "PROJECT_ID", "LOCATION", "POOL_NAME", "SVM_NAME",
    "AD_FQDN", "COMPUTER_NAME", "AD_USERNAME", "AD_PASSWORD",
)
missing = [name for name in REQUIRED if not os.environ.get(name)]
if missing:
    sys.exit(f"Set required environment variables: {', '.join(missing)}")

PROJECT_ID = os.environ["PROJECT_ID"]
LOCATION = os.environ["LOCATION"]
POOL_NAME = os.environ["POOL_NAME"]
SVM_NAME = os.environ["SVM_NAME"]
AD_FQDN = os.environ["AD_FQDN"]
COMPUTER_NAME = os.environ["COMPUTER_NAME"]
AD_USERNAME = os.environ["AD_USERNAME"]
AD_PASSWORD = os.environ["AD_PASSWORD"]

# Optional environment variables.
OU = os.environ.get("OU", "")
AD_SITE = os.environ.get("AD_SITE", "")
POLL_INTERVAL = int(os.environ.get("POLL_INTERVAL", "10"))

# Kerberos encryption types advertised to Active Directory. AES-256 only by default.
# To add aes-128 or des (not recommended), extend this list before you run the script.
ADVERTISED_KDC_ENCRYPTIONS = ["aes-256"]

API_ROOT = (
    f"https://netapp.googleapis.com/v1/projects/{PROJECT_ID}"
    f"/locations/{LOCATION}/storagePools/{POOL_NAME}/ontap/api"
)

def get_access_token() -> str:
    return subprocess.check_output(
        ["gcloud", "auth", "print-access-token"], text=True
    ).strip()

def api_request(method: str, path: str, body=None) -> dict:
    headers = {
        "Authorization": f"Bearer {get_access_token()}",
        "Content-Type": "application/json",
    }
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(f"{API_ROOT}{path}", data=data, headers=headers, method=method)
    try:
        with urllib.request.urlopen(req) as resp:
            return json.loads(resp.read())
    except urllib.error.HTTPError as exc:
        detail = exc.read().decode()
        sys.exit(f"API request failed ({exc.code}): {detail}")

def job_record(response: dict) -> dict:
    return response.get("rawResponse") or response.get("body") or response

def job_state(response: dict) -> str:
    return job_record(response).get("state", "")

def format_job_error(response: dict) -> str:
    record = job_record(response)
    message = record.get("message") or record.get("error", {}).get("message")
    if message:
        return message
    return json.dumps(response, indent=2)

def wait_for_job(job_uuid: str) -> None:
    print(f"ONTAP job UUID: {job_uuid}")
    while True:
        response = api_request("GET", f"/cluster/jobs/{job_uuid}")
        state = job_state(response)
        print(f"  Job state: {state}")
        if state == "success":
            print("Domain join completed.")
            return
        if state in ("failure", "error"):
            sys.exit(f"Job failed: {format_job_error(response)}")
        time.sleep(POLL_INTERVAL)

def main() -> None:
    ad_domain = {
        "fqdn": AD_FQDN,
        "user": AD_USERNAME,
        "password": AD_PASSWORD,
    }
    if OU:
        ad_domain["organizational_unit"] = OU
    if AD_SITE:
        ad_domain["default_site"] = AD_SITE

    body = {
        "body": {
            "svm": {"name": SVM_NAME},
            "name": COMPUTER_NAME,
            "ad_domain": ad_domain,
            "security": {
                "advertised_kdc_encryptions": ADVERTISED_KDC_ENCRYPTIONS,
            },
        }
    }

    print(f"Creating CIFS server and joining {AD_FQDN}...")
    response = api_request("POST", "/protocols/cifs/services?return_records=true", body)

    job = (response.get("body") or {}).get("job") or response.get("job")
    if not job or not job.get("uuid"):
        print(json.dumps(response, indent=2))
        return
    wait_for_job(job["uuid"])

if __name__ == "__main__":
    main()

Configurare l'accesso SMB

Concedi i diritti di amministratore locale a un utente o a un gruppo di un dominio:

 ontap_execute "vserver cifs users-and-groups local-group add-members -vserver SVM_NAME -group-name BUILTIN\\Administrators -member-names NETBIOS_DOMAIN\\username"

Sostituisci NETBIOS_DOMAIN con il nome di dominio NetBIOS, non con il nome DNS.

Se utilizzi il DNS integrato in Active Directory, attiva gli aggiornamenti DNS dinamici sicuri. Devi impostare il flag -vserver-fqdn sul nome di dominio completo del server CIFS, ad esempio COMPUTER_NAME.AD_FQDN:

 ontap_execute "vserver services name-service dns dynamic-update modify -vserver SVM_NAME -is-enabled true -use-secure true -vserver-fqdn COMPUTER_NAME.AD_FQDN"

Verifica l'aggiunta al dominio

Per verificare l'unione al dominio:

 ontap_execute "vserver cifs show -vserver SVM_NAME"

Verifica che il server CIFS sia online e unito al dominio previsto.

Rimuovere un server CIFS

Per eliminare il server CIFS e unirti di nuovo al dominio, completa i seguenti passaggi:

  1. Disattiva gli aggiornamenti DNS dinamico sicuro:

     ontap_execute "vserver services name-service dns dynamic-update modify -vserver SVM_NAME -is-enabled false -use-secure false"

    ONTAP blocca l'eliminazione di CIFS mentre DDNS sicuro è abilitato.

  2. Rimuovi l'account computer da Active Directory o utilizza un account di dominio che disponga dell'autorizzazione per eliminare gli account computer nell'UO di destinazione.

  3. Elimina il server CIFS su ONTAP:

     ontap_execute "vserver cifs delete -vserver SVM_NAME -skip-ad-account-delete true"

    Utilizza -skip-ad-account-delete true se l'account computer è già stato rimosso da Active Directory o se l'account utilizzato per l'eliminazione non dispone dell'autorizzazione per rimuovere gli oggetti computer. In questo caso, ONTAP rimuove solo la configurazione CIFS locale e non tenta di eliminare un oggetto Active Directory.

    Per impostazione predefinita, vserver cifs delete rimuove anche l'account computer da Active Directory e richiede le credenziali dell'amministratore di dominio. Questo prompt non funziona tramite il proxy CLI ONTAP.

Passaggi successivi