Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Agregar usuarios y administradores de Cuadernos de Jupyter Puede utilizar uno de los dos métodos para que los usuarios se autentiquen, de JupyterHub modo que puedan crear libretas y, de forma opcional, administrarlas. JupyterHub El método más sencillo es utilizar el módulo JupyterHub de autenticación conectable (PAM). Además, JupyterHub en Amazon EMR es compatible con el [complemento de autenticación LDAP JupyterHub para](https://github.com/jupyterhub/ldapauthenticator/) obtener las identidades de los usuarios de un servidor LDAP, como un servidor Microsoft Active Directory. En esta sección se proporcionan instrucciones y ejemplos para añadir usuarios con cada método de autenticación. JupyterHub en Amazon EMR tiene un usuario predeterminado con permisos de administrador. El nombre de usuario es `jovyan` y la contraseña es `jupyter`. Le recomendamos que reemplace el usuario por otro que tenga permisos administrativos. Para ello, puede utilizar un paso cuando cree el clúster o conectarse al nodo principal cuando se ejecute el clúster. **Topics** + [Uso de la autenticación PAM](emr-jupyterhub-pam-users.md) + [Uso de la autenticación LDAP](emr-jupyterhub-ldap-users.md) + [Suplantación de usuarios](emr-jupyterhub-user-impersonation.md) # Uso de la autenticación PAM La creación de usuarios de PAM JupyterHub en Amazon EMR es un proceso de dos pasos. El primer paso es añadir usuarios al sistema operativo que se está ejecutando en el contenedor `jupyterhub` del nodo principal y añadir un directorio de inicio correspondiente a cada usuario. El segundo paso consiste en añadir a estos usuarios del sistema operativo como JupyterHub usuarios, un proceso que se conoce como inclusión en una lista blanca. JupyterHub Una vez agregado un JupyterHub usuario, este puede conectarse a la JupyterHub URL y proporcionar las credenciales de acceso de su sistema operativo. Cuando un usuario inicia sesión, JupyterHub abre la instancia del servidor portátil de ese usuario, que se guarda en el directorio principal del usuario en el nodo principal, que es`/var/lib/jupyter/home/username`. Si no existe una instancia de servidor de notebook, JupyterHub genera una instancia de notebook en el directorio principal del usuario. En las siguientes secciones se muestra cómo añadir usuarios de forma individual al sistema operativo y a él JupyterHub, seguido de un rudimentario script bash que añade varios usuarios. ## Agregar un usuario de sistema operativo al contenedor El siguiente ejemplo primero usa el comando [useradd](https://linux.die.net/man/8/useradd) en el contenedor para añadir un solo usuario, diego, y crear un directorio de inicio para ese usuario. El segundo comando utiliza [chpasswd](https://linux.die.net/man/8/chpasswd) para establecer la contraseña diego para este usuario. Los comandos se ejecutan en la línea de comandos del nodo principal mientras están conectados mediante SSH. También puede ejecutar estos comandos usando un paso tal como se ha descrito anteriormente en [Administración mediante el envío de pasos](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" ``` ## Añadir un usuario JupyterHub Puede usar el panel de **administración** JupyterHub o la API REST para agregar usuarios y administradores, o solo usuarios. **Para añadir usuarios y administradores mediante el panel de administración de JupyterHub** 1. Conéctese al nodo principal mediante SSH e inicie sesión en https: //:9443 *MasterNodeDNS* con una identidad que tenga permisos de administrador. 1. Elija **Control Panel (Panel de control)**, **Admin (Administración)**. 1. Elija **User (Usuario)**, **Add Users (Añadir usuarios)** o elija **Admin (Administrador)**, **Add Admins** (Añadir administradores). **Para añadir un usuario con la API de REST** 1. Conéctese al nodo principal con SSH y utilice el siguiente comando en él o ejecute el comando como un paso. 1. Adquiera un token administrativo para realizar solicitudes a la API y sustitúyalo por ese token *AdminToken* en el siguiente paso. 1. Usa el siguiente comando y *UserName* sustitúyelo por un usuario del sistema operativo que se haya creado en el contenedor. ``` curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName ``` **nota** Al iniciar sesión en la interfaz JupyterHub web por primera vez, se le añade automáticamente como usuario JupyterHub no administrador. ## Ejemplo: script bash para agregar varios usuarios El siguiente ejemplo de script bash combina los pasos anteriores de esta sección para crear varios JupyterHub usuarios. El script puede ejecutarse directamente en el nodo maestro o puede cargarse en Amazon S3 y, a continuación, ejecutarse como un paso. El script establece primero una matriz de nombres de usuario y utiliza el comando `jupyterhub token` para crear un token de API para el administrador predeterminado, jovyan. A continuación, crea un usuario de sistema operativo en el contenedor `jupyterhub` para cada usuario, asignando a cada uno una contraseña inicial igual que su nombre de usuario. Por último, llama a la operación de la API REST para crear cada usuario. JupyterHub Pasa el token generado anteriormente en el script y canaliza la respuesta REST a `jq` para facilitar su visualización. ``` # 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 ``` Guarde el script en una ubicación en Amazon S3, como `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. A continuación, puede utilizar `script-runner.jar` para ejecutarlo como un paso. ### Ejemplo: ejecución del script al crear un clúster (AWS CLI) **nota** Se incluyen caracteres de continuación de línea de Linux (\$1) para facilitar la lectura. Se pueden eliminar o utilizar en los comandos de Linux. En Windows, elimínelos o sustitúyalos por un signo de intercalación (^). ``` 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"] ``` ### Ejecución del script en un clúster existente (AWS CLI) **nota** Se incluyen caracteres de continuación de línea de Linux (\$1) para facilitar la lectura. Se pueden eliminar o utilizar en los comandos de Linux. En Windows, elimínelos o sustitúyalos por un signo de intercalación (^). ``` 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"] ``` # Uso de la autenticación LDAP El protocolo ligero de acceso a directorios (LDAP) es un protocolo de aplicación para consultar y modificar objetos que corresponden a recursos como usuarios y equipos almacenados en un proveedor de servicios de directorio compatible con LDAP, como Active Directory o un servidor OpenLDAP. Puede usar el [complemento de autenticación LDAP para JupyterHub Amazon EMR para JupyterHub](https://github.com/jupyterhub/ldapauthenticator/) usar LDAP para la autenticación de usuarios. El complemento controla las sesiones de inicio de sesión para usuarios LDAP y proporciona información de usuario a Jupyter. Esto permite a los usuarios conectarse a sus libretas JupyterHub y cuadernos utilizando las credenciales de sus identidades almacenadas en un servidor compatible con LDAP. Los pasos de esta sección explican los siguientes pasos para configurar y habilitar LDAP mediante el complemento LDAP Authenticator para. JupyterHub Los pasos se realizan mientras está conectado a la línea de comandos del nodo principal. Para obtener más información, consulte [Conexión al nodo maestro y a los servidores de blocs de notas](emr-jupyterhub-connect.md). 1. Cree un archivo de configuración LDAP con información sobre el servidor LDAP, como la dirección IP del host, el puerto, los nombres de enlace, etc. 1. Modifique `/etc/jupyter/conf/jupyterhub_config.py` para habilitar el complemento de autenticación LDAP para JupyterHub. 1. Cree y ejecute un script que configure LDAP en el contenedor `jupyterhub`. 1. Consulte el LDAP para los usuarios y, a continuación, cree los directorios principales dentro del contenedor para cada usuario. JupyterHub requiere que los directorios principales alojen los blocs de notas. 1. Ejecute un script que se reinicie JupyterHub **importante** Antes de configurar LDAP, pruebe la infraestructura de red para asegurarse de que el servidor LDAP y el nodo principal del clúster puedan comunicarse según sea necesario. TLS suele utilizar el puerto 389 a través de una conexión TCP sencilla. Si su conexión LDAP utiliza SSL, el puerto TCP conocido para SSL es 636. ## Crear del archivo de configuración de LDAP En el siguiente ejemplo se utilizan los siguientes valores de configuración de marcador de posición. Reemplácelos por parámetros que coincidan con su implementación. + El servidor LDAP ejecuta la versión 3 y está disponible en el puerto 389. Es el puerto no SSL estándar para LDAP. + El nombre distinguido (DN) base es `dc=example, dc=org`. Utilice un editor de texto para crear el archivo [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), con un contenido similar al siguiente. Utilice valores apropiados para su implementación de LDAP. *host*Sustitúyalo por la dirección IP o el nombre de host que se pueda resolver del servidor LDAP. ``` base dc=example,dc=org uri ldap://host ldap_version 3 binddn cn=admin,dc=example,dc=org bindpw admin ``` ## Habilite el complemento de autenticación LDAP para JupyterHub Utilice un editor de texto para modificar el archivo `/etc/jupyter/conf/jupyterhub_config.py` y añadir propiedades [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) similares a las siguientes. *host*Sustitúyalo por la dirección IP o el nombre de host resoluble del servidor LDAP. En el ejemplo se supone que los objetos de usuario se encuentran dentro de una unidad organizativa denominada *people* ou y se utilizan los componentes de nombres distintivos que se establecieron anteriormente. `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' ``` ## Configuración de LDAP en el contenedor Utilice un editor de texto para crear un script bash con los siguientes contenidos: ``` #!/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" ``` Guarde el script en el nodo principal y, a continuación, ejecútelo desde la línea de comandos del nodo principal. Por ejemplo, con el script guardado como `configure_ldap_client.sh` haga que el archivo sea ejecutable: ``` chmod +x configure_ldap_client.sh ``` Y ejecute el script: ``` ./configure_ldap_client.sh ``` ## Adición de atributos a Active Directory Para encontrar a cada usuario y crear la entrada adecuada en la base de datos, el contenedor JupyterHub docker requiere las siguientes propiedades de UNIX para el objeto de usuario correspondiente en Active Directory. Para obtener más información, consulte la sección *¿Cómo puedo seguir editando los atributos del GID/UID RFC 2307 ahora que el complemento Unix Attributes ya no está disponible para el complemento MMC Usuarios y equipos de Active Directory*? en el artículo, [aclaraciones sobre el estado de la administración de identidades para Unix (IDMU) y la función del servidor NIS en la versión preliminar técnica de Windows Server 2016 y](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) versiones posteriores. + `homeDirectory` Esta es la ubicación del directorio de inicio del usuario, que suele ser `/home/username`. + `gidNumber` Es un valor mayor que 60 000 que todavía no esté utilizando ningún otro usuario. Compruebe en el archivo `etc/passwd` cuáles son los gids en uso. + `uidNumber` Es un valor mayor que 60 000 que todavía no esté utilizando ningún otro grupo. Compruebe en el archivo `etc/group` cuáles son los uids en uso. + `uid` Esto es lo mismo que el. *username* ## Crear directorios de inicio de los usuarios JupyterHub necesita directorios principales dentro del contenedor para autenticar a los usuarios de LDAP y almacenar los datos de las instancias. El siguiente ejemplo muestra dos usuarios, *shirley* y *diego*, en el directorio LDAP. El primer paso consiste en consultar al servidor LDAP la información sobre el identificador de usuario y el identificador de grupo de cada usuario mediante [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html), como se muestra en el siguiente ejemplo, y sustituirlo por la dirección IP o el nombre de *host* host resoluble del servidor 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 ``` El comando `ldapsearch` devuelve una respuesta con formato LDIF que se parece a la siguiente para los usuarios *shirley* y *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 ``` Con la información de la respuesta, ejecute comandos en el contenedor para crear un directorio de inicio para cada nombre común de usuario (`cn`). Utilice `uidNumber` y `gidNumber` para fijar la propiedad del directorio de inicio de ese usuario. Los siguientes comandos de ejemplo hacen esto para el usuario. *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** El autenticador LDAP no JupyterHub admite la creación de usuarios locales. Para obtener más información, consulte [Nota de la configuración del autenticador LDAP sobre la creación de usuarios locales](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation). Para crear manualmente un usuario local, utilice el siguiente comando. ``` sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd" ``` ## Reinicie el contenedor JupyterHub Ejecute los siguientes comandos para reiniciar el contenedor de `jupyterhub`: ``` sudo docker stop jupyterhub sudo docker start jupyterhub ``` # Suplantación de usuarios Un trabajo de Spark que se ejecute dentro de un cuaderno de Jupyter recorre varias aplicaciones durante su ejecución en Amazon EMR. Por ejemplo, Sparkmagic recibe PySpark tres códigos que un usuario ejecuta en Jupyter, y utiliza una solicitud HTTP POST para enviarlos a Livy, que luego crea un trabajo de Spark para ejecutarlo en el clúster mediante YARN. De forma predeterminada, los trabajos de YARN enviados de esta manera se ejecutan como el usuario `livy`, con independencia de quién haya iniciado el trabajo. Al configurar la *suplantación de usuarios*, puede hacer que el ID de usuario del usuario del bloc de notas también sea el usuario asociado al trabajo de YARN. En lugar de que los trabajos iniciados por `shirley` y `diego` se asocien al usuario `livy`, los trabajos que inicia cada usuario se asocian a `shirley` y `diego`, respectivamente. Esto le ayuda a auditar el uso de Jupyter y a administrar las aplicaciones dentro de su organización. Esta configuración solo se admite cuando las llamadas de Sparkmagic a Livy no están autenticadas. Las aplicaciones que proporcionan una capa de autenticación o delegación entre las aplicaciones de Hadoop y Livy (como Apache Knox Gateway) no se admiten. En los pasos de esta sección para configurar la suplantación de identidad de un usuario, se parte del supuesto de que JupyterHub Livy y Livy se ejecutan en el mismo nodo maestro. Si la aplicación tiene clústeres distintos, [Paso 3: Crear directorios de inicio de HDFS para los usuarios](#Step3-UserImpersonation) debe modificarse de manera que los directorios HDFS se creen en el nodo principal de Livy. **Topics** + [Paso 1: Configurar Livy](#Step1-UserImpersonation) + [Paso 2: Añadir usuarios](#Step2-UserImpersonation) + [Paso 3: Crear directorios de inicio de HDFS para los usuarios](#Step3-UserImpersonation) ## Paso 1: Configurar Livy Puede utilizar las clasificaciones de configuración `livy-conf` y `core-site` al crear un clúster para habilitar la suplantación de usuarios de Livy tal y como se muestra en el siguiente ejemplo. Guarde la clasificación de configuración como JSON y haga referencia a ella cuando cree el clúster o especifique la clasificación de configuración directamente. Para obtener más información, consulte [Configuración de aplicaciones](emr-configure-apps.md). ``` [ { "Classification": "livy-conf", "Properties": { "livy.impersonation.enabled": "true" } }, { "Classification": "core-site", "Properties": { "hadoop.proxyuser.livy.groups": "*", "hadoop.proxyuser.livy.hosts": "*" } } ] ``` ## Paso 2: Añadir usuarios Agregue JupyterHub usuarios mediante PAM o LDAP. Para obtener más información, consulte [Uso de la autenticación PAM](emr-jupyterhub-pam-users.md) y [Uso de la autenticación LDAP](emr-jupyterhub-ldap-users.md). ## Paso 3: Crear directorios de inicio de HDFS para los usuarios Se ha conectado al nodo principal para crear usuarios. Mientras está conectado al nodo principal, copie el contenido que se indica a continuación y guárdelo en un archivo de script. El script crea directorios principales de HDFS para cada JupyterHub usuario del nodo principal. El script asume que está utilizando el ID de usuario administrador predeterminado,*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 ```