Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Aggiunta di utenti e amministratori Jupyter Notebook È possibile utilizzare uno dei due metodi con cui gli utenti possono autenticarsi in JupyterHub modo che possano creare notebook e, facoltativamente, amministrarli. JupyterHub Il metodo più semplice consiste nell'utilizzare il modulo di autenticazione collegabile ( JupyterHubPAM). Inoltre, JupyterHub su Amazon EMR supporta il [plug-in di autenticazione LDAP JupyterHub per](https://github.com/jupyterhub/ldapauthenticator/) ottenere le identità degli utenti da un server LDAP, come un server Microsoft Active Directory. Istruzioni ed esempi per l'aggiunta di utenti con ogni metodo di autenticazione vengono forniti in questa sezione. JupyterHub su Amazon EMR ha un utente predefinito con autorizzazioni di amministratore. Il nome utente è `jovyan` e la password è `jupyter`. Ti consigliamo di sostituire l'utente con un altro che dispone di autorizzazioni amministrative. È possibile eseguire questa operazione utilizzando una fase della creazione del cluster, oppure collegandosi al nodo master quando il cluster è in esecuzione. **Topics** + [Utilizzo dell'autenticazione PAM](emr-jupyterhub-pam-users.md) + [Utilizzo dell'autenticazione LDAP](emr-jupyterhub-ldap-users.md) + [Rappresentazione dell'utente](emr-jupyterhub-user-impersonation.md) # Utilizzo dell'autenticazione PAM La creazione di utenti PAM in JupyterHub Amazon EMR è un processo in due fasi. La prima fase è aggiungere utenti al sistema operativo in esecuzione nel container `jupyterhub` sul nodo master e aggiungere una home directory utente corrispondente per ogni utente. Il secondo passaggio consiste nell'aggiungere questi utenti del sistema operativo come JupyterHub utenti, un processo noto come whitelisting in. JupyterHub Una volta aggiunto, un JupyterHub utente può connettersi all' JupyterHub URL e fornire le credenziali del sistema operativo per l'accesso. Quando un utente accede, JupyterHub apre l'istanza del server notebook per quell'utente, che viene salvata nella home directory dell'utente sul nodo master, ovvero. `/var/lib/jupyter/home/username` Se non esiste un'istanza del server notebook, JupyterHub genera un'istanza di notebook nella home directory dell'utente. Le sezioni seguenti mostrano come aggiungere utenti singolarmente al sistema operativo e a JupyterHub, seguite da uno script bash rudimentale che aggiunge più utenti. ## Aggiunta di un utente del sistema operativo al container Nell'esempio seguente viene utilizzato innanzitutto il comando [useradd](https://linux.die.net/man/8/useradd) all'interno del container per aggiungere un singolo utente, diego, e creare una home directory per tale utente. Il secondo comando utilizza [chpasswd](https://linux.die.net/man/8/chpasswd) per stabilire una password di diego per questo utente. I comandi vengono eseguiti sulla riga di comando del nodo master durante la connessione mediante SSH. Puoi anche eseguire questi comandi utilizzando una fase come descritto in precedenza in [Amministrazione inviando fasi](emr-jupyterhub-administer.md#emr-jupyterhub-administer-steps). ``` sudo docker exec jupyterhub useradd -m -s /bin/bash -N diego sudo docker exec jupyterhub bash -c "echo diego:diego | chpasswd" ``` ## Aggiungere un utente JupyterHub Puoi utilizzare il pannello di **amministrazione** JupyterHub o l'API REST per aggiungere utenti e amministratori o solo utenti. **Per aggiungere utenti e amministratori utilizzando il pannello di amministrazione in JupyterHub** 1. Connect al master node tramite SSH e accedi a https: //:9443 *MasterNodeDNS* con un'identità con autorizzazioni di amministratore. 1. Scegliere **Control Panel (Pannello di controllo)**, **Admin (Amministratore)**. 1. Scegliere **User (Utente)**, **Add Users (Aggiungi utenti)** o scegliere **Admin (Amministratore)**, **Add Admins (Aggiungi amministratori)**. **Per aggiungere un utente utilizzando la REST API** 1. Connettersi al nodo master mediante SSH e utilizzare il comando seguente sul nodo master o eseguire il comando come una fase. 1. Acquisisci un token amministrativo per effettuare richieste API e sostituiscilo *AdminToken* nel passaggio successivo con quel token. 1. Utilizzate il seguente comando, sostituendolo *UserName* con un utente del sistema operativo creato all'interno del contenitore. ``` curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName ``` **Nota** Verrai aggiunto automaticamente come utente JupyterHub non amministratore quando accedi all'interfaccia JupyterHub web per la prima volta. ## Esempio: Script bash per aggiungere più utenti Il seguente script bash di esempio collega i passaggi precedenti di questa sezione per creare più JupyterHub utenti. Lo script può essere eseguito direttamente sul nodo master o può essere caricato in Amazon S3 e, successivamente, eseguito come fase. Il primo script stabilisce una serie di nomi utente e utilizza il comando `jupyterhub token` per creare un token API per l'amministratore predefinito, jovyan. Quindi crea un utente del sistema operativo nel container `jupyterhub` per ogni utente, assegnando a ciascuno una password iniziale che è uguale al relativo nome utente. Infine, chiama l'operazione API REST per creare ogni utente in JupyterHub. Il token generato in precedenza nello script viene passato ed la risposta REST viene reindirizzata a `jq` per facilitare la visualizzazione. ``` # 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 ``` Salva lo script in un percorso in Amazon S3, ad esempio `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. Quindi puoi utilizzare `script-runner.jar` per eseguirlo come una fase. ### Esempio: Esecuzione dello script durante la creazione di un cluster (AWS CLI) **Nota** I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^). ``` 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"] ``` ### Esecuzione dello script su un cluster esistente (AWS CLI) **Nota** I caratteri di continuazione della riga Linux (\$1) sono inclusi per la leggibilità. Possono essere rimossi o utilizzati nei comandi Linux. Per Windows, rimuoverli o sostituirli con un accento circonflesso (^). ``` 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"] ``` # Utilizzo dell'autenticazione LDAP LDAP è un protocollo di applicazioni per inviare query e modificare oggetti che corrispondono a risorse quali utenti e computer archiviati in un provider di servizi di directory compatibile con LDAP, ad esempio Active Directory o un server OpenLDAP. Puoi utilizzare il [plug-in di autenticazione LDAP per with JupyterHub su JupyterHub Amazon EMR per](https://github.com/jupyterhub/ldapauthenticator/) utilizzare LDAP per l'autenticazione degli utenti. Il plugin gestisce sessioni di accesso per utenti LDAP e fornisce informazioni utente a Jupyter. Ciò consente agli utenti di connettersi ai notebook utilizzando JupyterHub le credenziali per le loro identità archiviate in un server compatibile con LDAP. I passaggi di questa sezione illustrano i seguenti passaggi per configurare e abilitare LDAP utilizzando il plug-in LDAP Authenticator per. JupyterHub Eseguire le fasi mentre si è connessi alla riga di comando del nodo master. Per ulteriori informazioni, consulta [Connessione al nodo master e ai server notebook](emr-jupyterhub-connect.md). 1. Crea un file di configurazione LDAP con informazioni sul server LDAP, ad esempio l'indirizzo IP host, la porta, i nomi di binding e così via. 1. Modifica `/etc/jupyter/conf/jupyterhub_config.py` per abilitare LDAP Authenticator Plugin per JupyterHub. 1. Crea ed esegui uno script che configura LDAP all'interno del container `jupyterhub`. 1. Interroga LDAP per gli utenti, quindi crea le home directory all'interno del contenitore per ogni utente. JupyterHub richiede le home directory per ospitare i notebook. 1. Esegui uno script che si riavvia JupyterHub **Importante** Prima di configurare LDAP, verifica l'infrastruttura di rete per garantire che il server LDAP e il nodo master del cluster siano in grado di comunicare come richiesto. TLS utilizza in genere la porta 389 su una connessione TCP semplice. Se la connessione LDAP utilizza SSL, la porta TCP nota per SSL è 636. ## Creazione del file di configurazione LDAP Nell'esempio seguente vengono utilizzati i seguenti valori di configurazione del segnaposto. Sostituiscili con i parametri che soddisfano l'implementazione. + Il server LDAP esegue la versione 3 ed è disponibile sulla porta 389. Questa è la porta non SSL standard per LDAP. + Il nome distinto di base (DN) è `dc=example, dc=org`. Utilizza un editor di testo per creare il file [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), con contenuti simili ai seguenti. Utilizza valori appropriate per l'implementazione LDAP. *host*Sostituiscilo con l'indirizzo IP o il nome host risolvibile del tuo server LDAP. ``` base dc=example,dc=org uri ldap://host ldap_version 3 binddn cn=admin,dc=example,dc=org bindpw admin ``` ## Abilita il plug-in LDAP Authenticator per JupyterHub Utilizza un editor di testo per modificare il file `/etc/jupyter/conf/jupyterhub_config.py` e aggiungere proprietà [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) simili alle seguenti. Sostituire *host* con l'indirizzo IP o il nome host risolvibile del server LDAP. L'esempio presuppone che gli oggetti utente si trovino all'interno di un'unità organizzativa (ou) denominata *people* e utilizzi i componenti del nome distinto definiti in precedenza utilizzando. `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' ``` ## Configurazione di LDAP all'interno del container Utilizza un editor di testo per creare uno script bash con il seguente contenuto: ``` #!/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" ``` Salva lo script nel nodo master, quindi eseguilo dalla riga di comando del nodo master. Ad esempio, con lo script salvato come `configure_ldap_client.sh`, rendi il file eseguibile: ``` chmod +x configure_ldap_client.sh ``` Ed esegui lo script: ``` ./configure_ldap_client.sh ``` ## Aggiunta di attributi ad Active Directory Per trovare ogni utente e creare la voce appropriata nel database, il contenitore JupyterHub docker richiede le seguenti proprietà UNIX per l'oggetto utente corrispondente in Active Directory. Per ulteriori informazioni, vedere la sezione *Come posso continuare a modificare gli attributi GID/UID RFC 2307 ora che il plug-in Unix Attributes non è più disponibile per lo snap-in MMC Active Directory Users* and Computers? nell'articolo [Chiarimenti sullo stato della gestione delle identità per Unix (IDMU) e sul ruolo del server NIS nell'anteprima tecnica di Windows Server 2016 e](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) oltre. + `homeDirectory` Questo è il percorso alla home directory dell'utente, in genere `/home/username`. + `gidNumber` Si tratta di un valore maggiore di 60000 che non è già utilizzato da un altro utente. Seleziona il file `etc/passwd` per i gid in uso. + `uidNumber` Si tratta di un valore maggiore di 60000 che non è già utilizzato da un altro gruppo. Seleziona il file `etc/group` per gli uid in uso. + `uid` È lo stesso di. *username* ## Creazione di home directory dell'utente JupyterHub necessita di home directory all'interno del contenitore per autenticare gli utenti LDAP e archiviare i dati delle istanze. Nell'esempio seguente vengono illustrati due utenti, *shirley* e *diego*, nella directory LDAP. Il primo passaggio consiste nell'interrogare il server LDAP per le informazioni sull'ID utente e sull'ID di gruppo di ciascun utente utilizzando [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html), come mostrato nell'esempio seguente, sostituendolo *host* con l'indirizzo IP o il nome host risolvibile del server 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 ``` Il comando `ldapsearch` restituisce una risposta in formato LDIF il cui aspetto è simile al seguente per gli utenti *shirley* e *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 ``` Utilizzando le informazioni della risposta, esegui comandi all'interno del container per creare una home directory per ogni nome comune dell'utente (`cn`). Utilizza `uidNumber` e `gidNumber` per correggere la proprietà per la home directory di tale utente. I seguenti comandi di esempio eseguono questa operazione per l'utente. *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" ``` **Nota** L'autenticatore LDAP per non JupyterHub supporta la creazione di utenti locali. Per ulteriori informazioni, consulta [Nota sulla configurazione di LDAP Authenticator per la creazione di utenti locali](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation). Per creare manualmente un utente locale, utilizzare il comando seguente. ``` sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd" ``` ## Riavvia il contenitore JupyterHub Esegui i comandi seguenti per riavviare il container `jupyterhub`: ``` sudo docker stop jupyterhub sudo docker start jupyterhub ``` # Rappresentazione dell'utente Un processo Spark in esecuzione all'interno di un notebook Jupyter passa attraverso più applicazioni durante la propria esecuzione su Amazon EMR. Ad esempio, il codice PySpark 3 eseguito da un utente all'interno di Jupyter viene ricevuto da Sparkmagic, che utilizza una richiesta HTTP POST per inviarlo a Livy, che quindi crea un job Spark da eseguire sul cluster utilizzando YARN. Per impostazione predefinita, le operazioni YARN inviate in questo modo vengono eseguite come utente `livy`, indipendentemente dall'utente che ha avviato il processo. Impostando la *rappresentazione degli utenti* si può fare in modo che l'ID utente dell'utente del notebook sia anche l'utente associato al processo YARN. Anziché avere processi avviati da entrambi `shirley` e `diego` associati con l'utente `livy`, i processi avviati da ciascun utente sono associati a `shirley` e `diego` rispettivamente. In questo modo è possibile effettuare un audit dell'utilizzo di Jupyter e gestire le applicazioni all'interno della propria organizzazione. Questa configurazione è supportata solo quando le chiamate da Sparkmagic a Livy non sono autenticate. Le applicazioni che forniscono un livello di autenticazione o di proxy tra le applicazioni Hadoop e Livy (ad esempio Apache Knox Gateway) non sono supportate. I passaggi per configurare l'impersonificazione dell'utente in questa sezione presuppongono che Livy JupyterHub e Livy siano in esecuzione sullo stesso nodo principale. Se la tua applicazione ha cluster separati, [Fase 3: crea le directory home HDFS per gli utenti](#Step3-UserImpersonation) deve essere modificato in modo che le directory HDFS vengano create nel nodo master Livy. **Topics** + [Fase 1: configurazione di Livy](#Step1-UserImpersonation) + [Fase 2: aggiungere gli utenti](#Step2-UserImpersonation) + [Fase 3: crea le directory home HDFS per gli utenti](#Step3-UserImpersonation) ## Fase 1: configurazione di Livy È possibile utilizzare le classificazioni di configurazioni `livy-conf` e `core-site` al momento della creazione di un cluster per consentire la rappresentazione dell'utente Livy come mostrato nel seguente esempio. Salva la classificazione di configurazione come JSON, quindi fai riferimento a essa al momento della creazione del cluster, oppure specifica la configurazione della classificazione inline. Per ulteriori informazioni, consulta [Configurazione delle applicazioni](emr-configure-apps.md). ``` [ { "Classification": "livy-conf", "Properties": { "livy.impersonation.enabled": "true" } }, { "Classification": "core-site", "Properties": { "hadoop.proxyuser.livy.groups": "*", "hadoop.proxyuser.livy.hosts": "*" } } ] ``` ## Fase 2: aggiungere gli utenti Aggiungi JupyterHub utenti utilizzando PAM o LDAP. Per ulteriori informazioni, consultare [Utilizzo dell'autenticazione PAM](emr-jupyterhub-pam-users.md) e [Utilizzo dell'autenticazione LDAP](emr-jupyterhub-ldap-users.md). ## Fase 3: crea le directory home HDFS per gli utenti Ti sei connesso al nodo master per creare gli utenti. Mentre sei ancora connesso al nodo master, copia i contenuti di seguito e salvali in un file di script. Lo script crea le home directory HDFS per ogni JupyterHub utente sul nodo master. Lo script presuppone che si stia utilizzando l'ID utente amministratore predefinito,. *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 ```