Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Menambahkan pengguna dan administrator Jupyter Notebook Anda dapat menggunakan salah satu dari dua metode bagi pengguna untuk mengautentikasi JupyterHub sehingga mereka dapat membuat buku catatan dan, secara opsional, mengelola. JupyterHub Metode termudah adalah dengan menggunakan modul otentikasi JupyterHub pluggable (PAM). Selain itu, JupyterHub di Amazon EMR mendukung [plugin otentikator LDAP JupyterHub untuk](https://github.com/jupyterhub/ldapauthenticator/) mendapatkan identitas pengguna dari server LDAP, seperti server Microsoft Active Directory. Petunjuk dan contoh untuk menambahkan pengguna dengan setiap metode autentikasi disediakan di bagian ini. JupyterHub di Amazon EMR memiliki pengguna default dengan izin administrator. Nama pengguna adalah `jovyan` dan kata sandi `jupyter`. Kami sangat menyarankan Anda mengganti pengguna dengan pengguna lain yang memiliki izin administratif. Anda dapat melakukan ini menggunakan langkah ketika Anda membuat klaster, atau dengan menghubungkan ke simpul utama ketika klaster berjalan. **Topics** + [Menggunakan autentikasi PAM](emr-jupyterhub-pam-users.md) + [Menggunakan autentikasi LDAP](emr-jupyterhub-ldap-users.md) + [Peniruan pengguna](emr-jupyterhub-user-impersonation.md) # Menggunakan autentikasi PAM Membuat pengguna PAM JupyterHub di Amazon EMR adalah proses dua langkah. Langkah pertama adalah menambahkan pengguna ke sistem operasi yang berjalan di `jupyterhub` kontainer pada simpul utama, dan menambahkan direktori home pengguna yang sesuai untuk setiap pengguna. Langkah kedua adalah menambahkan pengguna sistem operasi ini sebagai JupyterHub pengguna — proses yang dikenal sebagai daftar putih. JupyterHub Setelah JupyterHub pengguna ditambahkan, mereka dapat terhubung ke JupyterHub URL dan memberikan kredensyal sistem operasi mereka untuk akses. Ketika pengguna log in, JupyterHub membuka instance server notebook untuk pengguna tersebut, yang disimpan di direktori home pengguna pada node master, yaitu`/var/lib/jupyter/home/username`. Jika instance server notebook tidak ada, JupyterHub memunculkan instance notebook di direktori home pengguna. Bagian berikut menunjukkan cara menambahkan pengguna secara individual ke sistem operasi dan ke JupyterHub, diikuti oleh skrip bash dasar yang menambahkan beberapa pengguna. ## Menambahkan pengguna sistem operasi ke kontainer Contoh berikut pertama-tama menggunakan perintah [useradd](https://linux.die.net/man/8/useradd) dalam kontainer untuk menambahkan satu pengguna, diego, dan membuat direktori home untuk pengguna tersebut. Perintah kedua menggunakan [chpasswd](https://linux.die.net/man/8/chpasswd) untuk membuat kata sandi diego untuk pengguna ini. Perintah dijalankan pada baris perintah simpul utama saat terhubung menggunakan SSH. Anda juga dapat menjalankan perintah ini menggunakan langkah seperti yang dijelaskan sebelumnya di [Administrasi dengan mengirimkan langkah-langkah](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" ``` ## Menambahkan JupyterHub pengguna Anda dapat menggunakan panel **Admin** di JupyterHub atau REST API untuk menambahkan pengguna dan administrator, atau hanya pengguna. **Untuk menambahkan pengguna dan administrator menggunakan panel admin di JupyterHub** 1. Connect ke master node menggunakan SSH dan masuk ke https: //:9443 *MasterNodeDNS* dengan identitas yang memiliki izin administrator. 1. Pilih **Panel Kontrol**, **Admin**. 1. Pilih **Pengguna**, **Tambahkan Pengguna**, atau pilih **Admin**, **Tambahkan admin**. **Untuk menambahkan pengguna menggunakan REST API** 1. Connect ke simpul utama menggunakan SSH dan gunakan perintah berikut pada simpul utama, atau jalankan perintah sebagai langkah. 1. Dapatkan token administratif untuk membuat permintaan API, dan ganti *AdminToken* pada langkah berikut dengan token itu. 1. Gunakan perintah berikut, ganti *UserName* dengan pengguna sistem operasi yang telah dibuat di dalam wadah. ``` curl -XPOST -H "Authorization: token AdminToken" "https://$(hostname):9443/hub/api/users/UserName ``` **catatan** Anda secara otomatis ditambahkan sebagai pengguna JupyterHub non-admin ketika Anda masuk ke antarmuka JupyterHub web untuk pertama kalinya. ## Contoh: Skrip Bash untuk menambahkan beberapa pengguna Contoh skrip bash berikut mengikat langkah-langkah sebelumnya di bagian ini untuk membuat banyak JupyterHub pengguna. Skrip dapat dijalankan langsung pada simpul utama, atau dapat diunggah ke Amazon S3 dan kemudian dijalankan sebagai langkah. Skrip pertama menetapkan array nama pengguna, dan menggunakan `jupyterhub token` perintah untuk membuat token API untuk administrator default, jovyan. Ini kemudian menciptakan pengguna sistem operasi di `jupyterhub` kontainer untuk setiap pengguna, menetapkan kata sandi awal untuk masing-masing yang sama dengan nama pengguna mereka. Akhirnya, ia memanggil operasi REST API untuk membuat setiap pengguna masuk JupyterHub. Melewati token yang dihasilkan sebelumnya dalam skrip dan menyalurkan respon REST `jq` agar lebih mudah dilihat. ``` # 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 ``` Simpan skrip ke lokasi di Amazon S3 seperti `s3://amzn-s3-demo-bucket/createjupyterusers.sh`. Kemudian Anda dapat menggunakan `script-runner.jar` untuk menjalankannya sebagai langkah. ### Contoh: Menjalankan skrip saat membuat sebuah klaster (AWS CLI) **catatan** Karakter lanjutan baris Linux (\$1) disertakan agar mudah dibaca Karakter ini bisa dihapus atau digunakan dalam perintah Linux. Untuk Windows, hapus atau ganti dengan tanda sisipan (^). ``` 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"] ``` ### Menjalankan skrip pada klaster yang ada (AWS CLI) **catatan** Karakter lanjutan baris Linux (\$1) disertakan agar mudah dibaca Karakter ini bisa dihapus atau digunakan dalam perintah Linux. Untuk Windows, hapus atau ganti dengan tanda sisipan (^). ``` 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"] ``` # Menggunakan autentikasi LDAP Lightweight Directory Access Protocol (LDAP) adalah sebuah protokol aplikasi untuk mengkueri dan memodifikasi objek yang sesuai dengan sumber daya seperti pengguna dan komputer yang disimpan dalam penyedia layanan direktori LDAP-kompatibel seperti Direktori Aktif atau OpenLDAP server. Anda dapat menggunakan [plugin otentikator LDAP untuk JupyterHub dengan di JupyterHub Amazon EMR untuk](https://github.com/jupyterhub/ldapauthenticator/) menggunakan LDAP untuk otentikasi pengguna. Plugin menangani sesi login untuk pengguna LDAP dan memberikan informasi pengguna untuk Jupyter. Ini memungkinkan pengguna terhubung ke JupyterHub dan notebook dengan menggunakan kredensyal untuk identitas mereka yang disimpan di server yang kompatibel dengan LDAP. Langkah-langkah di bagian ini memandu Anda melalui langkah-langkah berikut untuk mengatur dan mengaktifkan LDAP menggunakan Plugin Authenticator LDAP untuk. JupyterHub Anda melakukan langkah-langkah tersebut namun tetap terhubung ke baris perintah simpul utama. Untuk informasi selengkapnya, lihat [Menyambung ke simpul utama dan server Notebook](emr-jupyterhub-connect.md). 1. Buat file konfigurasi LDAP dengan informasi tentang LDAP server, seperti alamat IP host, port, mengikat nama, dan sebagainya. 1. Ubah `/etc/jupyter/conf/jupyterhub_config.py` untuk mengaktifkan Plugin Authenticator LDAP untuk. JupyterHub 1. Buat dan jalankan skrip yang mengonfigurasi LDAP dalam `jupyterhub` kontainer. 1. Kueri LDAP untuk pengguna, lalu buat direktori home di dalam wadah untuk setiap pengguna. JupyterHub membutuhkan direktori rumah untuk meng-host notebook. 1. Jalankan skrip yang dimulai ulang JupyterHub **penting** Sebelum Anda mengatur LDAP, periksa infrastruktur jaringan Anda untuk memastikan bahwa LDAP server dan simpul utama klaster dapat berkomunikasi seperti yang diperlukan. TLS biasanya menggunakan port 389 melalui sambungan TCP biasa. Jika sambungan LDAP Anda menggunakan SSL, port TCP terkenal untuk SSL adalah 636. ## Buat file konfigurasi Contoh di bawah ini menggunakan nilai konfigurasi tempat-pemegang berikut. Ganti ini dengan parameter yang sesuai dengan implementasi Anda. + LDAP server menjalankan versi 3 dan tersedia untuk port 389. Ini adalah port non-SSL standar untuk LDAP. + Nama khusus dasar (DN) adalah `dc=example, dc=org`. Gunakan editor teks untuk membuat file [ldap.conf](http://manpages.ubuntu.com/manpages/bionic/man5/ldap.conf.5.html), dengan konten yang serupa dengan berikut ini. Gunakan nilai-nilai yang sesuai untuk pelaksanaan LDAP Anda. Ganti *host* dengan alamat IP atau nama host yang dapat diselesaikan dari server LDAP Anda. ``` base dc=example,dc=org uri ldap://host ldap_version 3 binddn cn=admin,dc=example,dc=org bindpw admin ``` ## Aktifkan Plugin Authenticator LDAP untuk JupyterHub Gunakan editor teks untuk mengubah `/etc/jupyter/conf/jupyterhub_config.py` file dan menambahkan properti [ldapauthenticator](https://github.com/jupyterhub/ldapauthenticator) yang serupa dengan berikut ini. Ganti *host* dengan alamat IP atau nama host yang dapat diselesaikan dari server LDAP. Contoh mengasumsikan bahwa objek pengguna berada dalam unit organisasi (ou) bernama*people*, dan menggunakan komponen nama dibedakan yang Anda buat sebelumnya menggunakan`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' ``` ## Konfigurasikan LDAP dalam kontainer Gunakan editor teks untuk membuat skrip bash dengan konten sebagai berikut: ``` #!/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" ``` Simpan skrip ke simpul utama, dan kemudian jalankan dari baris perintah simpul utama. Sebagai contoh, dengan skrip yang disimpan sebagai `configure_ldap_client.sh`, buat file agar dapat dijalankan: ``` chmod +x configure_ldap_client.sh ``` Dan jalankan skrip: ``` ./configure_ldap_client.sh ``` ## Tambahkan atribut ke Direktori Aktif Untuk menemukan setiap pengguna dan membuat entri yang sesuai dalam database, wadah JupyterHub docker memerlukan properti UNIX berikut untuk objek pengguna yang sesuai di Active Directory. Untuk informasi lebih lanjut, lihat bagian *Bagaimana cara terus mengedit atribut GID/UID RFC 2307 sekarang karena Plug-in Atribut Unix tidak lagi tersedia untuk snap-in Pengguna Direktori Aktif dan Komputer* MMC? dalam artikel [Klarifikasi mengenai status manajemen identitas untuk peran server Unix (IDMU) dan NIS dalam pratinjau teknis Windows Server 2016](https://blogs.technet.microsoft.com/activedirectoryua/2016/02/09/identity-management-for-unix-idmu-is-deprecated-in-windows-server/) dan seterusnya. + `homeDirectory` Ini adalah lokasi ke direktori home pengguna, yang biasanya `/home/username`. + `gidNumber` Ini adalah nilai yang lebih besar dari 60000 yang sudah tidak digunakan oleh pengguna lain. Periksa `etc/passwd` file untuk gids yang digunakan. + `uidNumber` Ini adalah nilai yang lebih besar dari 60000 yang sudah tidak digunakan oleh grup lain. Periksa `etc/group` file untuk uids yang sedang digunakan. + `uid` Ini sama dengan*username*. ## Buat direktori home pengguna JupyterHub membutuhkan direktori home di dalam wadah untuk mengautentikasi pengguna LDAP dan menyimpan data instance. Contoh berikut menunjukkan dua pengguna, *shirley* dan *diego*, dalam direktori LDAP. Langkah pertama adalah menanyakan server LDAP untuk setiap id pengguna dan informasi id grup menggunakan [ldapsearch](http://manpages.ubuntu.com/manpages/xenial/man1/ldapsearch.1.html) seperti yang ditunjukkan pada contoh berikut, mengganti *host* dengan alamat IP atau nama host yang dapat diselesaikan dari server LDAP Anda: ``` 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 ``` Perintah `ldapsearch` mengembalikan respon LDIF diformat yang terlihat mirip dengan berikut ini untuk pengguna *shirley* dan *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 ``` Menggunakan informasi dari respon, jalankan perintah dalam kontainer untuk membuat direktori home untuk setiap nama umum pengguna (`cn`). Gunakan `uidNumber` dan `gidNumber` untuk memperbaiki kepemilikan direktori home untuk pengguna tersebut. Contoh perintah berikut melakukan ini untuk pengguna*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" ``` **catatan** Authenticator LDAP untuk JupyterHub tidak mendukung pembuatan pengguna lokal. Untuk informasi lebih lanjut, lihat [Catatan konfigurasi autentikator LDAP pada pembuatan pengguna lokal](https://github.com/jupyterhub/ldapauthenticator#configuration-note-on-local-user-creation). Untuk membuat pengguna lokal secara manual, gunakan perintah berikut. ``` sudo docker exec jupyterhub bash -c "echo 'shirley:x:$uidNumber:$gidNumber::/home/shirley:/bin/bash' >> /etc/passwd" ``` ## Mulai ulang JupyterHub wadah Jalankan perintah berikut untuk memulai ulang `jupyterhub` kontainer: ``` sudo docker stop jupyterhub sudo docker start jupyterhub ``` # Peniruan pengguna Sebuah tugas Spark berjalan di dalam notebook Jupyter melintasi beberapa aplikasi selama pelaksanaannya di Amazon EMR. Misalnya, PySpark 3 kode yang dijalankan pengguna di dalam Jupyter diterima oleh Sparkmagic, yang menggunakan permintaan HTTP POST untuk mengirimkannya ke Livy, yang kemudian membuat pekerjaan Spark untuk dieksekusi di cluster menggunakan YARN. Secara default, tugas YARN yang dikirimkan dengan cara ini dijalankan sebagai pengguna `livy`, terlepas dari pengguna yang memulai pekerjaan. Dengan menyiapkan *Peniruan pengguna* Anda dapat memiliki ID pengguna dari pengguna notebook yang juga menjadi pengguna yang terkait dengan tugas YARN. Daripada memiliki tugas yang dimulai oleh `shirley` dan `diego` terkait dengan pengguna `livy`, tugas yang dimulai setiap pengguna terkait dengan `shirley` dan `diego` masing-masing. Hal ini membantu Anda untuk melakukan audit penggunaan Jupyter dan mengelola aplikasi dalam organisasi Anda. Konfigurasi ini hanya didukung bila panggilan dari Sparkmagic ke Livy tidak diautentikasi. Aplikasi yang menyediakan autentikasi atau proksi lapisan antara aplikasi Hadoop dan Livy (seperti Apache Knox Gateway) tidak didukung. Langkah-langkah untuk mengonfigurasi peniruan identitas pengguna di bagian ini mengasumsikan bahwa JupyterHub dan Livy berjalan pada node master yang sama. Jika aplikasi Anda memiliki klaster terpisah, [Langkah 3: Buat direktori home HDFS untuk pengguna](#Step3-UserImpersonation) perlu dimodifikasi agar direktori HDFS bisa dibuat pada simpul utama Livy. **Topics** + [Langkah 1: Konfigurasikan Livy](#Step1-UserImpersonation) + [Langkah 2: Tambahkan pengguna](#Step2-UserImpersonation) + [Langkah 3: Buat direktori home HDFS untuk pengguna](#Step3-UserImpersonation) ## Langkah 1: Konfigurasikan Livy Anda menggunakan klasifikasi konfigurasi `livy-conf` dan `core-site` ketika membuat klaster untuk mengaktifkan peniruan pengguna Livy seperti yang ditunjukkan dalam contoh berikut. Simpan klasifikasi konfigurasi sebagai JSON dan kemudian referensikan ketika Anda membuat klaster, atau tentukan klasifikasi konfigurasi inline. Untuk informasi selengkapnya, lihat [Konfigurasikan aplikasi](emr-configure-apps.md). ``` [ { "Classification": "livy-conf", "Properties": { "livy.impersonation.enabled": "true" } }, { "Classification": "core-site", "Properties": { "hadoop.proxyuser.livy.groups": "*", "hadoop.proxyuser.livy.hosts": "*" } } ] ``` ## Langkah 2: Tambahkan pengguna Tambahkan JupyterHub pengguna menggunakan PAM atau LDAP. Untuk informasi selengkapnya, lihat [Menggunakan autentikasi PAM](emr-jupyterhub-pam-users.md) dan [Menggunakan autentikasi LDAP](emr-jupyterhub-ldap-users.md). ## Langkah 3: Buat direktori home HDFS untuk pengguna Anda terhubung ke simpul utama untuk membuat pengguna. Sementara masih terhubung ke simpul utama, salin isi di bawah ini dan simpan ke file skrip. Skrip membuat direktori rumah HDFS untuk setiap JupyterHub pengguna pada node master. Skrip mengasumsikan Anda menggunakan ID pengguna administrator default,*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 ```