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. # Hinzufügen von Jupyter-Notebook-Benutzern und Administratoren Sie können eine von zwei Methoden verwenden, um sich für Benutzer zu authentifizieren, JupyterHub sodass sie Notizbücher erstellen und optional verwalten können. JupyterHub Die einfachste Methode ist die Verwendung JupyterHub des Pluggable Authentication Module (PAM). Darüber hinaus unterstützt EMR JupyterHub auf Amazon das [LDAP-Authentifikator-Plugin JupyterHub zum](https://github.com/jupyterhub/ldapauthenticator/) Abrufen von Benutzeridentitäten von einem LDAP-Server, z. B. einem Microsoft Active Directory-Server. Anweisungen und Beispiele für das Hinzufügen von Benutzern mit den beiden Authentifizierungsmethoden finden Sie in diesem Abschnitt. JupyterHub hat auf Amazon EMR einen Standardbenutzer mit Administratorrechten. Der Benutzername ist `jovyan` , das Passwort ist `jupyter`. Wir empfehlen Ihnen dringend, den Benutzer durch einen anderen Benutzer mit Administratorrechten zu ersetzen. Dies ist mit einem Schritt beim Erstellen des Clusters oder durch das Herstellen einer Verbindung zum Master-Knoten möglich, während der Cluster ausgeführt wird. **Topics** + [ # Verwenden der PAM-Authentifizierung ](emr-jupyterhub-pam-users.md) + [ # Verwenden der LDAP-Authentifizierung ](emr-jupyterhub-ldap-users.md) + [ # Benutzer-Identitätswechsel ](emr-jupyterhub-user-impersonation.md) # Verwenden der PAM-Authentifizierung Das Erstellen von PAM-Benutzern in JupyterHub Amazon EMR erfolgt in zwei Schritten. Der erste Schritt besteht darin, dem Betriebssystem, das im Container `jupyterhub` auf dem Master-Knoten ausgeführt wird, Benutzer hinzuzufügen, und für jeden Benutzer ein entsprechendes Benutzer-Stammverzeichnis hinzuzufügen. Der zweite Schritt besteht darin, diese Betriebssystembenutzer als JupyterHub Benutzer hinzuzufügen — ein Vorgang, der als Whitelisting bezeichnet wird. JupyterHub Nachdem ein JupyterHub Benutzer hinzugefügt wurde, kann er eine Verbindung zur JupyterHub URL herstellen und seine Betriebssystemanmeldeinformationen für den Zugriff angeben. Wenn sich ein Benutzer anmeldet, JupyterHub wird die Notebook-Server-Instanz für diesen Benutzer geöffnet, die im Home-Verzeichnis des Benutzers auf dem Master-Knoten gespeichert ist`/var/lib/jupyter/home/username`. Wenn eine Notebook-Server-Instanz nicht existiert, JupyterHub wird eine Notebook-Instanz im Home-Verzeichnis des Benutzers erzeugt. In den folgenden Abschnitten wird gezeigt, wie Benutzer einzeln zum Betriebssystem und zu hinzugefügt werden JupyterHub, gefolgt von einem rudimentären Bash-Skript, das mehrere Benutzer hinzufügt. ## Hinzufügen eines Betriebssystembenutzers zum Container Das folgende Beispiel verwendet den Befehl [useradd](https://linux.die.net/man/8/useradd) innerhalb des Containers, um einen einzelnen Benutzer hinzuzufügen, diego, und ein Stammverzeichnis für diesen Benutzer anzulegen. Der zweite Befehl verwendet [chpasswd](https://linux.die.net/man/8/chpasswd), um diego ein Passwort für diesen Benutzer zu erteilen. Die Befehle werden in der Befehlszeile auf dem Master-Knoten ausgeführt, während mit SSH eine Verbindung eingerichtet wird. Sie können diese Befehle auch mithilfe eines Schritts ausführen, wie zuvor in [Administration durch Übermitteln von Schritten](emr-jupyterhub-administer.md#emr-jupyterhub-administer-steps) beschrieben. ``` sudo docker exec jupyterhub useradd -m -s /bin/bash -N diego sudo docker exec jupyterhub bash -c "echo diego:diego | chpasswd" ``` ## Einen Benutzer hinzufügen JupyterHub Sie können das **Admin-Panel** in JupyterHub oder die REST-API verwenden, um Benutzer und Administratoren oder einfach nur Benutzer hinzuzufügen. **So fügen Sie Benutzer und Administratoren über das Admin-Panel in hinzu JupyterHub** 1. Stellen Sie über SSH Connect zum Master-Knoten her und melden Sie sich *MasterNodeDNS* mit einer Identität mit Administratorrechten bei https: //:9443 an. 1. Wählen Sie **Control Panel (Systemsteuerung)**, **Admin (Administrator)**. 1. Wählen Sie **User (Benutzer)**, **Add Users (Benutzer hinzufügen)** oder wählen Sie **Admin (Administrator)**, **Add Admins (Administratoren hinzufügen)**. **So fügen Sie einen Benutzer mit dem REST API hinzu** 1. Stellen Sie unter Verwendung von SSH eine Verbindung mit dem Master-Knoten her und verwenden Sie den folgenden Befehl auf dem Master-Knoten, oder führen Sie den Befehl als Schritt aus. 1. Erwerben Sie ein Administrator-Token, um API-Anfragen zu stellen, und ersetzen Sie es *AdminToken* im folgenden Schritt durch dieses Token. 1. Verwenden Sie den folgenden Befehl und *UserName* ersetzen Sie ihn durch einen Betriebssystembenutzer, der im Container erstellt wurde. ``` curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName ``` **Anmerkung** Sie werden automatisch als Benutzer JupyterHub ohne Administratorrechte hinzugefügt, wenn Sie sich zum ersten Mal an der JupyterHub Weboberfläche anmelden. ## Beispiel: Bash-Skript zum Hinzufügen mehrerer Benutzer Das folgende Bash-Beispielskript verknüpft die vorherigen Schritte in diesem Abschnitt, um mehrere JupyterHub Benutzer zu erstellen. Das Skript kann direkt auf dem Hauptknoten ausgeführt werden, oder in Amazon S3 hochgeladen und als Schritt ausgeführt werden. Das Skript stellt zuerst ein Array mit Benutzernamen, und verwendet den Befehl `jupyterhub token` zum Erstellen eines API-Token für den Standard-Administrator, jovyan. Anschließend erstellt es einen Betriebssystem-Benutzer im `jupyterhub`-Container für jeden Benutzer und weist jedem von ihnen ein anfängliches Passwort zu, das gleich ihrem Benutzernamen ist. Schließlich ruft es die REST-API-Operation auf, um jeden Benutzer in JupyterHub zu erstellen. Es übergibt das Token, das zuvor im Skript erstellt wurde und gibt die REST-Antwort der besseren Übersicht halber per Pipe an `jq` weiter. ``` # Bulk add users to container and JupyterHub with temp password of username set -x USERS=(shirley diego ana richard li john mary anaya) TOKEN=$(sudo docker exec jupyterhub /opt/conda/bin/jupyterhub token jovyan | tail -1) for i in "${USERS[@]}"; do sudo docker exec jupyterhub useradd -m -s /bin/bash -N $i sudo docker exec jupyterhub bash -c "echo $i:$i | chpasswd" curl -XPOST --silent -k https://$(hostname):9443/hub/api/users/$i \ -H "Authorization: token $TOKEN" | jq done ``` Speichern Sie das Skript an einem Speicherort in Amazon S3, beispielsweise `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. Anschließend können Sie es mit `script-runner.jar` als Schritt ausführen. ### Beispiel: Ausführen des Skripts beim Erstellen eines Clusters (AWS CLI) **Anmerkung** Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^). ``` aws emr create-cluster --name="MyJupyterHubCluster" --release-label emr-5.36.2 \ --applications Name=JupyterHub --log-uri s3://amzn-s3-demo-bucket/MyJupyterClusterLogs \ --use-default-roles --instance-type m5.xlarge --instance-count 2 --ec2-attributes KeyName=MyKeyPair \ --steps Type=CUSTOM_JAR,Name=CustomJAR,ActionOnFailure=CONTINUE,\ Jar=s3://region.elasticmapreduce/libs/script-runner/script-runner.jar,Args=["s3://amzn-s3-demo-bucket/createjupyterusers.sh"] ``` ### Ausführen des Skripts auf einem vorhandenen Cluster (AWS CLI) **Anmerkung** Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^). ``` aws emr add-steps --cluster-id j-XXXXXXXX --steps Type=CUSTOM_JAR,\ Name=CustomJAR,ActionOnFailure=CONTINUE,\ Jar=s3://region.elasticmapreduce/libs/script-runner/script-runner.jar,Args=["s3://amzn-s3-demo-bucket/createjupyterusers.sh"] ``` # 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 ``` # Benutzer-Identitätswechsel Ein Spark-Auftrag, der in einem Jupyter-Notebook ausgeführt wird, durchläuft während seiner Ausführung in Amazon EMR mehrere Anwendungen. Zum Beispiel wird PySpark 3-Code, den ein Benutzer in Jupyter ausführt, von Sparkmagic empfangen. Sparkmagic verwendet eine HTTP-POST-Anfrage, um ihn an Livy zu senden, das dann einen Spark-Job erstellt, der mit YARN auf dem Cluster ausgeführt wird. Standardmäßig werden auf diese Weise gesendete YARN-Aufträge als Benutzer `livy` ausgeführt. Dies gilt unabhängig von dem Benutzer, der den Auftrag initiiert hat. Durch das Einrichten eines *Benutzer-Identitätswechsels* können Sie die Benutzer-ID des Notebook-Benutzers auch für den dem YARN-Auftrag zugeordneten Benutzer verwenden. Von `shirley` und `diego` initiierte Aufträge werden nicht dem Benutzer `livy` zugeordnet. Stattdessen werden die von den Benutzern initiierten Aufträge `shirley` und `diego` zugeordnet. Dies erleichtert das Überwachen der Jupyter-Nutzung und das Verwalten von Anwendungen in der Organisation. Diese Konfiguration wird nur unterstützt, wenn Aufrufe von Sparkmagic an Livy ohne Authentifizierung erfolgen. Anwendungen, die eine Authentifizierung oder einen Proxy-Layer zwischen Hadoop-Anwendungen und Livy (z. B. Apache Knox Gateway) bereitstellen, werden nicht unterstützt. Bei den Schritten zur Konfiguration des Benutzerwechsels in diesem Abschnitt wird davon ausgegangen, dass JupyterHub und Livy auf demselben Master-Knoten ausgeführt werden. Wenn die Anwendung separate Cluster enthält, muss [Schritt 3: HDFS-Stammverzeichnisse für Benutzer erstellen](#Step3-UserImpersonation) geändert werden, damit HDFS-Verzeichnisse auf dem Livy-Master-Knoten erstellt werden. **Topics** + [ ## Schritt 1: Livy konfigurieren ](#Step1-UserImpersonation) + [ ## Schritt 2: Benutzer hinzufügen ](#Step2-UserImpersonation) + [ ## Schritt 3: HDFS-Stammverzeichnisse für Benutzer erstellen ](#Step3-UserImpersonation) ## Schritt 1: Livy konfigurieren Sie verwenden die Konfigurationsklassifizierungen `livy-conf` und `core-site`, wenn Sie einen Cluster erstellen, um Livy-Benutzer-Identitätswechsel zu ermöglichen (siehe folgendes Beispiel). Speichern Sie die Konfigurationsklassifizierung als JSON-Objekt und verweisen Sie dann darauf, wenn Sie den Cluster erstellen. Sie können die Konfigurationsklassifizierung auch im Code angeben. Weitere Informationen finden Sie unter [Anwendungen konfigurieren](emr-configure-apps.md). ``` [ { "Classification": "livy-conf", "Properties": { "livy.impersonation.enabled": "true" } }, { "Classification": "core-site", "Properties": { "hadoop.proxyuser.livy.groups": "*", "hadoop.proxyuser.livy.hosts": "*" } } ] ``` ## Schritt 2: Benutzer hinzufügen Fügen Sie JupyterHub Benutzer mithilfe von PAM oder LDAP hinzu. Weitere Informationen erhalten Sie unter [Verwenden der PAM-Authentifizierung](emr-jupyterhub-pam-users.md) und [Verwenden der LDAP-Authentifizierung](emr-jupyterhub-ldap-users.md). ## Schritt 3: HDFS-Stammverzeichnisse für Benutzer erstellen Sie haben eine Verbindung zum Master-Knoten hergestellt, um Benutzer zu erstellen. Kopieren Sie den unten angegebenen Inhalt, während die Verbindung zum Master-Knoten noch besteht, und speichern Sie ihn in einer Skriptdatei. Das Skript erstellt HDFS-Home-Verzeichnisse für jeden JupyterHub Benutzer auf dem Master-Knoten. Das Skript geht davon aus, dass Sie die Standard-Administratorbenutzer-ID verwenden,*jovyan*. ``` #!/bin/bash CURL="curl --silent -k" HOST=$(curl -s http://169.254.169.254/latest/meta-data/local-hostname) admin_token() { local user=jovyan local pwd=jupyter local token=$($CURL https://$HOST:9443/hub/api/authorizations/token \ -d "{\"username\":\"$user\", \"password\":\"$pwd\"}" | jq ".token") if [[ $token != null ]]; then token=$(echo $token | sed 's/"//g') else echo "Unable to get Jupyter API Token." exit 1 fi echo $token } # Get Jupyter Admin token token=$(admin_token) # Get list of Jupyter users users=$(curl -XGET -s -k https://$HOST:9443/hub/api/users \ -H "Authorization: token $token" | jq '.[].name' | sed 's/"//g') # Create HDFS home dir for user in ${users[@]}; do echo "Create hdfs home dir for $user" hadoop fs -mkdir /user/$user hadoop fs -chmod 777 /user/$user done ```