En el host de administración, instala las herramientas del cliente Kerberos y cifs-utils.

En todos los demás nodos, instala cifs-utils.

En cada nodo, comprueba la instalación.

which cifs.upcall

Establece el espacio de nombres en el que se ejecuta AI Data Engine y comprueba que la solicitud de volumen de configuración esté vinculada. El espacio de nombres predeterminado es aide.

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

Obtén el servidor NFS y la ruta de exportación del volumen de configuración. Estos valores los especificaste al implementar AI Data Engine.

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

Monta la exportación. Sustituye <nfs_server> y <export_path> por los valores del paso anterior. Los comandos utilizan /mnt/aide-config como punto de montaje. Puedes utilizar cualquier directorio vacío.

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

Crea los directorios de Kerberos.

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

Establece las variables que utilizan los siguientes comandos. Sustituye cada valor entre corchetes angulares por tu propio valor, sin incluir los corchetes angulares. Introduce el reino en mayúsculas y el dominio en minúsculas.

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 el archivo de configuración de Kerberos en la exportación NFS. AI Data Engine lee este archivo desde la exportación. No lo crees en /etc/krb5.conf de los nodos.

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 keytab para la cuenta de servicio de análisis.

Comprueba el keytab. La variable KRB5_CONFIG apunta las herramientas de Kerberos al archivo de la exportación.

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

Instala el keytab y luego elimina la copia temporal.

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

Haz que el actualizador de tickets pueda escribir en el directorio de caché de tickets.

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

Crea el archivo principal. El valor KRB5_RENEW_INTERVAL_H es el intervalo de renovación del ticket en horas.

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}"

Comprueba que los archivos estén en su sitio.

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

En cada nodo, comprueba que el servidor de archivos y el KDC se resuelvan mediante su FQDN. Sustituye los valores por el FQDN de tu servidor de archivos y el FQDN del KDC.

nslookup <file_server_fqdn>
nslookup <kdc_fqdn>

Comprueba el resultado.

En el host de administración, inicia una tarea de actualización, espera a que finalice y visualiza su registro.

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}"

Comprueba que la caché de tickets compartida exista y que tenga una marca de tiempo reciente.

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

Enumera los pods del servicio de montaje y los nodos en los que se ejecutan.

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

Para cada pod, ejecuta los siguientes comandos. Sustituye <pod_name> por el nombre 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

(Opcional) Comprueba que se monta el recurso compartido utilizando 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"

En la interfaz de usuario de AI Data Engine, selecciona Configuración.

En la pestaña Sistemas analizados, selecciona Add system.

Selecciona Grupo de recursos compartidos de archivos.

Introduce un nombre para el grupo.

Introduce la ruta del recurso compartido con el formato <file_server_fqdn>/<share_name>. Sustituye los marcadores de posición por tus propios valores. No uses una dirección IP.

Para el método de autenticación, selecciona Kerberos. Deja vacíos los campos de nombre de usuario y contraseña.

Revisa tus selecciones y pulsa Confirm.

Selecciona Activar análisis para el nuevo sistema.

Comprueba que tu servidor DNS de Active Directory también resuelva nombres externos.

En cada nodo, haz una copia de seguridad de /etc/resolv.conf, y configura tu servidor DNS de Active Directory como único servidor de nombres. Si abres un nuevo shell en un nodo, vuelve a configurar la variable 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

En cada nodo, evita que el gestor de red sobrescriba la configuración de DNS tras un reinicio.

Desde el host de administración, reinicia CoreDNS para que AI Data Engine utilice la nueva configuración de DNS. Este paso solo hay que realizarlo una vez para todo el clúster. CoreDNS reenvía las consultas de nombres de fuera del clúster a los servidores de nombres del archivo /etc/resolv.conf del nodo, por lo que debe reiniciarse para que aplique el cambio.

Comprueba de nuevo la resolución de nombres. Consulta Comprueba la resolución de nombres.

En el host de administración, reinicia el servicio de montaje y elimina las tareas anteriores de actualización de tickets.

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

Inicia una nueva actualización de ticket. Consulta Inicia la primera actualización del ticket.

Desde la interfaz de usuario de AI Data Engine, elimina la fuente de datos SMB/CIFS que utiliza Kerberos.

En el host de administración, con la exportación NFS montada en /mnt/aide-config, elimina los archivos de 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

Si has modificado la configuración del DNS, restablece la configuración original.