Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden der LDAP-Authentifizierung
Lightweight Directory Access Protocol (LDAP) ist ein Anwendungsprotokoll zum Abfragen und Ändern von Objekten, die Ressourcen wie Benutzern und Computern entsprechen, die bei einem LDAP-kompatiblen Verzeichnisdiensteanbieter wie Active Directory oder auf einem OpenLDAP-Server gespeichert sind. Sie können das [LDAP-Authentifikator-Plug-In für JupyterHub](https://github.com/jupyterhub/ldapauthenticator/) with JupyterHub auf Amazon EMR verwenden, um LDAP für die Benutzerauthentifizierung zu verwenden. Das Plugin verwaltet Anmeldesitzungen für LDAP-Benutzer und stellt Jupyter Benutzerinformationen zur Verfügung. Auf diese Weise können Benutzer mithilfe der auf einem LDAP-kompatiblen Server gespeicherten Anmeldeinformationen für ihre Identitäten eine Verbindung zu JupyterHub und Notebooks herstellen.
Die Schritte in diesem Abschnitt führen Sie durch die folgenden Schritte zur Einrichtung und Aktivierung von LDAP mithilfe des LDAP Authenticator-Plug-ins für. JupyterHub Sie führen die Schritte aus, während Sie mit der Befehlszeile des Master-Knotens verbunden sind. Weitere Informationen finden Sie unter [Eine Verbindung mit dem Hauptknoten und Notebook-Servern herstellen](emr-jupyterhub-connect.md).
1. Erstellen Sie eine LDAP-Konfigurationsdatei mit Informationen über den LDAP-Server, wie Host-IP-Adresse, Port, Bindungsnamen usw.
1. Ändern Sie `/etc/jupyter/conf/jupyterhub_config.py`, um das LDAP-Authenticator-Plug-in für JupyterHub zu aktivieren.
1. Erstellen Sie ein Skript, das LDAP innerhalb des `jupyterhub`-Containers konfiguriert, und führen Sie es aus.
1. Fragen Sie LDAP nach Benutzern ab und erstellen Sie dann Basisverzeichnisse innerhalb des Containers für jeden Benutzer. JupyterHub benötigt Home-Verzeichnisse zum Hosten von Notebooks.
1. Führen Sie ein Skript aus, das neu gestartet wird JupyterHub
**Wichtig**
Bevor Sie LDAP einrichten, testen Sie Ihre Netzwerkinfrastruktur, um sicherzustellen, dass der LDAP-Server und der Cluster-Master-Knoten wie gefordert kommunizieren können. TLS verwendet in der Regel Port 389 über eine einfache TCP-Verbindung. Wenn Ihre LDAP-Verbindung SSL verwendet, ist der bekannte TCP-Port für SSL 636.
## Die LDAP-Konfigurationsdatei erstellen
Das folgende Beispiel verwendet die folgenden Platzhalter-Konfigurationswerte. Ersetzen Sie diese durch Parameter, die Ihrer Implementierung entsprechen.
+ Der LDAP-Server läuft in Version 3 und ist auf Port 389 verfügbar. Dies ist der standardmäßige Nicht-SSL-Port für LDAP.
+ Der grundlegende spezifische Name (DN, Distinguished Name) ist `dc=example, dc=org`.
Erstellen Sie mit einem Texteditor die Datei [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html) mit Inhalt, der etwa wie folgt aussieht. Verwenden Sie geeignete Werte für Ihre LDAP-Implementierung. *host*Ersetzen Sie es durch die IP-Adresse oder den auflösbaren Hostnamen Ihres LDAP-Servers.
```
base dc=example,dc=org
uri ldap://host
ldap_version 3
binddn cn=admin,dc=example,dc=org
bindpw admin
```
## Aktivieren Sie das LDAP Authenticator Plugin für JupyterHub
Verwenden Sie einen Texteditor, um die Datei `/etc/jupyter/conf/jupyterhub_config.py` zu ändern, und fügen Sie [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator)-Eigenschaften hinzu, etwa wie folgt. *host*Ersetzen Sie es durch die IP-Adresse oder den auflösbaren Hostnamen des LDAP-Servers. Das Beispiel geht davon aus, dass sich die Benutzerobjekte innerhalb einer benannten Organisationseinheit (OU) befinden*people*, und verwendet die definierten Namenskomponenten, die Sie zuvor mit Hilfe eingerichtet haben. `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'
```
## LDAP im Container konfigurieren
Erstellen Sie mithilfe eines Texteditors ein Bash-Skript mit folgendem Inhalt:
```
#!/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"
```
Speichern Sie das Skript auf dem Master-Knoten und führen Sie es in der Befehlszeile des Master-Knotens aus. Wenn das Skript beispielsweise als `configure_ldap_client.sh` gespeichert ist, machen Sie die Datei ausführbar:
```
chmod +x configure_ldap_client.sh
```
Und führen das Skript aus:
```
./configure_ldap_client.sh
```
## Attribute zur Active Directory hinzufügen
Um jeden Benutzer zu finden und den entsprechenden Eintrag in der Datenbank zu erstellen, benötigt der JupyterHub Docker-Container die folgenden UNIX-Eigenschaften für das entsprechende Benutzerobjekt in Active Directory. Weitere Informationen finden Sie im Abschnitt *Wie bearbeite ich weiterhin die GID/UID RFC 2307-Attribute, da das Unix Attributes Plug-in für das MMC-Snap-In Active Directory-Benutzer und -Computer nicht mehr verfügbar ist*? im Artikel [Klarstellung zum Status der Identitätsverwaltung für Unix (IDMU) und der NIS-Serverrolle in der technischen Vorschau von Windows Server 2016](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) und darüber hinaus.
+ `homeDirectory`
Dies ist der Speicherort im Stammverzeichnis des Benutzers, das in der Regel `/home/username` ist.
+ `gidNumber`
Dies ist ein Wert größer als 60.000, der noch nicht von einem anderen Benutzer verwendet wird. Überprüfen Sie die `etc/passwd`-Datei auf GIDs, die bereits verwendet werden.
+ `uidNumber`
Dies ist ein Wert größer als 60000, der noch nicht von einer anderen Gruppe verwendet wird. Überprüfen Sie die `etc/group`-Datei auf UIDs, die bereits verwendet werden.
+ `uid`
Das ist dasselbe wie das*username*.
## Root-Verzeichnisse für Benutzer erstellen
JupyterHub benötigt Home-Verzeichnisse innerhalb des Containers, um LDAP-Benutzer zu authentifizieren und Instanzdaten zu speichern. Das folgende Beispiel zeigt zwei Benutzer, *shirley* und *diego*, im LDAP-Verzeichnis.
Der erste Schritt besteht darin, den LDAP-Server mithilfe von [ldapsearch nach](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html) den Benutzer-IDs und Gruppen-ID-Informationen der einzelnen Benutzer abzufragen, wie im folgenden Beispiel gezeigt, und durch die IP-Adresse oder den auflösbaren Hostnamen Ihres LDAP-Servers zu *host* ersetzen:
```
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
```
Der Befehl `ldapsearch` gibt eine LDIF-formatierte Antwort zurück, die für die Benutzer *shirley* und *diego* etwa wie nachfolgend gezeigt aussieht.
```
# 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
```
Unter Verwendung der Informationen aus der Antwort führen Sie Befehle innerhalb des Containers zum Erstellen eines Stammverzeichnisses für jeden allgemeinen Namen (`cn`) des Benutzers aus. Verwenden Sie `uidNumber` und `gidNumber`, um das Eigentum für das Stammverzeichnis für diesen Benutzer festzulegen. Die folgenden Beispielbefehle erledigen dies für den Benutzer. *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"
```
**Anmerkung**
Der LDAP-Authentifikator für JupyterHub unterstützt die lokale Benutzererstellung nicht. Weitere Informationen finden Sie unter [LDAP-Authentifikator-Konfigurationshinweis zur lokalen Benutzererstellung](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation).
Um einen lokalen Benutzer manuell zu erstellen, verwenden Sie den folgenden Befehl.
```
sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd"
```
## Starten Sie den Container neu JupyterHub
Führen Sie den folgenden Befehl aus, um den `jupyterhub`-Container neu zu starten:
```
sudo docker stop jupyterhub
sudo docker start jupyterhub
```