Sur l'hôte d'administration, installez les outils clients Kerberos et cifs-utils.

Sur tous les autres nœuds, installez cifs-utils.

Sur chaque nœud, vérifiez l'installation.

which cifs.upcall

Définissez l’espace de noms dans lequel AI Data Engine s’exécute, et vérifiez que la demande de volume de configuration est liée. L’espace de noms par défaut est aide.

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

Récupérez le serveur NFS et le chemin d'exportation du volume de configuration. Vous avez spécifié ces valeurs lors du déploiement d'AI Data Engine.

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

Montez l'export. Remplacez <nfs_server> et <export_path> par les valeurs de l'étape précédente. Les commandes utilisent /mnt/aide-config comme point de montage. Vous pouvez utiliser n'importe quel répertoire vide.

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

Créez les répertoires Kerberos.

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

Définissez les variables utilisées par les commandes suivantes. Remplacez chaque valeur entre chevrons par votre valeur, sans inclure les chevrons. Saisissez le realm en majuscules et le domaine en minuscules.

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"

Créez le fichier de configuration Kerberos sur l’export NFS. AI Data Engine lit ce fichier depuis l’export. Ne le créez pas dans /etc/krb5.conf sur les nœuds.

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

Créez un fichier keytab pour le compte du service de numérisation.

Testez le fichier keytab. La KRB5_CONFIG variable indique aux outils Kerberos le fichier sur l'export.

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

Installez le fichier keytab, puis supprimez la copie temporaire.

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

Rendez le répertoire du cache de tickets accessible en écriture par le processus d’actualisation des tickets.

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

Créez le fichier principal. La KRB5_RENEW_INTERVAL_H valeur correspond à l'intervalle de renouvellement du billet en heures.

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

Vérifiez que les fichiers sont bien en place.

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

Sur chaque nœud, vérifiez que le serveur de fichiers et le KDC se résolvent par FQDN. Remplacez les valeurs par le FQDN de votre serveur de fichiers et le FQDN de votre KDC.

nslookup <file_server_fqdn>
nslookup <kdc_fqdn>

Vérifiez le résultat.

Sur l’hôte d’administration, lancez une tâche d’actualisation, attendez qu’elle se termine et affichez son journal.

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

Vérifiez que le cache de tickets partagé existe et qu'il comporte un horodatage récent.

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

Listez les pods du service de montage et les nœuds sur lesquels ils s'exécutent.

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

Pour chaque pod, exécutez les commandes suivantes. Remplacez <pod_name> par le nom du 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

(Facultatif) Testez le montage du partage en utilisant 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"

Dans l’interface utilisateur de AI Data Engine, sélectionnez Configuration.

Dans l'onglet Systèmes scannés, sélectionnez Ajouter un système.

Sélectionnez Groupe de partages de fichiers.

Saisissez un nom pour le groupe.

Saisissez le chemin de partage au format <file_server_fqdn>/<share_name>. Remplacez les espaces réservés par vos valeurs. N'utilisez pas d'adresse IP.

Pour la méthode d'authentification, sélectionnez Kerberos. Laissez les champs nom d'utilisateur et mot de passe vides.

Vérifiez vos sélections et sélectionnez Confirmer.

Sélectionnez Activer les analyses pour le nouveau système.

Vérifiez que votre serveur DNS Active Directory résout également les noms externes.

Sur chaque nœud, effectuez une sauvegarde /etc/resolv.conf, et définissez votre serveur DNS Active Directory comme unique serveur de noms. Si vous ouvrez un nouveau shell sur un nœud, définissez à nouveau la KDC_IP variable.

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

Sur chaque nœud, empêchez le gestionnaire de réseau d'écraser les paramètres DNS après un redémarrage.

Depuis l'hôte d'administration, redémarrez CoreDNS afin qu'AI Data Engine utilise les nouveaux paramètres DNS. Vous n'exécutez cette étape qu'une seule fois pour le cluster. CoreDNS transfère les requêtes pour les noms en dehors du cluster aux serveurs de noms dans le /etc/resolv.conf fichier de configuration du nœud, il doit donc redémarrer pour prendre en compte la modification.

Vérifiez à nouveau la résolution de noms. Consultez Vérifier la résolution de noms.

Sur l'hôte d'administration, redémarrez le service de montage et supprimez les tâches précédentes d'actualisation des 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

Lancez une nouvelle actualisation de ticket. Reportez-vous à Lancer le premier rafraîchissement du ticket.

Dans l’interface utilisateur d’AI Data Engine, supprimez la source de données SMB/CIFS qui utilise Kerberos.

Sur l'hôte d'administration, avec l'export NFS monté sur /mnt/aide-config, supprimez les fichiers 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 vous avez modifié les paramètres DNS, rétablissez les paramètres d'origine.