As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Adicionar usuários e administradores do Caderno Jupyter Você pode usar um dos dois métodos para os usuários se autenticarem para que JupyterHub possam criar cadernos e, opcionalmente, administrar. JupyterHub O método mais fácil é usar o módulo JupyterHub de autenticação conectável (PAM). Além disso, JupyterHub no Amazon EMR, o EMR oferece suporte ao [plug-in autenticador LDAP JupyterHub para](https://github.com/jupyterhub/ldapauthenticator/) obter identidades de usuário de um servidor LDAP, como um servidor Microsoft Active Directory. Instruções e exemplos para adicionar usuários com cada método de autenticação são fornecidos nesta seção. JupyterHub no Amazon EMR tem um usuário padrão com permissões de administrador. O nome de usuário é `jovyan` e a senha é `jupyter`. É altamente recomendável que você substitua o usuário por outro usuário que tenha permissões administrativas. Você pode fazer isso usando uma etapa ao criar o cluster ou se conectando ao nó principal quando o cluster estiver em execução. **Topics** + [ # Usar autenticação PAM ](emr-jupyterhub-pam-users.md) + [ # Usar autenticação LDAP ](emr-jupyterhub-ldap-users.md) + [ # Personificação do usuário ](emr-jupyterhub-user-impersonation.md) # Usar autenticação PAM A criação de usuários do PAM JupyterHub no Amazon EMR é um processo de duas etapas. A primeira etapa é adicionar usuários ao sistema operacional em execução no contêiner `jupyterhub` no nó principal e adicionar um diretório inicial do usuário correspondente para cada usuário. A segunda etapa é adicionar esses usuários do sistema operacional como JupyterHub usuários — um processo conhecido como lista branca em. JupyterHub Depois que um JupyterHub usuário é adicionado, ele pode se conectar ao JupyterHub URL e fornecer suas credenciais do sistema operacional para acesso. Quando um usuário faz login, JupyterHub abre a instância do servidor do notebook para esse usuário, que é salva no diretório inicial do usuário no nó principal, que é`/var/lib/jupyter/home/username`. Se uma instância do servidor do notebook não existir, JupyterHub gera uma instância do notebook no diretório inicial do usuário. As seções a seguir demonstram como adicionar usuários individualmente ao sistema operacional e ao sistema operacional JupyterHub, seguido por um script bash rudimentar que adiciona vários usuários. ## Adicionar um usuário do sistema operacional ao contêiner O exemplo a seguir usa primeiro o comando [useradd](https://linux.die.net/man/8/useradd) dentro do contêiner para adicionar um único usuário, diego e criar um diretório inicial para esse usuário. O segundo comando usa [chpasswd](https://linux.die.net/man/8/chpasswd) para estabelecer uma senha de diego para este usuário. Os comandos são executados na linha de comando do nó principal enquanto conectado usando SSH. Você também pode executar esses comandos usando uma etapa conforme descrito anteriormente em [Administração por envio de etapas](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" ``` ## Adicionando um JupyterHub usuário Você pode usar o painel do **administrador** JupyterHub ou a API REST para adicionar usuários e administradores, ou apenas usuários. **Para adicionar usuários e administradores usando o painel de administração no JupyterHub** 1. Conecte-se ao nó principal usando SSH e faça login em https: //:9443 *MasterNodeDNS* com uma identidade que tenha permissões de administrador. 1. Escolha **Control Panel (Painel de Controle)**, **Admin**. 1. Escolha **User (Usuário)**, **Add Users (Adicionar usuários)** ou escolha **Admin**, **Add Admins (Adicionar admins)**. **Para adicionar um usuário usando a API REST** 1. Conecte-se ao nó principal usando o SSH e use o seguinte comando no nó principal, ou execute o comando como uma etapa. 1. Adquira um token administrativo para fazer solicitações de API e substitua-o *AdminToken* na etapa seguinte por esse token. 1. Use o comando a seguir, *UserName* substituindo-o por um usuário do sistema operacional que tenha sido criado dentro do contêiner. ``` curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName ``` **nota** Você é automaticamente adicionado como usuário JupyterHub não administrador ao fazer login na interface da JupyterHub web pela primeira vez. ## Exemplo: script Bash para adicionar vários usuários O exemplo de script bash a seguir reúne as etapas anteriores desta seção para criar vários JupyterHub usuários. O script pode ser executado diretamente no nó principal, ou pode ser carregado no Amazon S3 e, em seguida, executado como uma etapa. O script primeiro estabelece uma matriz de nomes de usuário e usa o comando `jupyterhub token` para criar um token de API para o administrador padrão, jovyan. Em seguida, ele cria um usuário do sistema operacional no contêiner `jupyterhub` para cada usuário, atribuindo uma senha inicial a cada um que é igual ao seu nome de usuário. Por fim, ele chama a operação da API REST para criar cada usuário em JupyterHub. Ele transmite o token gerado anteriormente no script e envia a resposta REST para o `jq` para facilitar a visualização. ``` # 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 ``` Salve o script em um local do Amazon S3, como `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. Em seguida, você pode usar o `script-runner.jar` para executá-lo como uma etapa. ### Exemplo: executar o script ao criar um cluster (AWS CLI) **nota** Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados ​​em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^). ``` 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"] ``` ### Executar o script em um cluster existente (AWS CLI) **nota** Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados ​​em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^). ``` 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"] ``` # Usar autenticação LDAP O LDAP (Lightweight Directory Access Protocol) é um protocolo de aplicativo para consultar e modificar objetos que correspondem a recursos, como usuários e computadores, armazenados em um provedor de serviços de diretório compatível com LDAP, como o Active Directory ou um servidor OpenLDAP. Você pode usar o [plug-in autenticador LDAP for with JupyterHub on JupyterHub Amazon EMR para](https://github.com/jupyterhub/ldapauthenticator/) usar o LDAP para autenticação do usuário. O plug-in processa sessões de login para usuários LDAP e fornece as informações do usuário para o Jupyter. Isso permite que os usuários se conectem a notebooks JupyterHub e notebooks usando as credenciais de suas identidades armazenadas em um servidor compatível com LDAP. As etapas desta seção orientam você pelas etapas a seguir para configurar e habilitar o LDAP usando o plug-in autenticador LDAP para. JupyterHub Execute as etapas enquanto estiver conectado à linha de comando do nó principal. Para obter mais informações, consulte [Conectar-se ao nó principal e aos servidores de cadernos](emr-jupyterhub-connect.md). 1. Crie um arquivo de configuração LDAP com informações sobre o servidor LDAP, como o endereço IP do host, a porta, nomes de vinculação, e assim por diante. 1. Modifique o `/etc/jupyter/conf/jupyterhub_config.py` para habilitar o Plugin do Autenticador LDAP para o JupyterHub. 1. Crie e execute um script que configura o LDAP dentro do contêiner `jupyterhub`. 1. Consulte o LDAP para usuários e, em seguida, crie diretórios pessoais dentro do contêiner para cada usuário. JupyterHub requer diretórios pessoais para hospedar notebooks. 1. Execute um script que reinicia JupyterHub **Importante** Antes de configurar o LDAP, teste a infraestrutura de rede para garantir que o servidor LDAP e o nó principal do cluster possa se comunicar, conforme necessário. O TLS normalmente usa a porta 389 por meio de uma conexão TCP simples. Se a sua conexão LDAP usar SSL, a porta TCP conhecida para SSL será 636. ## Criar o arquivo de configuração do LDAP O exemplo abaixo usa os seguintes valores de configuração do espaço reservado. Substitua esses valores pelos parâmetros que corresponde à sua implementação. + O servidor LDAP está executando a versão 3 e está disponível na porta 389. Essa é a porta não SSL padrão para o LDAP. + O nome diferenciado base (DN) é `dc=example, dc=org`. Use um editor de texto para criar o arquivo [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), com conteúdo semelhante ao seguinte. Use os valores apropriados para a sua implementação do LDAP. *host*Substitua pelo endereço IP ou nome de host resolvível do seu servidor LDAP. ``` base dc=example,dc=org uri ldap://host ldap_version 3 binddn cn=admin,dc=example,dc=org bindpw admin ``` ## Ativar o plug-in de autenticação LDAP para JupyterHub Use um editor de texto para modificar o arquivo `/etc/jupyter/conf/jupyterhub_config.py` e adicionar as propriedades [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) semelhante ao seguinte. *host*Substitua pelo endereço IP ou nome de host resolvível do servidor LDAP. O exemplo pressupõe que os objetos do usuário estão dentro de uma unidade organizacional (ou) chamada *people* e usa os componentes de nome distinto que você estabeleceu anteriormente usando`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' ``` ## Configurar o LDAP dentro do contêiner Use um editor de texto para criar um script bash com o seguinte conteúdo: ``` #!/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" ``` Salve o script no nó principal e, em seguida, execute-o na linha de comando do nó principal. Por exemplo, com o script salvo como `configure_ldap_client.sh`, torne o arquivo executável: ``` chmod +x configure_ldap_client.sh ``` E execute o script: ``` ./configure_ldap_client.sh ``` ## Adicionar atributos ao Active Directory Para encontrar cada usuário e criar a entrada apropriada no banco de dados, o contêiner JupyterHub docker requer as seguintes propriedades UNIX para o objeto de usuário correspondente no Active Directory. Para obter mais informações, consulte a seção *Como continuo editando os atributos do GID/UID RFC 2307 agora que o Plug-in de Atributos Unix não está mais disponível para o snap-in MMC de Usuários e Computadores do Active Directory*? no artigo [Esclarecimento sobre o status do gerenciamento de identidade para Unix (IDMU) e a função de servidor NIS na versão prévia técnica do Windows Server 2016 e](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) versões posteriores. + `homeDirectory` Este é o local para o diretório inicial do usuário, que é geralmente `/home/username`. + `gidNumber` Um valor maior que 60000 que ainda não esteja sendo usado por outro usuário. Verifique o arquivo `etc/passwd` para ver os GIDs que estão sendo usados. + `uidNumber` Um valor maior que 60000 que ainda não esteja sendo usado por outro grupo. Verifique o arquivo `etc/group` para ver os UDIs que estão sendo usados. + `uid` Isso é o mesmo que *username* o. ## Criar diretórios iniciais do usuário JupyterHub precisa de diretórios iniciais dentro do contêiner para autenticar usuários LDAP e armazenar dados da instância. O exemplo a seguir demonstra dois usuários, *shirley* e *diego*, no diretório LDAP. A primeira etapa é consultar o servidor LDAP para obter as informações de ID de usuário e ID de grupo de cada usuário usando [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html), conforme mostrado no exemplo a seguir, *host* substituindo pelo endereço IP ou nome de host resolvível do seu 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 ``` O comando `ldapsearch` retorna uma resposta formatada LDIF que se parece com a seguinte para os usuários *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 ``` Ao usar as informações da resposta, execute comandos dentro do contêiner para criar um diretório inicial para cada nome comum de usuário (`cn`). Use o `uidNumber` e o `gidNumber` para corrigir a propriedade do diretório inicial desse usuário. Os comandos de exemplo a seguir fazem isso para o usuário*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** O autenticador LDAP para JupyterHub não oferece suporte à criação de usuários locais. Para obter mais informações, consulte [Observação da configuração do autenticador do LDAP sobre criação de usuário local](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation). Para criar um usuário local manualmente, use o comando a seguir. ``` sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd" ``` ## Reinicie o JupyterHub contêiner Para reiniciar o contêiner `jupyterhub`, execute os seguintes comandos: ``` sudo docker stop jupyterhub sudo docker start jupyterhub ``` # Personificação do usuário Um trabalho do Spark em execução em um caderno Jupyter percorre várias aplicações durante sua execução no Amazon EMR. Por exemplo, PySpark 3 códigos que um usuário executa dentro do Jupyter são recebidos pelo Sparkmagic, que usa uma solicitação HTTP POST para enviá-los ao Livy, que então cria um trabalho do Spark para executar no cluster usando o YARN. Por padrão, os trabalhos do YARN que são enviados dessa forma são executados como usuário `livy`, independentemente do usuário que iniciou o trabalho. Ao configurar a *personificação do usuário*, você pode fazer com que o ID de usuário do notebook também seja o usuário associado ao trabalho do YARN. Em vez dos trabalhos serem iniciados por `shirley` e `diego` associados ao usuário `livy`, os trabalhos que cada usuário inicia são associados a `shirley` e `diego` respectivamente. Isso ajuda você a auditar o uso do Jupyter e gerenciar os aplicativos em sua organização. Essa configuração tem suporte somente quando as chamadas do Sparkmagic para o Livy são não autenticadas. Os aplicativos que fornecem uma camada de proxy ou de autenticação entre os aplicativos Hadoop e Livy (como o Apache Knox Gateway) não são compatíveis. As etapas para configurar a representação do usuário nesta seção pressupõem que JupyterHub e Livy estejam sendo executados no mesmo nó principal. Se o seu aplicativo tiver clusters separados, [Etapa 3: criar diretórios iniciais do HDFS para usuários](#Step3-UserImpersonation) precisará ser modificado para que os diretórios do HDFS sejam criados no nó principal do Livy. **Topics** + [ ## Etapa 1: configurar o Livy ](#Step1-UserImpersonation) + [ ## Etapa 2: adicionar usuários ](#Step2-UserImpersonation) + [ ## Etapa 3: criar diretórios iniciais do HDFS para usuários ](#Step3-UserImpersonation) ## Etapa 1: configurar o Livy Use as classificações de configuração `livy-conf` e `core-site` ao criar um cluster para habilitar a personificação do usuário do Livy, conforme mostrado no exemplo a seguir. Salve a classificação de configuração como um JSON e, em seguida, faça referência a ele quando criar o cluster ou especifique a classificação de configuração em linha. Para obter mais informações, consulte [Configurar aplicações](emr-configure-apps.md). ``` [ { "Classification": "livy-conf", "Properties": { "livy.impersonation.enabled": "true" } }, { "Classification": "core-site", "Properties": { "hadoop.proxyuser.livy.groups": "*", "hadoop.proxyuser.livy.hosts": "*" } } ] ``` ## Etapa 2: adicionar usuários Adicione JupyterHub usuários usando PAM ou LDAP. Para obter mais informações, consulte [Usar autenticação PAM](emr-jupyterhub-pam-users.md) e [Usar autenticação LDAP](emr-jupyterhub-ldap-users.md). ## Etapa 3: criar diretórios iniciais do HDFS para usuários Você se conectou ao nó principal para criar usuários. Ainda conectado a ele, copie o conteúdo abaixo e o salve em um arquivo de script. O script cria diretórios iniciais do HDFS para cada JupyterHub usuário no nó principal. O script pressupõe que você esteja usando o ID de usuário administrador padrão,*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 ```