Gestion des utilisateurs AWS ParallelCluster SSH avec OpenLDAP: idk.dev – Serveur d’impression

[aws]



aws_region_name = eu-west-1
[global]
update_check = vrai
sanity_check = vrai
cluster_template = par défaut

[cluster default]
nom_clé = 
master_instance_type = c5.xlarge
compute_instance_type = c5n.18xlarge
enable_efa = calculer
placement_group = DYNAMIQUE
placement = calculer
disable_hyperthreading = true
post_install = s3: ///post-install.sh
s3_read_resource = arn: aws: s3 :::/ *
initial_queue_size = 0
max_queue_size = 20
keep_initial_size = false
planificateur = slurm
cluster_type = ondemand
master_root_volume_size = 340
compute_root_volume_size = 340
base_os = centos7
vpc_settings = std-vpc

[vpc std-vpc]
vpc_id = 
master_subnet_id = 
compute_subnet_id = 

#! / bin / bash
exec>> (tee /var/log/post-install.log|logger -t données-utilisateur -s 2> / dev / console) 2> & 1

### Fonctions utilitaires

install_server_packages () 
    yum -y installer openldap compat-openldap openldap-clients openldap-servers openldap-servers-sql openldap-devel


prepare_ldap_server ()  awk 'print $ 1'> /root/.ldappasswd
    chmod 400 /root/.ldappasswd
    # Utilisez le mot de passe pour générer un hachage de mot de passe LDAP
    LDAP_HASH = $ (slappasswd -T /root/.ldappasswd)
    # Spécification de la configuration LDAP initiale
    chat <<-EOF > /root/ldapdb.ldif
dn: olcDatabase = 2 hdb, cn = config
type de changement: modifier
remplacer: olcSuffix
olcSuffix: dc = $ stack_name, dc = internal

dn: olcDatabase = 2 hdb, cn = config
type de changement: modifier
remplacer: olcRootDN
olcRootDN: cn = ldapadmin, dc = $ stack_name, dc = internal

dn: olcDatabase = 2 hdb, cn = config
type de changement: modifier
remplacer: olcRootPW
olcRootPW: $ LDAP_HASH
EOF
    # Appliquer les paramètres LDAP
    ldapmodify -Y EXTERNAL -H ldapi: /// -f /root/ldapdb.ldif
    # Appliquer les paramètres de base de données LDAP
    cp /usr/share/openldap-servers/DB_CONFIG.example / var / lib / ldap / DB_CONFIG
    chown ldap: ldap / var / lib / ldap / *
    # Appliquer un ensemble minimal de schémas LDAP
    ldapadd -Y EXTERNAL -H ldapi: /// -f /etc/openldap/schema/cosine.ldif
    ldapadd -Y EXTERNAL -H ldapi: /// -f /etc/openldap/schema/nis.ldif
    # Spécifiez une structure de répertoire minimale
    chat <<-EOF > /root/struct.ldif
dn: dc = $ stack_name, dc = internal
dc: $ stack_name
objectClass: haut
objectClass: domaine

dn: cn = ldapadmin, dc = $ stack_name, dc = internal
objectClass: OrganizationRole
cn: ldapadmin
description: Admin LDAP

dn: ou = Users, dc = $ stack_name, dc = internal
objectClass: organizationUnit
ou: Utilisateurs
EOF
    # Appliquer la structure des répertoires
    ldapadd -x -W -D "cn = ldapadmin, dc = $ stack_name, dc = internal" -f /root/struct.ldif -y /root/.ldappasswd
    # Enregistrez le nom d'hôte du contrôleur dans un emplacement partagé pour une utilisation ultérieure
    echo "ldap_server = $ (nom d'hôte)"> /home/.ldap


install_client_packages () 
    miam -y installer openldap-clients nss-pam-ldapd


prepare_ldap_client () 
    source / etc / parallelcluster / cfnconfig
    source /home/.ldap
    authconfig --enableldap
               --enableldapauth
               --ldapserver = $ ldap_server
               --ldapbasedn = "dc = $ stack_name, dc = internal"
               --enablemkhomedir
               --mettre à jour
    systemctl redémarrage nslcd


### Corps principal

# Charger les variables d'environnement depuis ParallelCluster
source / etc / parallelcluster / cfnconfig
# Si le script est en cours d'exécution sur le contrôleur, configurez le serveur LDAP
si [ $cfn_node_type  == 'MasterServer' ]; puis
    install_server_packages
    prepare_ldap_server

Fi

# Pour les nœuds de contrôleur et de calcul, activez l'authentification LDAP
install_client_packages
prepare_ldap_client

Lorsque le script est exécuté sur l'instance de contrôleur, le install_server_packages et prepare_ldap_server les fonctions s'exécutent en premier, suivies de install_client_packages et prepare_ldap_client les fonctions. Toutes ces étapes se produisent pendant le processus de création de cluster initial. Lors des lancements d'instance suivants (c'est-à-dire lorsque le cluster évolue pour répondre aux demandes des travaux soumis), le processus de post-installation sur les nœuds de calcul exécutera uniquement le install_client_packages et prepare_ldap_client pas.

C'est tout! Une fois le lancement du cluster terminé, il sera prêt à accueillir de nouveaux utilisateurs.

Processus de post-installation

Avant d'ajouter des utilisateurs, parcourons le processus de post-installation étape par étape. passez à la section suivante si vous souhaitez simplement continuer à utiliser votre cluster.

Dans le prepare_ldap_server fonction, nous commençons par démarrer la giflé démon – c'est le service OpenLDAP – qui maintiendra une base de données d'utilisateurs et permettra aux clients de s'authentifier.

Ensuite, nous générons une chaîne aléatoire à utiliser comme mot de passe de configuration LDAP et la plaçons dans le répertoire de base racine pour réutiliser plus tard. Nous générons également un hachage approprié à partir du mot de passe à insérer dans LDAP. La configuration LDAP initiale définit le olcSuffix, olcRootDN, et olcRootPW paramètres aux valeurs que nous choisissons. Dans ce cas, les affectations de variables importantes sont cn = ldapadmin, dc = $ stack_name, dc = internal et $ LDAP_HASH.

Nous sommes libres de modifier le nom commun du compte administrateur LDAP à partir de ldapadmin à tout ce que nous choisissons, et ajustez également les composants du domaine de $ stack_name et interne selon nos propres préférences. Le point clé est de s'assurer que nos valeurs choisies sont cohérentes tout au long du script. le ldapmodify La commande applique ces paramètres au service LDAP en cours d'exécution.

Ensuite, nous importons une configuration de base de données par défaut à partir des fichiers fournis avec le package de serveur LDAP, et nous assurons le LDAP l'utilisateur du service possède tous les fichiers pertinents. La dernière étape de configuration du serveur consiste à définir et à appliquer une structure de répertoire utilisateur simple. Cela définit les fichiers liés les uns aux autres et leur permet d'être regroupés en unités organisationnelles. Pour cet exemple minimal, nous n'avons besoin que des définitions de schéma COSINE et NIS, qui sont fournies dans le cadre de l'installation LDAP. Ceux-ci décrivent la configuration minimale requise pour ajouter un utilisateur à LDAP. Notre structure de répertoires (spécifiée dans le struct.ldif fichier créé en ligne) contient une seule unité organisationnelle pour nos utilisateurs AWS ParallelCluster.

Avant de passer à la configuration du client, nous enregistrons le nom d'hôte du serveur LDAP dans un emplacement partagé qui sera accessible aux clients sur les instances de calcul. Dans ce cas, nous pouvons placer un fichier dans le /Accueil répertoire, car il sera partagé avec le reste du cluster via NFS.

le prepare_ldap_client La fonction établit la connexion entre les clients, exécutés sur l'instance de contrôleur ainsi que sur toutes les futures instances de calcul, et le serveur LDAP – dans ce cas, à l'aide de variables définies à la fois dans un emplacement AWS ParallelCluster standard (/ etc / parallelcluster / cfnconfig) et le /home/.ldap fichier que nous avons créé lors de la préparation du serveur.

Ajout d'utilisateurs de cluster

Une fois que l'instance de contrôleur de cluster démarre et que la configuration LDAP est terminée, nous devons ajouter des utilisateurs au service d'annuaire. Connectez-vous au cluster en tant qu'utilisateur par défaut (centos dans ce cas) avec la commande:

pcluster ssh 

ssh -i  centos @

#! / bin / bash

# N'agissez que si deux arguments sont fournis et que l'UID est suffisamment élevé
si [ $# -eq 2 ] && [ "$2" -eq "$2" ] 2> / dev / null && [ "$2" -gt 1000 ]; puis
  NOM D'UTILISATEUR = 1 $
  USERID = 2 $
autre
  echo "Utilisation:` basename $ 0`  "
  écho " doit être une chaîne "
  écho " doit être un entier supérieur à 1 000 "
  sortie 1
Fi

# Charger les variables d'environnement qui identifient le type d'instance
source / etc / parallelcluster / cfnconfig

# Ecrire une configuration d'objet LDAP minimale pour un utilisateur
chat <<-EOF > /tmp/$USERNAME.ldif
dn: uid = $ USERNAME, ou = Users, dc = $ stack_name, dc = internal
objectClass: haut
objectClass: compte
objectClass: posixAccount
objectClass: shadowAccount
cn: $ USERNAME
uid: $ USERNAME
uidNumber: $ USERID
gidNumber: 100
homeDirectory: / home / $ USERNAME
loginShell: / bin / bash
EOF

# Ajouter l'utilisateur à LDAP
ldapadd -x -D "cn = ldapadmin, dc = $ stack_name, dc = internal" -f /tmp/$USERNAME.ldif -y /root/.ldappasswd

# Ranger et vérifier que l'entrée a réussi
rm /tmp/$USERNAME.ldif
getent passwd $ 1

sudo ./add-user.sh alice 3000

source / etc / parallelcluster / cfnconfig
ldapadd -x -D "cn = ldapadmin, dc = $ stack_name, dc = internal" -f  -y 

#! / bin / bash

# N'agissez que si deux arguments sont fournis et le second est un fichier local
si [ $# -eq 2 ] && [ -f "$2" ] ; puis
  NOM D'UTILISATEUR = 1 $
  KEYFILE = 2 $
autre
  echo "Utilisation:` basename $ 0`  "
  écho " doit être un compte utilisateur "
  écho " doit être un fichier de clé publique SSH "
  sortie 1
Fi

# Créez le répertoire home et .ssh de l'utilisateur, configurez le fichier authorized_keys
# Notez que cela écrasera toutes les clés existantes si elles sont utilisées plusieurs fois
mkhomedir_helper $ USERNAME
mkdir -p /home/$USERNAME/.ssh
cat $ KEYFILE> /home/$USERNAME/.ssh/authorized_keys
chmod 600 /home/$USERNAME/.ssh/authorized_keys
chown -R $ USERNAME: utilisateurs / domicile / $ USERNAME