Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de l'authentification LDAP
LDAP (Lightweight Directory Access Protocol) est un protocole d'application pour l'interrogation et la modification d'objets correspondant à des ressources telles que des utilisateurs et des ordinateurs stockés dans un fournisseur de services de répertoire compatible avec LDAP tel qu'Active Directory, ou dans un serveur OpenLDAP. Vous pouvez utiliser le [plug-in d'authentification LDAP pour](https://github.com/jupyterhub/ldapauthenticator/) with JupyterHub sur JupyterHub Amazon EMR afin d'utiliser le protocole LDAP pour l'authentification des utilisateurs. Le plug-in gère les sessions de connexion pour les utilisateurs LDAP et fournit des informations utilisateur à Jupyter. Cela permet aux utilisateurs de se connecter à JupyterHub des blocs-notes en utilisant les informations d'identification de leur identité stockées sur un serveur compatible LDAP.
Les étapes décrites dans cette section vous guident à travers les étapes suivantes pour configurer et activer LDAP à l'aide du plug-in d'authentification LDAP pour. JupyterHub Pour effectuer ces étapes, vous devez être connecté à la ligne de commande du nœud principal. Pour de plus amples informations, veuillez consulter [Connexion au nœud principal et aux serveurs de bloc-notes](emr-jupyterhub-connect.md).
1. Créez un fichier de configuration LDAP avec les informations sur le serveur LDAP, telles que l'adresse IP de l'hôte, le port, les noms de liaison, etc.
1. Modifiez `/etc/jupyter/conf/jupyterhub_config.py` pour activer le plug-in d'authentification LDAP pour JupyterHub.
1. Créez et exécutez un script qui configure LDAP dans le conteneur `jupyterhub`.
1. Interrogez LDAP pour les utilisateurs, puis créez des répertoires personnels dans le conteneur pour chaque utilisateur. JupyterHub nécessite des répertoires personnels pour héberger les blocs-notes.
1. Exécuter un script qui redémarre JupyterHub
**Important**
Avant de configurer LDAP, testez votre infrastructure réseau afin de vous assurer que le serveur LDAP et le nœud principal du cluster peuvent communiquer si nécessaire. Généralement, TLS utilise le port 389 sur une connexion TCP brute. Si votre connexion LDAP utilise SSL, le port TCP connu pour SSL est 636.
## Création du fichier de configuration LDAP
L'exemple ci-dessous utilise les valeurs de configuration d'espace réservé suivantes. Remplacez ces valeurs par des paramètres qui correspondent à votre implémentation.
+ Le serveur LDAP exécute la version 3 et est disponible sur le port 389. Il s'agit du port non SSL standard pour LDAP.
+ Le nom unique de base est `dc=example, dc=org`.
Utilisez un éditeur de texte pour créer le fichier [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), avec un contenu similaire à ce qui suit. Utilisez les valeurs appropriées pour votre implémentation LDAP. *host*Remplacez-le par l'adresse IP ou le nom d'hôte résoluble de votre serveur LDAP.
```
base dc=example,dc=org
uri ldap://host
ldap_version 3
binddn cn=admin,dc=example,dc=org
bindpw admin
```
## Activer le plug-in d'authentification LDAP pour JupyterHub
Utilisez un éditeur de texte pour modifier le fichier `/etc/jupyter/conf/jupyterhub_config.py` et ajouter les propriétés [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) similaires à ce qui suit. Remplacez *host* par l'adresse IP ou le nom d'hôte résoluble du serveur LDAP. L'exemple suppose que les objets utilisateur se trouvent au sein d'une unité organisationnelle (ou) nommée *people* et utilise les composants de nom unique que vous avez définis précédemment`ldap.conf`.
```
c.JupyterHub.authenticator_class = 'ldapauthenticator.LDAPAuthenticator'
c.LDAPAuthenticator.use_ssl = False
c.LDAPAuthenticator.server_address = 'host'
c.LDAPAuthenticator.bind_dn_template = 'cn={username},ou=people,dc=example,dc=org'
```
## Configuration de LDAP dans le conteneur
Utilisez un éditeur de texte pour créer un script bash avec le contenu suivant :
```
#!/bin/bash
# Uncomment the following lines to install LDAP client libraries only if
# using Amazon EMR release version 5.14.0. Later versions install libraries by default.
# sudo docker exec jupyterhub bash -c "sudo apt-get update"
# sudo docker exec jupyterhub bash -c "sudo apt-get -y install libnss-ldap libpam-ldap ldap-utils nscd"
# Copy ldap.conf
sudo docker cp ldap.conf jupyterhub:/etc/ldap/
sudo docker exec jupyterhub bash -c "cat /etc/ldap/ldap.conf"
# configure nss switch
sudo docker exec jupyterhub bash -c "sed -i 's/\(^passwd.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "sed -i 's/\(^group.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "sed -i 's/\(^shadow.*\)/\1 ldap/g' /etc/nsswitch.conf"
sudo docker exec jupyterhub bash -c "cat /etc/nsswitch.conf"
# configure PAM to create home directories
sudo docker exec jupyterhub bash -c "echo 'session required pam_mkhomedir.so skel=/etc/skel umask=077' >> /etc/pam.d/common-session"
sudo docker exec jupyterhub bash -c "cat /etc/pam.d/common-session"
# restart nscd service
sudo docker exec jupyterhub bash -c "sudo service nscd restart"
# Test
sudo docker exec jupyterhub bash -c "getent passwd"
# Install ldap plugin
sudo docker exec jupyterhub bash -c "pip install jupyterhub-ldapauthenticator"
```
Enregistrez le script sur le nœud principal, puis exécutez-le à partir de la ligne de commande du nœud principal. Par exemple, avec le script enregistré sous le nom `configure_ldap_client.sh`, rendez le fichier exécutable :
```
chmod +x configure_ldap_client.sh
```
Exécutez ensuite le script :
```
./configure_ldap_client.sh
```
## Ajout d'attributs à Active Directory
Pour rechercher chaque utilisateur et créer l'entrée appropriée dans la base de données, le conteneur JupyterHub docker nécessite les propriétés UNIX suivantes pour l'objet utilisateur correspondant dans Active Directory. Pour plus d'informations, consultez la section *Comment continuer à modifier les attributs de la GID/UID RFC 2307 maintenant que le plug-in d'attributs Unix n'est plus disponible pour le composant logiciel enfichable MMC Utilisateurs et ordinateurs Active Directory* ? dans l'article [Clarification concernant l'état de la gestion des identités pour Unix (IDMU) et le rôle du serveur NIS dans la version préliminaire technique de Windows Server 2016 et au-delà](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/).
+ `homeDirectory`
Il s'agit de l'emplacement de l’annuaire de base de l'utilisateur, qui est généralement `/home/username`.
+ `gidNumber`
Il s'agit d'une valeur supérieure à 60 000 qui n'est pas déjà utilisée par un autre utilisateur. Vérifiez le fichier `etc/passwd` pour les GID en cours d'utilisation.
+ `uidNumber`
Il s'agit d'une valeur supérieure à 60 000 qui n'est pas déjà utilisée par un autre groupe. Vérifiez le fichier `etc/group` pour les UID en cours d'utilisation.
+ `uid`
C'est le même que le*username*.
## Création de répertoires de base utilisateur
JupyterHub a besoin de répertoires personnels au sein du conteneur pour authentifier les utilisateurs LDAP et stocker les données d'instance. L'exemple suivant présente deux utilisateurs, *shirley* et *diego*, dans le répertoire LDAP.
La première étape consiste à interroger le serveur LDAP pour obtenir les informations d'identifiant d'utilisateur et d'identifiant de groupe de chaque utilisateur à l'aide de [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html), comme indiqué dans l'exemple suivant, en les *host* remplaçant par l'adresse IP ou le nom d'hôte résoluble de votre serveur LDAP :
```
ldapsearch -x -H ldap://host \
-D "cn=admin,dc=example,dc=org" \
-w admin \
-b "ou=people,dc=example,dc=org" \
-s sub \
"(objectclass=*)" uidNumber gidNumber
```
La commande `ldapsearch` renvoie une réponse au format LDIF qui ressemble à ce qui suit pour les utilisateurs *shirley* et *diego*.
```
# extended LDIF
# LDAPv3
# base with scope subtree
# filter: (objectclass=*)
# requesting: uidNumber gidNumber sn
# people, example.org
dn: ou=people,dc=example,dc=org
# diego, people, example.org
dn: cn=diego,ou=people,dc=example,dc=org
sn: B
uidNumber: 1001
gidNumber: 100
# shirley, people, example.org
dn: cn=shirley,ou=people,dc=example,dc=org
sn: A
uidNumber: 1002
gidNumber: 100
# search result
search: 2
result: 0 Success
# numResponses: 4
# numEntries: 3
```
À l'aide des informations contenues dans la réponse, exécutez des commandes dans le conteneur de manière à créer un répertoire de base pour chaque nom commun d'utilisateur (`cn`). Utilisez la valeur de `uidNumber` et de `gidNumber` pour corriger la propriété du répertoire de base pour cet utilisateur. Les exemples de commandes suivants le font pour l'utilisateur*shirley*.
```
sudo docker container exec jupyterhub bash -c "mkdir /home/shirley"
sudo docker container exec jupyterhub bash -c "chown -R $uidNumber /home/shirley"
sudo docker container exec jupyterhub bash -c "sudo chgrp -R $gidNumber /home/shirley"
```
**Note**
L'authentificateur LDAP pour JupyterHub ne prend pas en charge la création d'utilisateurs locaux. Pour plus d'informations, consultez la [Remarque sur la configuration de l'authentificateur LDAP pour la création d'utilisateurs locaux](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation).
Pour créer manuellement un utilisateur local, utilisez la commande suivante.
```
sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd"
```
## Redémarrer le JupyterHub conteneur
Exécutez la commande suivante pour redémarrer le conteneur `jupyterhub` :
```
sudo docker stop jupyterhub
sudo docker start jupyterhub
```