Sull'admin host, installa gli strumenti client Kerberos e cifs-utils.

Su ogni altro nodo, installa cifs-utils.

Su ogni nodo, verifica l'installazione.

which cifs.upcall

Imposta lo spazio dei nomi in cui viene eseguito AI Data Engine e verifica che la richiesta di volume di configurazione sia associata. Lo spazio dei nomi predefinito è aide.

export NAMESPACE="<namespace>"
kubectl -n "${NAMESPACE}" get pvc aide-config-pvc

Recupera il server NFS e il percorso di esportazione del volume di configurazione. Hai specificato questi valori quando hai distribuito AI Data Engine.

kubectl get pv aide-config-pv -o jsonpath='NFS server: {.spec.nfs.server}{"\n"}Export path: {.spec.nfs.path}{"\n"}'

Monta l'esportazione. Sostituisci <nfs_server> e <export_path> con i valori del passaggio precedente. I comandi utilizzano /mnt/aide-config come punto di montaggio. Puoi utilizzare qualsiasi directory vuota.

mkdir -p /mnt/aide-config
mount -t nfs <nfs_server>:<export_path> /mnt/aide-config

Crea le directory Kerberos.

export AIDE_CONFIG_ROOT="/mnt/aide-config"
mkdir -p "${AIDE_CONFIG_ROOT}/kerberos/kerberos_refresher"
mkdir -p "${AIDE_CONFIG_ROOT}/kerberos/kerberos_ccache"

Imposta le variabili utilizzate dai seguenti comandi. Sostituisci ogni valore tra parentesi angolari con il tuo valore e non includere le parentesi angolari. Inserisci il realm in maiuscolo e il dominio in minuscolo.

export KDC_IP="<kdc_ip>"
export KDC_FQDN="<kdc_fqdn>"
export AD_DOMAIN="<domain>"
export REALM="<REALM>"
export SCAN_USER="<scan_user>"
export FILE_SERVER_FQDN="<file_server_fqdn>"
export SHARE_NAME="<share_name>"
export KRB5_CONF_SOURCE="${AIDE_CONFIG_ROOT}/kerberos/krb5.conf"
export KRB5_KEYTAB="${AIDE_CONFIG_ROOT}/kerberos/kerberos_refresher/datasense.keytab"
export KRB5_CREDS="${AIDE_CONFIG_ROOT}/kerberos/kerberos_refresher/kerberos_creds.env"

Crea il file di configurazione Kerberos sull'esportazione NFS. AI Data Engine legge questo file dall'esportazione. Non crearlo in /etc/krb5.conf sui nodi.

tee "${KRB5_CONF_SOURCE}" >/dev/null <<EOF
[libdefaults]
    default_realm = ${REALM}
    dns_lookup_realm = false
    dns_lookup_kdc = false
    rdns = false
    ticket_lifetime = 24h
    renew_lifetime = 7d
    forwardable = true

[realms]
    ${REALM} = {
        kdc = ${KDC_IP}:88
        admin_server = ${KDC_IP}:749
    }

[domain_realm]
    .${AD_DOMAIN} = ${REALM}
    ${AD_DOMAIN} = ${REALM}
EOF
chmod 644 "${KRB5_CONF_SOURCE}"

Crea un file keytab per l'account del servizio di scansione.

Verifica il file keytab. La KRB5_CONFIG variabile indirizza gli strumenti Kerberos al file nell'export.

export KRB5_CONFIG="${KRB5_CONF_SOURCE}"
klist -kt /tmp/krb5.keytab
kinit -kt /tmp/krb5.keytab "${SCAN_USER}@${REALM}"
klist
kdestroy

Installa il file keytab, quindi elimina la copia temporanea.

install -m 640 -g 4321 /tmp/krb5.keytab "${KRB5_KEYTAB}"
rm -f /tmp/krb5.keytab

Rendi la directory della cache dei ticket scrivibile per il sistema di aggiornamento dei ticket.

chown root:4321 "${AIDE_CONFIG_ROOT}/kerberos/kerberos_ccache"
chmod 770 "${AIDE_CONFIG_ROOT}/kerberos/kerberos_ccache"

Crea il file principal. Il KRB5_RENEW_INTERVAL_H valore corrisponde all'intervallo di rinnovo del ticket in ore.

tee "${KRB5_CREDS}" >/dev/null <<EOF
KRB5_USER=${SCAN_USER}
KRB5_REALM=${REALM}
KRB5_RENEW_INTERVAL_H=3
EOF
chmod 640 "${KRB5_CREDS}"
chgrp 4321 "${KRB5_CREDS}"

Verifica che i file siano nella posizione corretta.

ls -l "${KRB5_CONF_SOURCE}" "${KRB5_KEYTAB}" "${KRB5_CREDS}"

Su ogni nodo, verifica che il file server e il KDC vengano risolti tramite FQDN. Sostituisci i valori con l'FQDN del tuo file server e l'FQDN del tuo KDC.

nslookup <file_server_fqdn>
nslookup <kdc_fqdn>

Verifica il risultato.

Sull'admin host, avvia un job di refresh, attendi che venga completato e visualizzane il log.

JOB="kerberos-refresh-$(date +%s)"
kubectl -n "${NAMESPACE}" create job "${JOB}" --from=cronjob/ds-krb5-ticket-refresher
kubectl -n "${NAMESPACE}" wait --for=condition=complete "job/${JOB}" --timeout=120s
kubectl -n "${NAMESPACE}" logs "job/${JOB}"

Verifica che la cache condivisa dei ticket esista e abbia un timestamp recente.

ls -l "${AIDE_CONFIG_ROOT}/kerberos/kerberos_ccache/krb5cc_shared"

Elenca i pod del servizio di mount e i nodi su cui vengono eseguiti.

kubectl -n "${NAMESPACE}" get pods -l app.kubernetes.io/name=ds-mount-server -o wide

Per ogni pod, esegui i seguenti comandi. Sostituisci <pod_name> con il nome del pod.

POD=<pod_name>
kubectl -n "${NAMESPACE}" exec "${POD}" -- nslookup "${FILE_SERVER_FQDN}"
kubectl -n "${NAMESPACE}" exec "${POD}" -- klist
kubectl -n "${NAMESPACE}" exec "${POD}" -- cat /etc/krb5.conf

(Facoltativo) Verifica il montaggio della condivisione utilizzando Kerberos.

kubectl -n "${NAMESPACE}" exec "${POD}" -- sh -c "mount -t cifs -o sec=krb5,multiuser //${FILE_SERVER_FQDN}/${SHARE_NAME} /mnt && ls -l /mnt && umount /mnt"

Dall'interfaccia di AI Data Engine, seleziona Configurazione.

Nella scheda Sistemi scansionati, seleziona Aggiungi sistema.

Seleziona File shares group.

Inserisci un nome per il gruppo.

Inserisci il percorso di condivisione nel formato <file_server_fqdn>/<share_name>. Sostituisci i segnaposto con i tuoi valori. Non usare un indirizzo IP.

Per il metodo di autenticazione, seleziona Kerberos. Lascia vuoti i campi nome utente e password.

Rivedi le tue selezioni e seleziona Conferma.

Seleziona Attiva scansioni per il nuovo sistema.

Verifica che il tuo DNS server di Active Directory risolva anche i nomi esterni.

Su ogni nodo, esegui il backup /etc/resolv.conf e imposta il tuo DNS server di Active Directory come unico name server. Se apri una nuova shell su un nodo, imposta di nuovo la variabile KDC_IP.

export KDC_IP="<kdc_ip>"
cp /etc/resolv.conf /etc/resolv.conf.bak
ORIG_SEARCH=$(grep '^search' /etc/resolv.conf.bak | head -1 | cut -d' ' -f2-)
printf 'search %s\nnameserver %s\n' "${ORIG_SEARCH}" "${KDC_IP}" > /etc/resolv.conf

Su ogni nodo, impedisci al gestore di rete di sovrascrivere le impostazioni DNS dopo un riavvio.

Dall'admin host, riavvia CoreDNS in modo che AI Data Engine utilizzi le nuove impostazioni DNS. Esegui questo passaggio una sola volta per il cluster. CoreDNS inoltra le query per i nomi esterni al cluster ai name server nel /etc/resolv.conf file del nodo, quindi deve essere riavviato per recepire la modifica.

Verifica nuovamente la risoluzione dei nomi. Fai riferimento a Verifica la risoluzione dei nomi.

Sull'admin host, riavvia il servizio di montaggio ed elimina i precedenti processi di aggiornamento dei ticket.

kubectl -n "${NAMESPACE}" rollout restart daemonset ds-mount-server
kubectl -n "${NAMESPACE}" delete job -l app.kubernetes.io/name=ds-krb5-ticket-refresher --ignore-not-found

Avvia un nuovo aggiornamento del ticket. Fai riferimento a Avvia il primo aggiornamento del ticket.

Dall'interfaccia utente di AI Data Engine, elimina l'origine dati SMB/CIFS che utilizza Kerberos.

Sull'admin host, con l'esportazione NFS montata in /mnt/aide-config, elimina i file Kerberos.

rm -f /mnt/aide-config/kerberos/kerberos_refresher/datasense.keytab
rm -f /mnt/aide-config/kerberos/kerberos_refresher/kerberos_creds.env
rm -f /mnt/aide-config/kerberos/krb5.conf
rm -f /mnt/aide-config/kerberos/kerberos_ccache/krb5cc_shared
umount /mnt/aide-config

Se hai modificato le impostazioni DNS, ripristina le impostazioni originali.