Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memahami peran dan izin PostgreSQL
Bila Anda membuat Aurora PostgreSQL DB cluster DB menggunakan, akun administrator dibuat pada saat yang sama. Konsol Manajemen AWS Secara default, akun tersebut akan dinamakan `postgres`, seperti yang ditunjukkan pada gambar berikut:
![\[Identitas login default untuk Kredensial di halaman Buat basis data adalah postgres.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/default-login-identity-apg-rpg.png)
Anda dapat memilih nama lain daripada menerima nama default (`postgres`). Jika ya, nama yang Anda pilih harus dimulai dengan huruf dan terdiri atas 1 hingga 16 karakter alfanumerik. Untuk menyederhanakan, kami merujuk ke akun pengguna utama ini dengan nilai default-nya (`postgres`) di seluruh panduan ini.
Jika Anda menggunakan `create-db-cluster` AWS CLI bukan Konsol Manajemen AWS, Anda membuat nama pengguna dengan meneruskannya dengan `master-username` parameter. Untuk informasi selengkapnya, lihat [Langkah 2: Membuat klaster DB Aurora PostgreSQL](CHAP_GettingStartedAurora.AuroraPostgreSQL.FullConfig.md#CHAP_GettingStarted.AuroraPostgreSQL.CreateDBCluster).
Baik Anda menggunakan Konsol Manajemen AWS, API AWS CLI, atau Amazon RDS, dan apakah Anda menggunakan `postgres` nama default atau memilih nama yang berbeda, akun pengguna database pertama ini adalah anggota `rds_superuser` grup dan memiliki `rds_superuser` hak istimewa.
**Topics**
+ [Memahami peran rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md)
+ [Mengontrol akses pengguna ke basis data PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md)
+ [Menyerahkan dan mengendalikan manajemen kata sandi pengguna](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md)
+ [Menggunakan SCRAM untuk enkripsi kata sandi PostgreSQL](PostgreSQL_Password_Encryption_configuration.md)
# Memahami peran rds\$1superuser
Dalam PostgreSQL, *peran* dapat menentukan pengguna, grup, atau sekumpulan izin tertentu yang diberikan kepada grup atau pengguna untuk berbagai objek dalam basis data. Perintah PostgreSQL untuk `CREATE USER` dan `CREATE GROUP` telah digantikan oleh `CREATE ROLE` yang lebih umum dengan properti khusus untuk membedakan pengguna basis data. Pengguna basis data dapat dianggap sebagai peran dengan hak akses LOGIN.
**catatan**
Perintah `CREATE USER` dan `CREATE GROUP` masih dapat digunakan. Untuk informasi selengkapnya, lihat [Database Roles](https://www.postgresql.org/docs/current/user-manag.html) dalam dokumentasi PostgreSQL.
Pengguna `postgres` adalah pengguna basis data dengan hak akses tertinggi di klaster DB Aurora PostgreSQL . Pengguna tersebut memiliki karakteristik yang ditentukan oleh pernyataan `CREATE ROLE` berikut.
```
CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity'
```
Properti`NOSUPERUSER`, `NOREPLICATION`, `INHERIT`, dan `VALID UNTIL 'infinity'` merupakan opsi default untuk CREATE ROLE, kecuali ditentukan lain.
Secara default, `postgres` memiliki hak akses yang diberikan kepada peran `rds_superuser`, serta izin untuk membuat peran dan basis data. Peran `rds_superuser` mengizinkan pengguna `postgres` untuk melakukan tindakan berikut:
+ Menambahkan ekstensi yang tersedia untuk digunakan dengan Aurora PostgreSQL. Untuk informasi selengkapnya, lihat [Menangani ekstensi dan pembungkus data asing](Appendix.PostgreSQL.CommonDBATasks.md).
+ Buat peran dan berikan hak akses kepada pengguna. Untuk informasi selengkapnya, lihat [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) dan [GRANT](https://www.postgresql.org/docs/14/sql-grant.html) dalam dokumentasi PostgreSQL.
+ Membuat basis data. Untuk informasi selengkapnya, lihat [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) dalam dokumentasi PostgreSQL.
+ Berikan hak akses `rds_superuser` untuk peran pengguna yang tidak memiliki hak akses ini, dan cabut hak akses sesuai kebutuhan. Sebaiknya berikan peran ini hanya untuk pengguna yang menjalankan tugas superuser. Dengan kata lain, Anda dapat memberikan peran ini kepada administrator database (DBAs) atau administrator sistem.
+ Berikan (dan cabut) peran `rds_replication` kepada pengguna basis data yang tidak memiliki peran `rds_superuser`.
+ Berikan (dan cabut) peran `rds_password` kepada pengguna basis data yang tidak memiliki peran `rds_superuser`.
+ Dapatkan informasi status tentang semua koneksi basis data dengan menggunakan tampilan `pg_stat_activity`. Bila diperlukan, `rds_superuser` dapat menghentikan semua koneksi menggunakan `pg_terminate_backend` atau `pg_cancel_backend`.
Dalam pernyataan `CREATE ROLE postgres...`, Anda dapat melihat bahwa peran pengguna `postgres` secara khusus melarang izin `superuser` PostgreSQL. Aurora PostgreSQL adalah layanan terkelola, jadi Anda tidak dapat mengakses OS host, dan terhubung menggunakan akun `superuser` PostgreSQL. Banyak tugas yang memerlukan akses `superuser` pada PostgreSQL mandiri dikelola secara otomatis oleh Aurora.
Untuk informasi selengkapnya tentang pemberian hak akses, lihat [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) dalam dokumentasi PostgreSQL.
Peran `rds_superuser` adalah satu dari beberapa peran yang *telah ditentukan* dalam klaster DB Aurora PostgreSQL.
**catatan**
Dalam PostgreSQL 13 dan rilis sebelumnya, peran yang *telah ditentukan* dikenal sebagai peran *default*.
Dalam daftar berikut, Anda akan menemukan beberapa peran standar lainnya yang dibuat secara otomatis untuk klaster DB Aurora PostgreSQL yang baru. Peran yang telah ditentukan dan hak aksesnya tidak dapat diubah. Anda tidak dapat menghapus, mengganti nama, atau memodifikasi hak akses untuk peran yang telah ditentukan ini. Mencoba untuk melakukannya akan mengakibatkan kesalahan.
+ **rds\$1password** — Peran yang dapat mengubah kata sandi dan mengatur batasan kata sandi untuk pengguna basis data. `rds_superuser`Peran diberikan dengan peran ini secara default, dan dapat memberikan peran tersebut kepada pengguna database. Untuk informasi selengkapnya, lihat [Mengontrol akses pengguna ke basis data PostgreSQLMengontrol akses pengguna ke PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md).
+ Untuk RDS untuk PostgreSQL versi yang lebih tua dari 14`rds_password`, peran dapat mengubah kata sandi dan mengatur batasan kata sandi untuk pengguna database dan pengguna dengan peran. `rds_superuser` Dari RDS untuk PostgreSQL versi 14 dan yang lebih baru`rds_password`, peran dapat mengubah kata sandi dan mengatur batasan kata sandi hanya untuk pengguna database. Hanya pengguna dengan `rds_superuser` peran yang dapat melakukan tindakan ini pada pengguna lain yang memiliki `rds_superuser` peran.
+ **rdsadmin** — Peran yang dibuat untuk menangani banyak tugas manajemen yang dilakukan oleh administrator dengan hak akses `superuser` pada basis data PostgreSQL mandiri. Peran ini digunakan secara internal oleh Aurora PostgreSQL untuk banyak tugas manajemen.
# Melihat peran dan hak istimewa mereka
Anda dapat melihat peran yang telah ditentukan dan hak istimewanya di RDS untuk instans PostgreSQL DB menggunakan perintah yang berbeda tergantung pada versi PostgreSQL Anda. Untuk melihat semua peran yang telah ditentukan, Anda dapat terhubung ke RDS untuk instans PostgreSQL DB dan menjalankan perintah berikut menggunakan. `psql`
**Untuk `psql` 15 dan versi sebelumnya**
Connect ke RDS Anda untuk PostgreSQL DB instance dan gunakan perintah di psql: `\du`
```
postgres=> \du
List of roles
Role name | Attributes | Member of
-----------------+------------------------------------------------------------+------------------------------------------------------
postgres | Create role, Create DB +| {rds_superuser}
| Password valid until infinity |
rds_ad | Cannot login | {}
rds_iam | Cannot login | {}
rds_password | Cannot login | {}
rds_replication | Cannot login | {}
rds_superuser | Cannot login | {pg_monitor,pg_signal_backend,rds_password,rds_replication}
rdsadmin | Superuser, Create role, Create DB, Replication, Bypass RLS+| {}
| Password valid until infinity |
```
**Untuk `psql` 16 dan versi yang lebih baru**
```
postgres=> \drg+
List of role grants
Role name | Member of | Options | Grantor
---------------+-----------------------------+---------------------+----------
postgres | rds_superuser | INHERIT, SET | rdsadmin
rds_superuser | pg_checkpoint | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_monitor | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_signal_backend | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_use_reserved_connections | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_password | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_replication | ADMIN, INHERIT, SET | rdsadmin
```
Untuk memeriksa keanggotaan peran tanpa ketergantungan versi, Anda dapat menggunakan kueri SQL berikut:
```
SELECT m.rolname AS "Role name", r.rolname AS "Member of"
FROM pg_catalog.pg_roles m
JOIN pg_catalog.pg_auth_members pam ON (pam.member = m.oid)
LEFT JOIN pg_catalog.pg_roles r ON (pam.roleid = r.oid)
LEFT JOIN pg_catalog.pg_roles g ON (pam.grantor = g.oid)
WHERE m.rolname !~ '^pg_'
ORDER BY 1, 2;
```
Dalam output, Anda dapat melihat bahwa `rds_superuser` itu bukan peran pengguna basis data (tidak dapat masuk), tetapi memiliki hak akses dari banyak peran lainnya. Anda juga dapat melihat bahwa pengguna basis data `postgres` adalah anggota peran `rds_superuser`. Seperti disebutkan sebelumnya, `postgres` adalah nilai default di halaman **Buat basis data** konsol Amazon RDS. Jika Anda memilih nama lain, nama itu akan ditampilkan dalam daftar peran.
**catatan**
Aurora PostgreSQL versi 15.2 dan 14.7 memperkenalkan perilaku restriktif peran `rds_superuser`. Pengguna Aurora PostgreSQL harus diberi hak akses `CONNECT` pada basis data terkait agar dapat menghubungkan, meskipun pengguna tersebut diberi peran `rds_superuser`. Sebelum Aurora PostgreSQL versi 14.7 dan 15.2, pengguna dapat terhubung dengan basis data dan tabel sistem mana pun jika diberi peran `rds_superuser`. Perilaku restriktif ini sejalan dengan komitmen Amazon Aurora AWS dan Amazon Aurora untuk peningkatan keamanan yang berkelanjutan.
Perbarui logika masing-masing dalam aplikasi Anda jika peningkatan di atas berdampak.
# Mengontrol akses pengguna ke basis data PostgreSQL
Basis data baru di PostgreSQL selalu dibuat dengan serangkaian hak akses default dalam skema `public` basis data yang memungkinkan semua pengguna dan peran basis data untuk membuat objek. Hak akses ini memungkinkan pengguna basis data untuk terhubung ke basis data, misalnya, dan membuat tabel sementara saat terhubung.
Agar dapat mengontrol dengan lebih baik akses pengguna ke instans basis data yang Anda buat di simpul primer klaster DB Aurora PostgreSQL , sebaiknya Anda mencabut hak akses `public` default. Setelah melakukannya, Anda kemudian memberikan hak akses khusus untuk pengguna basis data secara lebih rinci, seperti yang diperlihatkan dalam prosedur berikut ini.
**Untuk menyiapkan peran dan hak akses untuk instans basis data baru**
Misalnya, Anda sedang menyiapkan basis data pada klaster DB Aurora PostgreSQL yang baru dibuat untuk digunakan oleh beberapa peneliti, yang semuanya membutuhkan akses baca-tulis ke basis data.
1. Gunakan `psql` (atau pgAdmin) untuk menghubungkan ke instans DB primer di klaster DB Aurora PostgreSQL:
```
psql --host=your-cluster-instance-1.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
Saat diminta, masukkan kata sandi Anda. Klien `psql` menghubungkan dan menampilkan basis data koneksi administratif default, `postgres=>`, sebagai perintah.
1. Untuk mencegah pengguna basis data membuat objek dalam skema `public`, lakukan tindakan berikut:
```
postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC;
REVOKE
```
1. Selanjutnya, buat instans basis data baru:
```
postgres=> CREATE DATABASE lab_db;
CREATE DATABASE
```
1. Cabut semua hak akses dari skema `PUBLIC` pada basis data baru ini.
```
postgres=> REVOKE ALL ON DATABASE lab_db FROM public;
REVOKE
```
1. Buat peran untuk pengguna basis data.
```
postgres=> CREATE ROLE lab_tech;
CREATE ROLE
```
1. Berikan pengguna basis data yang memiliki peran ini kemampuan untuk terhubung ke basis data.
```
postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Berikan semua hak akses pada basis data ini kepada semua pengguna dengan peran `lab_tech`.
```
postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Buat pengguna basis data, sebagai berikut:
```
postgres=> CREATE ROLE lab_user1 LOGIN PASSWORD 'change_me';
CREATE ROLE
postgres=> CREATE ROLE lab_user2 LOGIN PASSWORD 'change_me';
CREATE ROLE
```
1. Beri hak akses terkait peran lab\$1tech kepada dua pengguna ini:
```
postgres=> GRANT lab_tech TO lab_user1;
GRANT ROLE
postgres=> GRANT lab_tech TO lab_user2;
GRANT ROLE
```
Pada titik ini, `lab_user1` dan `lab_user2` dapat terhubung ke basis data `lab_db`. Contoh ini tidak mengikuti praktik terbaik untuk penggunaan perusahaan, yang mungkin termasuk membuat beberapa instans basis data, skema yang berbeda, dan pemberian izin terbatas. Untuk informasi yang lebih lengkap dan skenario tambahan lainnya, lihat [Mengelola Pengguna dan Peran PostgreSQL](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/).
Untuk informasi selengkapnya tentang hak akses di PostgreSQL, lihat perintah [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) dalam dokumentasi PostgreSQL.
# Menyerahkan dan mengendalikan manajemen kata sandi pengguna
Sebagai DBA, Anda mungkin perlu menyerahkan manajemen kata sandi pengguna. Atau, Anda juga dapat mencegah pengguna basis data mengubah kata sandi mereka atau mengonfigurasi ulang batasan kata sandi, seperti masa pakai kata sandi. Untuk memastikan bahwa hanya pengguna basis data yang Anda pilih yang dapat mengubah pengaturan kata sandi, Anda dapat mengaktifkan fitur manajemen kata sandi terbatas. Bila mengaktifkan fitur ini, hanya pengguna basis data yang telah diberikan peran `rds_password` yang dapat mengelola kata sandi.
**catatan**
Untuk menggunakan manajemen kata sandi terbatas, klaster DB Aurora PostgreSQL harus menjalankan Amazon Aurora PostgreSQL 10.6 atau versi lebih tinggi.
Secara default, fitur ini dalam keadaan `off`, seperti yang ditunjukkan berikut:
```
postgres=> SHOW rds.restrict_password_commands;
rds.restrict_password_commands
--------------------------------
off
(1 row)
```
Untuk mengaktifkan fitur ini, Anda harus menggunakan grup parameter kustom dan mengubah pengaturan `rds.restrict_password_commands` ke 1. Pastikan untuk melakukan booting ulang instans DB primer Aurora PostgreSQL agar pengaturan dapat berlaku.
Dalam keadaan fitur ini aktif, hak akses `rds_password` diperlukan untuk perintah SQL berikut:
```
CREATE ROLE myrole WITH PASSWORD 'mypassword';
CREATE ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword';
ALTER ROLE myrole VALID UNTIL '2023-01-01';
ALTER ROLE myrole RENAME TO myrole2;
```
Mengganti nama role (`ALTER ROLE myrole RENAME TO newname`) juga dibatasi jika password menggunakan algoritma MD5 hashing.
Jika fitur ini dalam keadaan aktif, mencoba salah satu perintah SQL ini tanpa izin peran `rds_password` akan menghasilkan kesalahan berikut:
```
ERROR: must be a member of rds_password to alter passwords
```
Sebaiknya Anda memberikan `rds_password` hanya untuk beberapa peran yang Anda gunakan semata untuk manajemen kata sandi. Jika memberikan hak akses `rds_password` kepada pengguna basis data yang tidak memiliki hak akses `rds_superuser`, Anda juga harus memberi mereka atribut `CREATEROLE`.
Pastikan Anda memverifikasi persyaratan kata sandi seperti kedaluwarsa dan kompleksitas yang diperlukan di sisi klien. Jika Anda menggunakan utilitas sisi klien Anda sendiri untuk perubahan terkait kata sandi, utilitas tersebut harus menjadi anggota `rds_password` dan memiliki hak akses `CREATE ROLE`.
# Menggunakan SCRAM untuk enkripsi kata sandi PostgreSQL
The *Salted Challenge Response Authentication Mechanism (SCRAM)* adalah alternatif dari algoritma message digest (MD5) default PostgreSQL untuk mengenkripsi kata sandi. Mekanisme otentikasi SCRAM dianggap lebih aman daripada. MD5 Untuk mempelajari selengkapnya tentang dua pendekatan berbeda untuk mengamankan kata sandi ini, lihat [Password Authentication](https://www.postgresql.org/docs/14/auth-password.html) dalam dokumentasi PostgreSQL.
Kami menyarankan Anda menggunakan SCRAM daripada MD5 sebagai skema enkripsi kata sandi untuk cluster Aurora PostgreSQL DB Anda. SCRAM didukung di Aurora PostgreSQL versi 10 dan semua versi mayor dan minor yang lebih tinggi. Ini adalah mekanisme respons tantangan kriptografi yang menggunakan algoritma scram-sha-256 untuk autentikasi dan enkripsi kata sandi.
Anda mungkin perlu memperbarui pustaka untuk aplikasi klien Anda agar dapat mendukung SCRAM. Misalnya, versi JDBC sebelum 42.2.0 tidak mendukung SCRAM. Untuk informasi selengkapnya, lihat [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) dalam dokumentasi Driver JDBC PostgreSQL. Untuk daftar driver PostgreSQL dan dukungan SCRAM lainnya, lihat [List of drivers](https://wiki.postgresql.org/wiki/List_of_drivers) dalam dokumentasi PostgreSQL.
Aurora PostgreSQL versi 14 dan yang lebih tinggi mendukung scram-sha-256 untuk enkripsi kata sandi untuk klaster DB baru secara default. Untuk versi ini, grup parameter cluster DB default (`default.aurora-postgresql14`) memiliki `password_encryption` nilai yang disetel ke scram-sha-256. SCRAM tidak didukung untukAurora Serverless v1.
## Menyiapkan Aurora PostgreSQL DB cluster untuk instance PostgreSQL DB untuk memerlukan SCRAM
Untuk Aurora PostgreSQL 14.3 dan versi yang lebih tinggi, Anda dapat meminta klaster DB Aurora PostgreSQL untuk hanya menerima kata sandi yang menggunakan algoritma scram-sha-256.
**penting**
Untuk Proksi RDS yang ada dengan basis data PostgreSQL, jika Anda mengubah autentikasi basis data untuk hanya menggunakan `SCRAM`, proksi akan menjadi tidak tersedia selama maksimal 60 detik. Untuk menghindari masalah ini, lakukan salah satu tindakan berikut:
Pastikan basis data mengizinkan autentikasi `SCRAM` dan `MD5`.
Untuk hanya menggunakan autentikasi `SCRAM`, buat proksi baru, migrasikan lalu lintas aplikasi Anda ke proksi baru, lalu hapus proksi yang sebelumnya terkait dengan basis data.
Sebelum melakukan perubahan pada sistem, pastikan Anda telah memahami proses lengkapnya, sebagai berikut:
+ Dapatkan informasi semua peran dan enkripsi kata sandi untuk semua pengguna basis data.
+ Periksa kembali pengaturan parameter klaster DB Aurora PostgreSQL untuk parameter yang mengontrol enkripsi kata sandi.
+ Jika klaster DB Aurora PostgreSQL menggunakan grup parameter default, maka Anda harus membuat grup parameter klaster DB , lalu menerapkannya ke klaster DB Aurora PostgreSQL agar Anda dapat memodifikasi parameter saat diperlukan. Jika klaster DB Aurora PostgreSQL menggunakan grup parameter kustom, Anda dapat memodifikasi parameter yang diperlukan nanti selama prosesnya sesuai kebutuhan.
+ Ubah parameter `password_encryption` ke `scram-sha-256`.
+ Beri tahu semua pengguna basis data bahwa mereka perlu memperbarui kata sandi. Lakukan hal yang sama untuk akun `postgres` Anda. Kata sandi baru telah dienkripsi dan disimpan menggunakan algoritma scram-sha-256.
+ Verifikasikan bahwa semua kata sandi telah dienkripsi menggunakan jenis enkripsi tersebut.
+ Jika semua kata sandi menggunakan scram-sha-256, Anda dapat mengubah parameter `rds.accepted_password_auth_method` dari `md5+scram` ke `scram-sha-256`.
**Awas**
Setelah Anda mengubah `rds.accepted_password_auth_method` ke scram-sha-256 saja, setiap pengguna (peran) dengan kata sandi terenkripsi `md5` tidak dapat terhubung.
###
Sebelum membuat perubahan apa pun pada klaster DB Aurora PostgreSQL periksa semua akun pengguna basis data yang ada. Periksa juga jenis enkripsi yang digunakan untuk kata sandi. Anda dapat melakukan semua tugas ini menggunakan ekstensi `rds_tools`. Untuk melihat versi PostgreSQL yang `rds_tools` didukung, [lihat Versi ekstensi untuk Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html) for PostgreSQL.
**Untuk mendapatkan daftar pengguna (peran) basis data dan metode enkripsi kata sandi**
1. Gunakan `psql` untuk terhubung ke instans primer klaster DB Aurora PostgreSQL , sebagaimana yang ditunjukkan di bawah ini.
```
psql --host=cluster-name-instance-1.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Instal ekstensi `rds_tools`.
```
postgres=> CREATE EXTENSION rds_tools;
CREATE EXTENSION
```
1. Dapatkan daftar peran dan enkripsi.
```
postgres=> SELECT * FROM
rds_tools.role_password_encryption_type();
```
Anda akan melihat output yang mirip dengan berikut ini.
```
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | md5
user_465 | md5
postgres | md5
(8 rows)
```
### Membuat grup parameter klaster DB
**catatan**
Jika klaster DB Aurora PostgreSQL sudah menggunakan grup parameter kustom, Anda tidak perlu membuat grup parameter yang baru.
Untuk ringkasan grup parameter Aurora, lihat [Membuat grup parameter cluster DB di Amazon Aurora](USER_WorkingWithParamGroups.CreatingCluster.md).
Jenis enkripsi kata sandi yang digunakan untuk kata sandi yang diatur dalam satu parameter, `password_encryption`. Enkripsi yang diizinkan oleh klaster DB Aurora PostgreSQL diatur dalam parameter lain, `rds.accepted_password_auth_method`. Mengubah salah satu dari nilai default ini mengharuskan Anda membuat grup parameter klaster DB , lalu menerapkannya ke klaster.
Anda juga dapat menggunakan Konsol Manajemen AWS atau RDS API untuk membuat grup parameter cluster DB kustom grup parameter . Untuk informasi lebih lanjut, lihat [Membuat grup parameter cluster DB di Amazon Aurora](USER_WorkingWithParamGroups.CreatingCluster.md).
Anda kini dapat mengaitkan grup parameter kustom dengan instans DB.
**Untuk membuat grup parameter cluster DB kustom grup**
1. Gunakan perintah CLI `[create-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster-parameter-group.html)` untuk membuat grup parameter kustom untuk klaster. Contoh berikut menggunakan `aurora-postgresql13` sebagai sumber untuk grup parameter kustom ini.
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-cluster-parameter-group --db-cluster-parameter-group-name 'docs-lab-scram-passwords' \
--db-parameter-group-family aurora-postgresql13 --description 'Custom DB cluster parameter group for SCRAM'
```
Untuk Windows:
```
aws rds create-db-cluster-parameter-group --db-cluster-parameter-group-name "docs-lab-scram-passwords" ^
--db-parameter-group-family aurora-postgresql13 --description "Custom DB cluster parameter group for SCRAM"
```
Anda kini dapat mengaitkan grup parameter kustom dengan klaster.
1. Gunakan perintah CLI `[modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)` untuk menerapkan grup parameter kustom ini ke klaster DB Aurora PostgreSQL Anda.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-cluster --db-cluster-identifier 'your-instance-name' \
--db-cluster-parameter-group-name "docs-lab-scram-passwords
```
Untuk Windows:
```
aws rds modify-db-cluster --db-cluster-identifier "your-instance-name" ^
--db-cluster-parameter-group-name "docs-lab-scram-passwords
```
Untuk menyinkronkan ulang klaster DB Aurora PostgreSQL Anda dengan grup parameter klaster DB kustom, boot ulang instans primer dan semua instans lain klaster.
### Mengonfigurasi enkripsi kata sandi agar menggunakan SCRAM
Mekanisme enkripsi kata sandi yang digunakan oleh klaster DB Aurora PostgreSQL diatur dalam grup parameter klaster DB dalam parameter `password_encryption`. Nilai yang diizinkan tidak ditentukan, `md5`, atau `scram-sha-256`. Nilai default bergantung pada versi Aurora PostgreSQL , sebagai berikut:
+ Aurora PostgreSQL 14 – Default adalah `scram-sha-256`
+ Aurora PostgreSQL 13 – Default adalah `md5`
Dengan grup parameter klaster DB yang terhubung ke klaster DB Aurora PostgreSQL, Anda dapat memodifikasi nilai untuk parameter enkripsi kata sandi.
![\[Berikutnya, konsol RDS akan menunjukkan nilai default parameter password_encryption untuk Aurora PostgreSQL.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/apg-pwd-encryption-md5-scram-1.png)
**Untuk mengubah pengaturan enkripsi kata sandi menjadi scram-sha-256**
+ Ubah nilai enkripsi kata sandi menjadi scram-sha-256, sebagaimana ditunjukkan berikut ini. Perubahan dapat langsung diterapkan karena parameternya dinamis, jadi mulai ulang tidak diperlukan agar perubahan diterapkan.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-cluster-parameter-group --db-cluster-parameter-group-name \
'docs-lab-scram-passwords' --parameters 'ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate'
```
Untuk Windows:
```
aws rds modify-db-parameter-group --db-parameter-group-name ^
"docs-lab-scram-passwords" --parameters "ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate"
```
### Memigrasikan kata sandi untuk peran pengguna ke SCRAM
Anda dapat memigrasikan kata sandi untuk peran pengguna ke SCRAM sebagaimana dijelaskan berikut.
**Untuk memigrasikan kata sandi pengguna (peran) basis data dari MD5 ke SCRAM**
1. Masuk sebagai pengguna administrator (nama pengguna default, `postgres`) sebagaimana ditunjukkan berikut.
```
psql --host=cluster-name-instance-1.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Periksa pengaturan parameter `password_encryption` pada instans DB RDS for PostgreSQL menggunakan perintah berikut.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
md5
(1 row)
```
1. Ubah nilai parameter ini menjadi scram-sha-256. Untuk informasi selengkapnya, lihat [Mengonfigurasi enkripsi kata sandi agar menggunakan SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption).
1. Periksa kembali nilainya untuk memastikan bahwa sekarang diatur ke`scram-sha-256`, sebagai berikut.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
scram-sha-256
(1 row)
```
1. Beri tahu semua pengguna basis data untuk mengubah kata sandi mereka. Pastikan juga untuk mengubah kata sandi Anda sendiri untuk akun `postgres` (pengguna basis data dengan hak akses `rds_superuser`).
```
labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me';
ALTER ROLE
```
1. Ulangi proses tersebut untuk semua basis data di klaster DB Aurora PostgreSQL Anda.
### Mengubah parameter untuk mengharuskan SCRAM
Ini adalah langkah terakhir dalam proses. Setelah Anda membuat perubahan dalam prosedur berikut, setiap akun pengguna (peran) yang masih menggunakan enkripsi `md5` untuk kata sandi tidak dapat masuk ke klaster DB PostgreSQL Aurora.
`rds.accepted_password_auth_method` menentukan metode enkripsi yang klaster DB Aurora PostgreSQL DB menerima untuk kata sandi pengguna selama proses masuk. Nilai default-nya adalah `md5+scram`, yang berarti bahwa salah satu metode diterima. Pada gambar berikut, Anda dapat menemukan pengaturan default untuk parameter ini.
![\[Konsol RDS menunjukkan nilai default dan yang diizinkan untuk parameter rds.accepted_password_auth_method.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/pwd-encryption-md5-scram-2.png)
Nilai yang diizinkan untuk parameter ini adalah `md5+scram` atau `scram` saja. Mengubah nilai parameter ini ke `scram` akan menjadikannya sebagai persyaratan.
**Untuk mengubah nilai parameter agar mengharuskan autentikasi SCRAM untuk kata sandi**
1. Verifikasikan bahwa semua kata sandi pengguna basis data untuk semua basis data di klaster DB Aurora PostgreSQL menggunakan `scram-sha-256` untuk enkripsi kata sandi. Untuk melakukannya, buat kueri `rds_tools` untuk peran (pengguna) dan jenis enkripsi, sebagai berikut.
```
postgres=> SELECT * FROM rds_tools.role_password_encryption_type();
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | scram-sha-256
user_465 | scram-sha-256
postgres | scram-sha-256
( rows)
```
1. Ulangi kueri di semua instans DB dalam klaster DB Aurora PostgreSQL Anda.
Jika semua kata sandi menggunakan scram-sha-256, Anda dapat melanjutkan.
1. Ubah nilai autentikasi kata sandi yang diterima menjadi scram-sha-256, sebagai berikut.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-cluster-parameter-group --db-cluster-parameter-group-name 'docs-lab-scram-passwords' \
--parameters 'ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate'
```
Untuk Windows:
```
aws rds modify-db-cluster-parameter-group --db-cluster-parameter-group-name "docs-lab-scram-passwords" ^
--parameters "ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate"
```