Mengukur performa OLTP di AlloyDB untuk PostgreSQL

Untuk mengevaluasi throughput dan latensi workload transaksional di AlloyDB untuk PostgreSQL, Anda dapat mengonfigurasi AlloyDB dan mesin klien untuk mengukur performa pemrosesan transaksi online (OLTP) menggunakan TPC-C, spesifikasi tolok ukur OLTP standar industri. Anda juga dapat menjalankan skenario OLTP intensif baca dan tulis yang disesuaikan, seperti Index Insert Only dan Select Only.

Petunjuk dalam dokumen ini didasarkan pada konfigurasi tertentu dari AlloyDB dan mesin klien. Gunakan nilai yang diberikan untuk setiap langkah dalam petunjuk tolok ukur.

Kemampuan workload AlloyDB

AlloyDB memberikan keandalan, skalabilitas, dan performa tingkat perusahaan yang cocok untuk semua bisnis dan workload penting. AlloyDB menyediakan komponen dan fitur berikut yang memungkinkan performa tinggi untuk workload transaksional (OLTP), analitis (OLAP), dan hybrid (HTAP):

  • Pengelolaan log dan transaksi
  • Manajemen memori dinamis
  • Integrasi kecerdasan buatan dan machine learning
  • Columnar engine bawaan
  • Cache multi-tingkat
  • Penyimpanan terdistribusi dan skalabel

Sistem database relasional biasanya memerlukan administrator database untuk mengoptimalkan database untuk tolok ukur, yang mencakup mengonfigurasi setelan log transaksi, menetapkan ukuran buffer pool yang tepat, dan mengubah parameter atau flag dan karakteristik database lainnya. Setelan ini bervariasi, bergantung pada ukuran dan jenis instance.

AlloyDB telah dikonfigurasi sebelumnya dengan setelan yang dioptimalkan untuk setiap jenis mesin. AlloyDB tidak mengharuskan Anda menyesuaikan flag di level database untuk mencapai performa OLTP yang tinggi; sebaliknya, AlloyDB memiliki performa OLTP tinggi yang sudah terintegrasi.

Jenis tolok ukur yang didukung

Dokumen ini menunjukkan cara menjalankan benchmark OLTP menggunakan alat berikut:

Driver tolok ukur OLTP Use cases
HammerDB HammerDB mengukur performa sistem dalam hal transaksi per menit (TPM) dan menghasilkan laporan yang mencakup statistik mendetail dan metrik performa.

HammerDB mendukung penyesuaian parameter benchmark, yang memungkinkan Anda menyesuaikan ukuran database, jumlah warehouse, dan karakteristik workload lainnya untuk menyimulasikan berbagai skenario.

HammerDB menyertakan implementasi benchmark TPC-C untuk mengevaluasi performa sistem OLTP. Implementasi TPC-C HammerDB memungkinkan Anda menyimulasikan workload yang mirip dengan benchmark TPC-C, termasuk campuran transaksi yang meniru perilaku lingkungan pemasok grosir.
pgbench pgbench adalah alat tolok ukur yang dipaketkan dengan PostgreSQL. Dengan pgbench, Anda dapat menyimulasikan workload transaksi seperti menyisipkan, memperbarui, memilih data, dan mengukur performa sistem database dalam Transaksi Per Detik (TPS).

Saat menggunakan pgbench, Anda dapat menyesuaikan ukuran database, jumlah klien, dan kombinasi transaksi untuk mengemulasi workload produksi dan mendapatkan insight tentang perilaku sistem dalam berbagai skenario.
pgbench menyertakan implementasi TPC-B. Implementasi TPC-B pgbench mirip dengan tolok ukur TPC-B.

Sebelum memulai

  1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the AlloyDB, Compute Engine, and Resource Manager APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the AlloyDB, Compute Engine, and Resource Manager APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

    8.

  8. Mengaktifkan Cloud API yang diperlukan untuk membuat dan terhubung ke AlloyDB untuk PostgreSQL.

    Mengaktifkan API

    1. Pada langkah Confirm project, klik Next untuk mengonfirmasi nama project yang akan Anda ubah.

    2. Pada langkah Enable APIs, klik Enable untuk mengaktifkan hal berikut:

      • AlloyDB API
      • Compute Engine API
      • Cloud Resource Manager API
      • Service Networking API

      Service Networking API diperlukan jika Anda berencana mengonfigurasi konektivitas jaringan ke AlloyDB menggunakan jaringan VPC yang berada dalam project Google Cloud yang sama dengan AlloyDB.

      Compute Engine API dan Cloud Resource Manager API diperlukan jika Anda berencana mengonfigurasi konektivitas jaringan ke AlloyDB menggunakan jaringan VPC yang berada di project Google Cloud yang berbeda.

Menyiapkan dan menyediakan database dan mesin klien

Mulai benchmark dengan membuat cluster dan instance AlloyDB. Kecuali ditentukan lain, informasi dalam dokumen ini didasarkan pada 16 vCPU dengan RAM 128 GB sebagai instance AlloyDB utama.

Membuat cluster dan instance AlloyDB

  1. Buka halaman Clusters.

    Buka Cluster

  2. Klik Create Cluster.

  3. Di kolom Cluster ID, masukkan nama untuk cluster Anda.

  4. Di Zonal availability, pilih Multiple zones (Highly Available) untuk jenis cluster.

  5. Pilih jaringan default.

  6. Di kolom Database version, pilih salah satu opsi berikut:

    • PostgreSQL 17

    • PostgreSQL 18

  7. Catat lokasi zona utama dan alamat IP pribadi. Jangan membuat kumpulan baca.

  8. Klik Create Cluster.

Menyediakan mesin klien

Untuk menjalankan tolok ukur OLTP, Anda memerlukan mesin klien dengan daya pemrosesan yang memadai. Alat benchmark seperti HammerDB dan pgbench berjalan dengan cara yang sangat paralel, dan menggunakan banyak CPU. Mesin klien tidak boleh menjadi bottleneck saat Anda menjalankan benchmark OLTP.

Kecuali ditentukan lain, petunjuk dalam dokumen ini menggunakan mesin E2-standard-32 dengan disk 128 GB sebagai klien untuk benchmark OLTP guna menggerakkan instance AlloyDB pada mesin 16 vCPU dengan RAM 128 GB. Anda harus membuat mesin klien di zona yang sama dengan instance utama AlloyDB.

Untuk menjalankan benchmark TPC-C pada instance utama AlloyDB dengan 16 CPU virtual, ikuti langkah-langkah berikut untuk membuat VM Compute Engine dan menyediakan mesin klien:

  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka instance VM

  2. Pilih project yang berisi instance AlloyDB yang ingin Anda hubungkan.
  3. Klik Create instance.
  4. Klik bagian Machine configuration.
  5. Masukkan Nama untuk instance.
  6. Konfigurasikan zona tempat Anda ingin membuat instance. Zona harus sama dengan zona instance utama AlloyDB.
  7. Pilih jenis mesin e2-standard-32.
  8. Pertahankan nilai default di bagian OS and Storage.
  9. Klik bagian Networking, dan tetapkan Network interfaces ke jaringan VPC yang dikonfigurasi untuk akses layanan pribadi ke AlloyDB.
    Jika Network interfaces tidak ditetapkan ke jaringan VPC yang dikonfigurasi untuk akses layanan pribadi, luaskan, lalu tetapkan Network ke jaringan VPC.
  10. Pertahankan nilai default di bagian Observability.
  11. Klik bagian Keamanan.
  12. Di bagian Identity and API access, tetapkan Cakupan akses ke Allow full access to all Cloud APIs.
  13. Pertahankan nilai default di bagian Advanced.
  14. Klik Create.
  15. Setelah VM dibuat, hubungkan ke VM Compute Engine yang Anda buat menggunakan SSH.

Menyiapkan mesin driver benchmark

Setelah menginstal dan menyiapkan database dan mesin klien, Anda mengonfigurasi mesin klien yang berjalan di Google Cloud, tempat Anda menginstal alat tolok ukur seperti HammerDB dan pgbench.

Untuk menyiapkan mesin driver benchmark, ikuti langkah-langkah berikut:

  1. Hubungkan ke mesin klien menggunakan perintah gcloud compute ssh berikut:

    gcloud compute ssh --zone "PRIMARY_ZONE" "CLIENT_MACHINE_NAME"  --project "GOOGLE_PROJECT"

  2. Menginstal klien PostgreSQL.

    1. Gunakan perintah berikut untuk menginstal klien PostgreSQL yang menyertakan aplikasi psql, lalu pastikan Anda dapat terhubung.

      sudo apt-get update
sudo apt install postgresql-client

    2. Gunakan perintah berikut untuk memastikan bahwa klien berfungsi dan Anda dapat terhubung ke AlloyDB. Gunakan alamat IP pribadi instance AlloyDB utama Anda.

      psql -h PRIVATE_IP -U postgres

  3. Instal driver HammerDB-4.6 untuk tolok ukur TPC-C dengan menjalankan perintah berikut:

    mkdir hammerdb
pushd hammerdb
curl -OL https://github.com/TPC-Council/HammerDB/releases/download/v4.6/HammerDB-4.6-Linux.tar.gz
tar zxvf HammerDB-4.6-Linux.tar.gz

  4. Instal driver pgbench untuk TPC-B dan berbagai tolok ukur OLTP dengan menjalankan perintah berikut:

    sudo apt-get update
sudo apt-get install postgresql-contrib
pgbench --version

    Jika pgbench --version berjalan tanpa error, berarti pgbench telah diinstal.

Melakukan pembersihan tolok ukur

Jika Anda berencana menjalankan beberapa benchmark secara berurutan, Anda harus melakukan pembersihan benchmark di antara setiap benchmark untuk memastikan hasil benchmarking yang akurat dan andal.

Pembersihan tolok ukur memastikan bahwa efek residual dari tolok ukur sebelumnya tidak memengaruhi pengukuran performa tolok ukur baru. Pembersihan tolok ukur juga membantu memastikan konsistensi dan pengulangan hasil tolok ukur, yang penting untuk membuat perbandingan yang bermakna antara berbagai sistem atau mengidentifikasi area untuk pengoptimalan dalam hardware, software, atau konfigurasi.

Ikuti langkah-langkah berikut untuk melakukan pembersihan benchmark sebelum Anda menjalankan benchmark lain:

  1. Hapus data tolok ukur atau database tolok ukur sebelumnya. Untuk menghapus database tolok ukur sebelumnya, gunakan perintah psql berikut dari mesin klien:

    psql -h PRIVATE_IP -U postgres -c "DROP DATABASE IF EXISTS <database_name>;"

    Untuk mengetahui informasi selengkapnya tentang penggunaan psql, lihat Menghubungkan ke database.

  2. Mulai ulang instance AlloyDB. Langkah ini akan menghapus cache di tingkat database dan sistem operasi.

Menjalankan Benchmark TPC-C

HammerDB adalah alat tolok ukur yang menyertakan implementasi tolok ukur TPC-C untuk mengevaluasi performa sistem OLTP. Implementasi TPC-C HammerDB memungkinkan Anda menyimulasikan workload yang mirip dengan tolok ukur TPC-C, termasuk campuran transaksi yang meniru perilaku lingkungan pemasok grosir.

HammerDB mengukur performa sistem dalam hal transaksi per menit (TPM) dan membuat laporan yang mencakup statistik mendetail dan metrik performa. Selain itu, HammerDB mendukung penyesuaian parameter benchmark, sehingga pengguna dapat menyesuaikan ukuran database, jumlah warehouse, dan karakteristik workload lainnya untuk menyimulasikan berbagai skenario.

Skenario evaluasi performa

Performa tolok ukur TPC-C dievaluasi menggunakan metode berikut:

  • Mode cache sebagian (~30%): Dalam mode ini, database TPC-C yang besar dibuat, yang hanya dapat muat sebagian di cache buffer. Transaksi dalam mode ini tidak selalu disajikan dari memori dan menimbulkan I/O ke subsistem penyimpanan yang mendasarinya. Skenario ini berlaku untuk kebutuhan OLTP banyak pengguna.

  • Mode di-cache sepenuhnya (100%): Dalam mode ini, database TPC-C sepenuhnya sesuai dengan cache buffer. Instance AlloyDB menggunakan sekitar 90% dari RAM 128 GB yang tersedia, termasuk cache buffer.

    Karena transaksi TPC-C melakukan I/O minimal —karena pembacaan sebagian besar dilayani dari cache buffer— dalam mode ini, TPM yang lebih tinggi diharapkan dibandingkan dengan operasi yang di-cache sebagian. Skenario ini berlaku untuk kebutuhan OLTP pengguna dengan kebutuhan I/O yang sangat rendah.

Menyiapkan mesin klien

  1. Siapkan mesin driver benchmark.

  2. Jika Anda menjalankan beberapa benchmark secara berurutan, lakukan pembersihan benchmark.

  3. Buka hammerdb/HammerDB-4.6 directory dengan menjalankan perintah berikut:

    cd hammerdb/HammerDB-4.6

    Anda akan menjalankan perintah dari direktori ini untuk menyiapkan mesin klien.

  4. Buat file setup.env menggunakan perintah berikut:

    cat << EOF > setup.env
# Private IP of the AlloyDB primary instance
export PGHOST=PRIVATE_IP
# Postgres default port address. You do not need to change it unless you use non-default port address.
export PGPORT=5432   # default port to connect with postgres
# Number of TPC-C warehouses to load. This determines the overall database size.
export NUM_WAREHOUSE=576
# Number of users for running the benchmark.
export NUM_USERS=256
EOF

  5. Edit file setup.env yang dihasilkan dengan mengganti semua parameter value yang ditandai dengan parameter value yang paling sesuai dengan penyiapan lingkungan Anda.

  6. Opsional: Uji mode yang di-cache sebagian (~30%) dengan mengubah NUM_WAREHOUSE menjadi 3200 di file setup.env. Untuk mengetahui informasi selengkapnya, lihat Skenario evaluasi performa.

  7. Opsional: Uji mode yang di-cache sepenuhnya (100%) dengan mengubah NUM_WAREHOUSE menjadi 576 di setup.env file. Untuk mengetahui informasi selengkapnya, lihat Skenario evaluasi performa.

Memuat data TPC-C ke dalam database

Langkah pemuatan mengacu pada proses mengisi database benchmark dengan data awal sebelum menjalankan pengujian performa.

Selama langkah pemuatan, database diisi dengan sejumlah gudang, pelanggan, dan entitas lain yang ditentukan sesuai dengan spesifikasi TPC-C. Tujuan langkah pemuatan adalah membuat workload yang realistis untuk pengujian performa, dan untuk memastikan bahwa hasil pengujian dapat dibandingkan di berbagai sistem.

Setelah langkah pemuatan selesai, database berada dalam status konsisten dengan kumpulan data awal yang ditentukan, siap digunakan untuk pengujian tolok ukur TPC-C.

Untuk memuat database TPC-C, ikuti langkah-langkah berikut:

  1. Beralihlah ke direktori beranda benchmark menggunakan perintah berikut:

    cd hammerdb/HammerDB-4.6

  2. Salin konten berikut, lalu tempelkan ke build-tpcc.sh:

    #!/bin/bash -x

source ./setup.env

# create role tpcc with superuser login as 'postgres' and password as 'AlloyDB#123';
# -----------------------------------------------------

./hammerdbcli << EOF

# CONFIGURE PARAMETERS FOR TPCC BENCHMARK
# --------------------------------------
dbset db pg
dbset bm tpc-c

# CONFIGURE POSTGRES HOST AND PORT
# --------------------------------------
diset connection pg_host $PGHOST
diset connection pg_port $PGPORT

# CONFIGURE TPCC
# --------------------------------------
diset tpcc pg_superuser postgres
diset tpcc pg_superuserpass AlloyDB#123
diset tpcc pg_user tpcc
diset tpcc pg_pass AlloyDB#123
diset tpcc pg_dbase tpcc

# SET NUMBER OF WAREHOUSES AND USERS TO MANAGE EACH WAREHOUSE
# THIS IMPORTANT METRIC ESTABLISHES THE DATABASE SCALE/SIZE
# --------------------------------------
diset tpcc pg_count_ware $NUM_WAREHOUSE
diset tpcc pg_num_vu 10

# LOG OUTPUT AND CONFIGURATION DETAILS
# --------------------------------------
vuset logtotemp 1
print dict

# CREATE AND POPULATE DATABASE SCHEMA
# --------------------------------------
buildschema

waittocomplete
vudestroy
quit

EOF

  3. Jalankan perintah pemuatan berikut dan tunggu hingga perintah selesai.

    chmod +x ./build-tpcc.sh
mkdir results
sudo nohup ./build-tpcc.sh > results/build-tpcc.out 2>&1

  4. Validasi pemuatan. Setelah skrip sebelumnya selesai, sebaiknya Anda mengonfirmasi bahwa pemuatan database berhasil. Untuk memverifikasi ukuran database, jalankan perintah berikut:

    psql -h $PGHOST -p 5432 -U postgres
postgres=> \l+ tpcc
                                                                          List of databases
     Name     |      Owner       | Encoding | Collate |  Ctype  |           Access privileges           |  Size   | Tablespace |                Description
 --------------+------------------+----------+---------+---------+---------------------------------------+---------+------------+--------------------------------------------
 tpcc         | tpcc             | UTF8     | C.UTF-8 | C.UTF-8 |                                       | --- GB  | pg_default |
           |                  |          |         |         |                                       | 160.000 |            |
 (1 row)

Dalam konfigurasi TPC-C yang di-cache 30% (dengan 3.200 warehouse), perkirakan ukuran database tpcc sekitar 300 GB.

Dalam konfigurasi TPC-C yang di-cache 100% (dengan 576 warehouse), perkirakan ukuran database tpcc sekitar 55 GB.

Menjalankan tolok ukur TPC-C

Sekarang Anda siap menjalankan uji performa TPC-C. Tolok ukur TPC-C dijalankan menggunakan database yang diisi dari langkah pemuatan. Tolok ukur ini menghasilkan serangkaian transaksi yang menyimulasikan lingkungan bisnis pada umumnya, termasuk entri pesanan, pemrosesan pembayaran, dan pengelolaan inventaris. Workload diukur dalam transaksi per menit (TPM), yang mewakili jumlah transaksi bisnis lengkap yang dapat ditangani sistem dalam satu menit.

Langkah run dirancang untuk menguji sistem database dalam kondisi yang realistis dan memberikan cara standar untuk mengukur performa yang dapat Anda bandingkan di berbagai sistem database. Vendor dan pengguna sering menggunakan hasil benchmark TPC-C untuk mengevaluasi performa berbagai sistem database dan konfigurasi hardware.

Untuk menjalankan benchmark TPC-C, ikuti langkah-langkah berikut:

  1. Beralih ke direktori utama benchmark:

    cd hammerdb/HammerDB-4.6

  2. Salin konten berikut, lalu tempelkan ke run-tpcc.sh:

    #!/bin/bash -x

source ./setup.env

./hammerdbcli << EOF
dbset db pg
dbset bm tpc-c

# CONFIGURE PG HOST and PORT
# -------------------------
diset connection pg_host $PGHOST
diset connection pg_port $PGPORT

# CONFIGURE TPCC DB
# -------------------------
diset tpcc pg_superuser postgres
diset tpcc pg_superuserpass AlloyDB#123
diset tpcc pg_user postgres
diset tpcc pg_pass AlloyDB#123
diset tpcc pg_dbase tpcc

# BENCHMARKING PARAMETERS
# -------------------------
diset tpcc pg_driver timed
diset tpcc pg_rampup 10
diset tpcc pg_duration 60
diset tpcc pg_vacuum false
diset tpcc pg_partition false
diset tpcc pg_allwarehouse true
diset tpcc pg_timeprofile true
diset tpcc pg_connect_pool false
diset tpcc pg_dritasnap false
diset tpcc pg_count_ware $NUM_WAREHOUSE
diset tpcc pg_num_vu 1

loadscript
print dict
vuset logtotemp 1
vuset vu $NUM_USERS
vucreate
vurun
waittocomplete
quit
EOF

  3. Jalankan skrip menggunakan perintah berikut:

    chmod +x run-tpcc.sh
mkdir results
sudo nohup ./run-tpcc.sh > results/run-tpcc.out 2>&1

  4. Tunggu hingga skrip run-tpcc.sh selesai. Skrip ini memerlukan waktu sekitar 1 jam 10 menit untuk diselesaikan. Setelah skrip selesai, Anda dapat menganalisis hasilnya.

Menganalisis hasil benchmark

Dalam tolok ukur TPC-C, Pesanan Baru Per Menit (NOPM) dan Transaksi Per Menit (TPM) adalah metrik performa yang digunakan untuk mengukur performa sistem database.

  • NOPM: mengukur jumlah transaksi pesanan baru yang dapat ditangani sistem dalam satu menit. Transaksi pesanan baru adalah salah satu transaksi terpenting dalam benchmark TPC-C dan melibatkan pembuatan pesanan baru untuk pelanggan.

  • TPM: mengukur jumlah total transaksi bisnis yang diselesaikan yang dapat ditangani sistem dalam satu menit. Transaksi mencakup transaksi pesanan baru serta jenis transaksi lain yang ditentukan dalam tolok ukur TPC-C, seperti pembayaran, pengiriman, dan status pesanan.

    TPM adalah metrik performa utama untuk benchmark TPC-C karena memberikan ukuran keseluruhan kemampuan sistem untuk menangani workload yang realistis. NOPM dapat menjadi metrik yang berguna untuk sistem yang berfokus pada pemrosesan pesanan baru, seperti sistem e-commerce atau retail.

Melihat hasil dengan database TPC-C yang di-cache 30% di mesin 16 vCPU

Untuk mengekstrak angka performa untuk skenario ini, gunakan perintah berikut:

grep NOPM results/run-tpcc.out

Berikut adalah output yang diharapkan:

Vuser 1:TEST RESULT : System achieved 252970 NOPM from 582385 PostgreSQL TPM

Dengan database TPC-C yang di-cache 30% pada mesin 16 vCPU (dengan NUM_WAREHOUSE=3200 dan NUM_USERS=256), Anda akan mengamati 252.970 tpm-C (New Order Per Minute) dari TPM AlloyDB kumulatif sebesar 582.385.

Melihat hasil dengan database TPC-C yang di-cache 100% di mesin 16 vCPU

Pada database TPC-C yang di-cache 100% di mesin 16 vCPU (dengan NUM_WAREHOUSE=576 dan NUM_USERS=256), Anda akan mengamati 428.316 tpm-C (Pesanan Baru Per Menit) dari TPM AlloyDB kumulatif sebesar 974.264.

Untuk mengekstrak angka performa untuk skenario ini, gunakan perintah berikut:

grep NOPM results/tpcc-run.out

Berikut adalah output yang diharapkan:

Vuser 1:TEST RESULT : System achieved 428316 NOPM from 974264 PostgreSQL TPM

Ringkasan hasil performa pada mesin 16 vCPU

Tabel berikut merangkum hasil performa benchmark untuk mesin 16 vCPU:

Skenario TPC-C NUM_WAREHOUSE NUM_USERS NOPM TPM Kumulatif
30% di-cache 3200 256 252.970 582.385
100% di-cache 576 256 428.316 974.264

Mengamati metrik performa database

Untuk lebih memahami perilaku sistem database Anda, gunakan alat pemantauan AlloyDB untuk mengamati metrik sistem yang penting seperti penggunaan CPU, penggunaan memori, dan transaksi per detik. Untuk mengetahui informasi selengkapnya, lihat Memantau performa instance.

Misalnya, setelah menjalankan benchmark ini, Anda dapat mengamati di halaman Ringkasan AlloyDB di konsol Google Cloud bahwa pemakaian CPU rata-rata untuk operasi TPC-C yang di-cache 100% hampir 90%.

Menjalankan tolok ukur TPC-C pada instance AlloyDB 64 vCPU

Untuk menjalankan tolok ukur TPC-C pada instance AlloyDB 64 vCPU, Anda mengikuti langkah-langkah penyiapan yang sama seperti dalam Menjalankan tolok ukur TPC-C, tetapi Anda menggunakan jenis mesin yang berbeda.

Menyiapkan AlloyDB dan mesin klien

  1. Buat cluster dan instance AlloyDB, dengan mengganti 64 vCPU, 512GB sebagai jenis mesin.

  2. Sediakan mesin klien, dengan mengganti n2-standard-64 sebagai jenis mesin.

  3. Siapkan mesin driver benchmark.

Menjalankan benchmark

  1. Jika Anda menjalankan beberapa benchmark secara berurutan, lakukan pembersihan benchmark.

  2. Siapkan mesin klien, dengan mengganti nilai berikut:

    • Tetapkan PGHOST ke IP Pribadi instance AlloyDB 64 vCPU baru Anda.
    • Untuk skenario TPC-C yang Di-cache 30%, tetapkan NUM_WAREHOUSE=12800 dan NUM_USERS=1024.
    • Untuk skenario TPC-C yang Di-cache 100%, tetapkan NUM_WAREHOUSE=2304 dan NUM_USERS=1024.

  3. Siapkan dan muat database TPC-C. Untuk mempercepat pemuatan, ubah nilai pg_num_vu menjadi 64 di build-tpcc.sh sebagai diset tpcc pg_num_vu 64.

  4. Jalankan tolok ukur TPC-C.

Menganalisis hasil benchmark

Tabel berikut merangkum hasil performa benchmark pada mesin 64 vCPU:

Mode tolok ukur NUM_WAREHOUSE NUM_USERS NOPM TPM Kumulatif
30% di-cache 12800 1024 589.598 1.371.160
100% di-cache 2304 1024 716.138 1.665.438

Menjalankan benchmark TPC-B pgbench

TPC-B (Transaction Processing Performance Council Benchmark B) adalah salah satu mode benchmark yang tersedia di pgbench, alat benchmark untuk PostgreSQL. TPC-B menyimulasikan skenario perbankan di mana beberapa teller menjalankan transaksi pada rekening nasabah. Workload terdiri dari jenis transaksi berikut:

  • Setoran
  • Penarikan
  • Pengecekan saldo

Tolok ukur ini mengukur performa sistem database dengan menyimulasikan kombinasi transaksi ini dan mengukur jumlah transaksi per detik yang dapat ditangani sistem.

Mode TPC-B di pgbench menghasilkan database sintetis dan menyimulasikan campuran transaksi yang menyerupai workload TPC-B, tetapi tidak disertifikasi secara resmi oleh organisasi TPC. Oleh karena itu, meskipun mode TPC-B di pgbench memberikan perkiraan performa TPC-B yang berguna, jangan gunakan mode ini untuk mengklaim kepatuhan terhadap standar TPC-B.

Skenario untuk mengukur performa

Bagian ini menjelaskan cara mengukur performa TPC-B dalam mode penting berikut. Satu-satunya parameter yang berbeda dalam mode ini adalah nilai parameter SCALE_FACTOR.

Skenario database yang di-cache sebagian

Dalam skenario ini, Anda akan menyiapkan dan melakukan inisialisasi database besar (berukuran sekitar 650 GB) menggunakan --scale= 50000. Memiliki database besar yang tidak muat dalam memori dan menyebabkan I/O disk yang signifikan memberikan representasi realistis dari banyak workload produksi.

Database besar yang menyebabkan I/O disk yang signifikan dapat menekankan pentingnya desain database dan pengoptimalan kueri. Database besar juga dapat mengekspos masalah performa yang terkait dengan I/O disk, seperti akses disk yang lambat atau kueri yang tidak efisien, yang mungkin tidak terlihat dalam database kecil atau database yang sepenuhnya berada di memori.

Skenario database yang di-cache sepenuhnya

Dalam skenario ini, Anda menyiapkan dan melakukan inisialisasi database berukuran sekitar 60 GB menggunakan --scale=4000 sehingga berada di buffer pool. Melakukan tolok ukur pada database yang berada di memori sangat penting karena memungkinkan Anda menilai performa maksimum sistem database dalam lingkungan yang terkontrol.

Database yang berada di memori menyimpan semua data di kumpulan buffer PostgreSQL, sehingga menghilangkan bottleneck I/O yang dapat terjadi saat mengakses data dari disk. Mode ini dapat membantu mengidentifikasi bottleneck performa yang tidak terkait dengan I/O, seperti penggunaan CPU atau masalah penguncian, yang mungkin tidak terlihat saat Anda melakukan benchmark database yang mengandalkan I/O disk.

Menyiapkan server database dan mesin klien

Untuk menyiapkan infrastruktur guna menjalankan tolok ukur TPC-B pgbench, ikuti langkah-langkah berikut:

  1. Buat cluster dan instance AlloyDB, dengan mengganti 16 vCPU, 128GB sebagai jenis mesin.

  2. Sediakan mesin klien, dengan mengganti E2-standard-16 (minimum) sebagai jenis mesin.

  3. Siapkan mesin driver benchmark.

  4. Melakukan pembersihan benchmark.

Menjalankan benchmark TPC-B pgbench

  1. Hubungkan ke mesin klien menggunakan perintah Google Cloud CLI berikut:

    gcloud compute ssh --zone "PRIMARY_ZONE" "CLIENT_MACHINE_NAME" --project "GOOGLE_PROJECT"

  2. Buat file pgbench-setup.env:

    $ cat << EOF > pgbench-setup.env

# Private IP of the AlloyDB primary instance
export PGHOST=<private_ip>

# Set PGUSER to postgres as a default user.
export PGUSER=postgres

# Password set for PGUSER
export PGPASSWORD=<your pg password>

# In pgbench, the scale factor represents the size of the test database.
# and is defined as the number of 1 MB-sized data pages to be generated per client.
export SCALE_FACTOR=<scale_factor>

# Number of clients to drive the benchmark in throughput mode
export NUM_CLIENTS=<num_clients>

EOF

  3. Edit file setup.env yang dihasilkan dan ganti nilai parameter berikut dengan nilai yang sesuai dengan penyiapan lingkungan Anda.

    • PRIVATE_IP: IP pribadi instance AlloyDB Anda.

    Gunakan tabel berikut untuk memilih nilai <scale_factor> dan <num_clients>. Nilai ini harus diskalakan dengan jenis mesin dan ukuran database (di-cache sepenuhnya atau di-cache sebagian). Contoh dalam panduan ini menggunakan nilai SCALE_FACTOR dan NUM_CLIENT yang sesuai dengan jenis mesin n2-highmem-16.

    Di-cache Sepenuhnya Di-cache Sebagian
    Machine Type SCALE_FACTOR NUM_CLIENTS SCALE_FACTOR NUM_CLIENTS
    n2-highmem-2 500 48 6250 32
    n2-highmem-4 1000 96 12500 64
    n2-highmem-8 2000 192 25000 128
    n2-highmem-16 4000 384 50000 256
    n2-highmem-32 8000 768 100000 512
    n2-highmem-64 16000 1536 200000 1024

  4. Membuat database pgbench.

    source ./pgbench-setup.env
psql -h $PGHOST -p 5432
postgres=> create database pgbench;
CREATE DATABASE

  5. Lakukan inisialisasi dan muat database pgbench dengan menjalankan perintah berikut. Langkah ini memastikan bahwa set data tolok ukur dibuat dan diisi dengan data yang realistis, sehingga Anda dapat menyimulasikan workload TPC-B secara akurat di database pgbench.

    source ./pgbench-setup.env
sudo nohup pgbench -i --host=$PGHOST --scale=$SCALE_FACTOR pgbench > /tmp/pgbench-tpcb-partially-cached-db-init.out 2>&1

    Perkiraan waktu pemuatan:

    • Database yang di-cache sebagian memerlukan waktu sekitar 6 jam untuk dimuat.
    • Database yang di-cache sepenuhnya memerlukan waktu sekitar 45 menit untuk dimuat.

  6. Opsional: Lakukan pemeriksaan akurasi pemuatan dengan memastikan bahwa konten file /tmp/pgbench-tpcb-partially-cached-db-init.out mirip dengan berikut ini:

    generating data (client-side)...
100000 of 400000000 tuples (0%) done (elapsed 0.02 s, remaining 99.82 s)
.. .. ..
.. .. ..
399800000 of 400000000 tuples (99%) done (elapsed 534.60 s, remaining 0.27 s)
399900000 of 400000000 tuples (99%) done (elapsed 534.72 s, remaining 0.13 s)
400000000 of 400000000 tuples (100%) done (elapsed 534.85 s, remaining 0.00 s)
vacuuming...
creating primary keys...
done in 1481.92 s (drop tables 0.01 s, create tables 0.04 s, client-side generate 540.93 s, vacuum 615.11 s, primary keys 325.84 s).

  7. Opsional: Untuk memvalidasi lebih lanjut akurasi beban Anda, jalankan perintah PostgreSQL berikut yang mengukur ukuran semua tabel pgbench:

    1. Hubungkan ke database pgbench:

      source ./pgbench-setup.env
psql -h $PGHOST -p 5432 -U postgres -d pgbench

    2. Jalankan perintah SQL berikut:

      pgbench=> SELECT nspname AS schema_name, relname AS table_name, pg_size_pretty(pg_total_relation_size(C.oid)) AS size FROM pg_class C
LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
WHERE nspname NOT LIKE 'pg_%' AND nspname != 'information_schema'
ORDER BY pg_total_relation_size(C.oid) DESC;

    3. Bandingkan output perintah sebelumnya dengan output yang Anda peroleh untuk operasi database yang di-cache sebagian (SCALE_FACTOR=50000).

       schema_name |                table_name                 |  size
 -------------+-------------------------------------------+---------
 public      | pgbench_accounts                          | 731 GB
 public      | pgbench_accounts_pkey                     | 105 GB
 public      | pgbench_tellers                           | 32 MB
 public      | pgbench_tellers_pkey                      | 11 MB
 public      | pgbench_branches                          | 2952 kB
 public      | pgbench_branches_pkey                     | 1112 kB
 .. .. ..
 public      | pgbench_history                           | 0 bytes
 .. .. ..
 (29 rows)

  8. Jalankan perintah berikut untuk menyimulasikan workload sistem akuntansi keuangan dengan menjalankan serangkaian transaksi yang melibatkan deposit, transfer, dan pembayaran, yang memungkinkan Anda mengukur performa database dalam workload yang berat.

    source ./pgbench-setup.env
mkdir -p ~/results/alloydb/pgbench
sudo nohup pgbench --host=$PGHOST --builtin=tpcb-like --time=3900 --jobs=$NUM_CLIENTS --client=$NUM_CLIENTS --scale=$SCALE_FACTOR --protocol=prepared --progress=1 pgbench > ~/results/alloydb/pgbench/pgbench.run.out 2>&1

Menganalisis hasil benchmark

Periksa output perintah sebelumnya di file ~/results/alloydb/pgbench/pgbench.run.out. Jumlah TPS harus mendekati angka yang ditampilkan dalam skenario database yang di-cache sepenuhnya dan database yang di-cache sebagian.

Hasil dengan database yang di-cache sepenuhnya

Output perintah terakhir di Menjalankan benchmark TPC-B pgbench akan mirip dengan berikut ini, dengan --scale=4000:

transaction type: <builtin: TPC-B (sort of)>
scaling factor: 4000
query mode: prepared
number of clients: 384
number of threads: 384
duration: 3900 s
number of transactions actually processed: 84819501
latency average = 17.654 ms
latency stddev = 6.963 ms
tps = 21747.831164 (including connections establishing)
tps = 21750.579718 (excluding connections establishing)

Untuk lebih memahami perilaku sistem database, Anda dapat memantau metrik sistem seperti penggunaan CPU, penggunaan memori, dan transaksi per detik menggunakan konsol Google Cloud . Untuk mengetahui informasi selengkapnya, lihat Memantau instance.

Hasil dengan database yang di-cache sebagian

Output perintah terakhir di Menjalankan benchmark TPC-B pgbench akan mirip dengan berikut ini, dengan --scale=50000:

pgbench: warning: scale option ignored, using count from pgbench_branches table (50000)
starting vacuum...end.
transaction type: <builtin: TPC-B (sort of)>

scaling factor: 50000
query mode: prepared
number of clients: 384
number of threads: 384
duration: 3900 s
number of transactions actually processed: 68073405
latency average = 21.992 ms
latency stddev = 29.272 ms
tps = 17453.913041 (including connections establishing)
tps = 17460.373303 (excluding connections establishing)

Ringkasan hasil performa untuk tolok ukur TPC-B pgbench

Tabel berikut merangkum hasil performa untuk benchmark TPC-B pgbench:

Skenario TPC-B SCALE_FACTOR TPS Penggunaan CPU (%)
Sebagian di-cache 50000 17.460 96%
Di-cache Sepenuhnya 4000 21.750 94%

Menjalankan benchmark Hanya Penyisipan Indeks

Benchmark Index Insert Only adalah skenario yang sangat serentak dan intensif penulisan yang disesuaikan di bagian ini untuk menunjukkan manfaat performa AlloyDB bagi sebagian besar aplikasi OLTP. Untuk menjalankan benchmark ini, Anda membuat beberapa indeks pada tabel pgbench_history, lalu berulang kali melakukan operasi INSERT pada tabel pgbench_history dari beberapa koneksi klien.

Benchmark Index Only Insert mengukur performa penyisipan data ke dalam tabel database, yang secara khusus berfokus pada dampak indeks terhadap operasi tulis. Tolok ukur ini memungkinkan Anda memahami seberapa cepat baris baru dapat ditambahkan ke tabel dengan dan tanpa indeks, sehingga menyoroti potensi perlambatan yang disebabkan oleh pemeliharaan indeks selama penyisipan.

AlloyDB meningkatkan performa tulis PostgreSQL, yang juga meningkatkan workload OLTP. Untuk meningkatkan performa skenario OLTP yang intensif penulisan, AlloyDB menawarkan inovasi arsitektur termasuk lapisan cache bertingkat untuk membantu pembacaan, dan teknologi mesin penyimpanan yang terdistribusi dan sangat skalabel untuk penulisan.

Menyiapkan AlloyDB dan mesin klien

Untuk menyiapkan infrastruktur guna menjalankan benchmark Index Only Insert, ikuti langkah-langkah berikut:

  1. Buat cluster dan instance AlloyDB, dengan mengganti 16 vCPU and 128 GB RAM sebagai jenis mesin.

  2. Sediakan mesin klien, dengan mengganti E2-standard-16 (minimum) sebagai jenis mesin.

  3. Menyiapkan mesin driver benchmark.

  4. Melakukan pembersihan benchmark.

Menjalankan benchmark Hanya Penyisipan Indeks

  1. Hubungkan ke mesin klien menggunakan contoh perintah berikut:

    gcloud compute ssh --zone "<primary zone>" "<client machine name>" --project "<google-project>"

  2. Siapkan lingkungan dengan menjalankan perintah berikut:

    export PGHOST=<private_ip>

  3. Buat database pgbench menggunakan contoh berikut. Jika database sudah ada, hapus database dan buat ulang.

    psql -h $PGHOST -p 5432 -U postgres -c "DROP DATABASE IF EXISTS pgbench"
psql -h $PGHOST -p 5432 -U postgres -c "CREATE DATABASE pgbench"

  4. Lakukan inisialisasi dan muat database pgbench untuk memastikan bahwa set data tolok ukur dibuat dan diisi dengan data yang realistis. Edit parameter yang ditandai, lalu jalankan perintah berikut:

    sudo nohup pgbench -i  --host=$PGHOST --user=postgres --scale=25000 pgbench > /tmp/pgbench-index-insert-only-init.out 2>&1
...

postgres=> create database pgbench;
CREATE DATABASE pgbench

  5. Pastikan output perintah sebelumnya mirip dengan berikut ini:

    dropping old tables...
creating tables...
generating data (client-side)...
100000 of 2500000000 tuples (0%) done (elapsed 0.03 s, remaining 636.43 s)
200000 of 2500000000 tuples (0%) done (elapsed 0.05 s, remaining 649.12 s)
.. .. ..
.. .. ..
2499900000 of 2500000000 tuples (99%) done (elapsed 3425.42 s, remaining 0.14 s)
2500000000 of 2500000000 tuples (100%) done (elapsed 3425.57 s, remaining 0.00 s)
vacuuming...
creating primary keys...
done in 12851.19 s (drop tables 998.62 s, create tables 0.02 s, client-side generate 3460.33 s, vacuum 5299.93 s, primary keys 3092.29 s).

  6. Buat skrip index-init.sql menggunakan perintah berikut:

    cat > index-init.sql << EOF
CREATE INDEX tid ON pgbench_history(tid);
CREATE INDEX bid ON pgbench_history(bid);
CREATE INDEX aid ON pgbench_history(aid);
CREATE INDEX delta ON pgbench_history(delta);
CREATE INDEX mtime ON pgbench_history(mtime);
EOF

  7. Jalankan skrip index-init.sql:

    psql -h $PGHOST -U postgres -d pgbench -f ./index-init.sql
Password for user postgres:
CREATE INDEX

  8. Opsional: Validasi skema database dan pemuatan awal:

    psql -h $PGHOST -U postgres -d pgbench

pgbench=> \dt
           List of relations
Schema |       Name       | Type  |  Owner
--------+------------------+-------+----------
 public | pgbench_accounts | table | postgres
 public | pgbench_branches | table | postgres
 public | pgbench_history  | table | postgres
 public | pgbench_tellers  | table | postgres
(4 rows)

pgbench=> \di
                       List of relations
 Schema |         Name          | Type  |  Owner   |      Table
--------+-----------------------+-------+----------+------------------
 public | aid                   | index | postgres | pgbench_history
 public | bid                   | index | postgres | pgbench_history
 public | delta                 | index | postgres | pgbench_history
 public | mtime                 | index | postgres | pgbench_history
 public | pgbench_accounts_pkey | index | postgres | pgbench_accounts
 public | pgbench_branches_pkey | index | postgres | pgbench_branches
 public | pgbench_tellers_pkey  | index | postgres | pgbench_tellers
 public | tid                   | index | postgres | pgbench_history
(8 rows)

    Setelah pemuatan, ukuran database diperkirakan sekitar 365 GB:

    pgbench=> \l+ pgbench
                         List of databases
Name     |      Owner       | Encoding | Collate |  Ctype  |           Access privileges           |  Size  | Tablespace |                Description
 --------------+------------------+----------+---------+---------+---------------------------------------+--------+------------+--------------------------------------------
...
 pgbench      | postgres         | UTF8     | C.UTF-8 | C.UTF-8 |                                       | 365 GB | pg_default |
...

  9. Buat skrip index-inserts-only.sql menggunakan perintah berikut:

    cat > index-inserts-only.sql << EOF
\set aid random(1, 1000000000)
\set bid random(1, 1000000000)
\set tid random(1, 1000000000)
\set delta random(-500000000, 500000000)
BEGIN;
INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
END;
EOF

  10. Jalankan tolok ukur pgbench menggunakan perintah berikut:

    sudo nohup pgbench --host=$PGHOST --user=postgres --time=3900 --client=256 --jobs=256 --scale=25000 --progress=1 --file=./index-inserts-only.sql pgbench > /tmp/pgbench-index-insert-only-run.out 2>&1

Menganalisis hasil benchmark

Verifikasi output perintah sebelumnya dalam file /tmp/pgbench-index-insert-only-run.out. Anda akan melihat sekitar 52 ribu transaksi per detik dan tingkat pemakaian CPU sekitar 88% selama pengujian tolok ukur ini, seperti yang ditunjukkan dalam contoh output berikut.

scaling factor: 25000
query mode: simple
number of clients: 256
number of threads: 256
duration: 3900 s
number of transactions actually processed: 201785196
latency average = 4.947 ms
latency stddev = 3.488 ms
tps = 51738.604613 (including connections establishing)
tps = 51742.459757 (excluding connections establishing)

Menjalankan benchmark Select Only pada Instance 64 vCPU

pgbench mendukung skenario bawaan khusus pemilihan yang berulang kali menjalankan kueri SELECT dari beberapa koneksi klien terhadap database yang ditentukan. Tolok ukur ini digunakan untuk mengukur performa baca database, tanpa menimbulkan overhead operasi modifikasi data seperti INSERT, UPDATE, atau DELETE. Kueri SELECT ini adalah kueri pencarian titik yang merupakan jenis kueri select tercepat dan paling efisien karena hanya melibatkan akses ke satu baris data langsung dari struktur indeks.

Menjalankan benchmark Khusus Pilih membantu Anda mencapai hal berikut:

  • Mencapai throughput maksimum: Karena pencarian titik pada indeks adalah bentuk kueri yang paling efisien dalam sistem database, Anda dapat mengukur throughput maksimum yang dapat dicapai AlloyDB.

  • Skalabilitas: Benchmark khusus Select membantu Anda menguji skalabilitas AlloyDB dari 2 vCPU hingga konfigurasi vCPU maksimum yang ditawarkan oleh AlloyDB.

Menyiapkan AlloyDB dan mesin klien

Siapkan AlloyDB dan mesin klien pada jenis mesin 64 vCPU.

Menjalankan benchmark Select Only

  1. Hubungkan ke mesin klien menggunakan contoh perintah berikut:

    gcloud compute ssh --zone "PRIMARY_ZONE" "CLIENT_MACHINE_NAME" --project "GOOGLE_PROJECT"

  2. Siapkan lingkungan menggunakan perintah berikut:

    export PGHOST=<private_ip>

  3. Buat database pgbench menggunakan contoh berikut:

    psql -h $PGHOST -p 5432 -U postgres

postgres=> create database pgbench;
CREATE DATABASE

  4. Lakukan inisialisasi database pgbench. Perintah berikut menginisialisasi database pgbench dengan sekitar 220 GB data realistis. Anda menggunakan --scale=15000 untuk benchmark Select Only yang di-cache sepenuhnya.

    Jalankan perintah berikut:

    sudo nohup pgbench -i --host=$PGHOST --user=postgres --scale=15000 pgbench > /tmp/pgbench-select-only-init.out 2>&1

  5. Pastikan output perintah sebelumnya mirip dengan berikut ini:

    cat /tmp/pgbench-select-only-init.out
nohup: ignoring input
dropping old tables...
creating tables...
generating data (client-side)...
100000 of 1500000000 tuples (0%) done (elapsed 0.01 s, remaining 161.60 s)
200000 of 1500000000 tuples (0%) done (elapsed 0.03 s, remaining 224.35 s)
300000 of 1500000000 tuples (0%) done (elapsed 0.09 s, remaining 448.97 s)
.. .. ..
.. .. ..
1499900000 of 1500000000 tuples (99%) done (elapsed 1251.03 s, remaining 0.08 s)
1500000000 of 1500000000 tuples (100%) done (elapsed 1251.10 s, remaining 0.00 s)
vacuuming...
creating primary keys...
done in 2204.62 s (drop tables 2.29 s, create tables 0.01 s, client-side generate 1271.82 s, vacuum 427.83 s, primary keys 502.66 s).

  6. Menjalankan pgbench. Langkah terakhir pembuatan tolok ukur ini memerlukan waktu lebih dari satu jam untuk diselesaikan.

    sudo nohup pgbench --host=$PGHOST --user=postgres  --builtin=select-only --time=3900 --jobs=256 --client=256 --scale=15000 --protocol=simple --progress=1 pgbench > /tmp/pgbench-select-only-run.out  2>&1

  7. Setelah benchmark selesai, periksa file /tmp/pgbench-select-only-run.out untuk melihat hasil akhir.

Menganalisis hasil benchmark

Anda akan mengamati sekitar 467 ribu transaksi per detik dan tingkat pemakaian CPU sekitar 95% selama pengujian tolok ukur ini, seperti yang ditunjukkan dalam contoh output berikut.

cat /tmp/pgbench-select-only-run.out
transaction type: <builtin: select only>
scaling factor: 15000
query mode: simple
number of clients: 256
number of threads: 256
duration: 3900 s
number of transactions actually processed: 1823506174
latency average = 0.547 ms
latency stddev = 0.267 ms
tps = 467563.144333 (including connections establishing)
tps = 467583.398400 (excluding connections establishing)

Ringkasan hasil tolok ukur AlloyDB

Tabel berikut merangkum hasil tolok ukur AlloyDB berdasarkan pengujian yang dilakukan dalam dokumen ini.

Ringkasan performa TPC-C HammerDB

Jenis Mesin AlloyDB Skenario Workload TPC-C NUM_WAREHOUSE NUM_USERS Pesanan Baru Per Menit (NOPM) TPM Kumulatif Dikonversi ke TPS
16vCPU 30% di-cache 3200 256 252.970 582.385 9.706
16vCPU 100% di-cache 576 256 428.316 974.264 16.238
64vCPU 30% di-cache 12800 1024 589.598 1.371.160 22.853
64vCPU 100% di-cache 2304 1024 716.138 1.665.438 27.757

Ringkasan performa pgbench

Jenis Mesin AlloyDB Skenario Workload pgbench Faktor Skala TPS %CPU
16vCPU TPC-B Like, Di-cache Sepenuhnya 4000 20.359 96%
16vCPU TPC-B Like, Di-cache Sebagian 50000 14.060 94%
16vCPU Hanya penyisipan indeks 25000 51.742 88%
64vCPU Throughput Maks. (Hanya Pilih) 15000 467.583 95%

Menjalankan tolok ukur OLTP di Cloud SQL untuk PostgreSQL

Anda dapat menguji performa OLTP yang setara di PostgreSQL di Cloud SQL untuk PostgreSQL pada jenis mesin 16 vCPU untuk analisis komparatif. Bagian ini menjelaskan cara menyiapkan Cloud SQL untuk PostgreSQL (atau server PostgreSQL apa pun yang di-deploy di infrastruktur pilihan Anda) yang sebanding dengan penyiapan AlloyDB yang digunakan dalam panduan ini untuk mengukur performa OLTP. Dalam skenario ini, termasuk memilih SKU 16vCPU, mengaktifkan ketersediaan tinggi (HA), dan melakukan pra-konfigurasi dengan penyimpanan.

Sebelum memulai

  1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the AlloyDB, Compute Engine, and Resource Manager APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  7. To initialize the gcloud CLI, run the following command: 

    gcloud init

  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the AlloyDB, Compute Engine, and Resource Manager APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  11. Install the Google Cloud CLI.

  12. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  13. To initialize the gcloud CLI, run the following command: 

    gcloud init
  14. Pastikan Anda memiliki peran Admin Cloud SQL dan Compute Viewer di akun pengguna.

    Buka halaman IAM

    Pelajari lebih lanjut tentang peran dan perizinan

Menyediakan instance Cloud SQL untuk PostgreSQL

  1. Buat instance PostgreSQL, dengan mengganti nilai berikut:

    • Database version: PostgreSQL 14
    • Pilih konfigurasi untuk memulai: Production
    • Pilih ketersediaan region dan zona: Pilih us-central1 sebagai region.
    • Zonal availability: Multiple zones (Highly Available)
      • Zona utama: us-central1-c
      • Zona sekunder: us-central-1-f
    • Jenis mesin: Mesin High Memory 16 vCPU, 104 GB. Ini adalah mesin terdekat yang ditawarkan Cloud SQL untuk PostgreSQL ke instance AlloyDB yang cocok yang Anda buat di bagian tolok ukur AlloyDB dalam dokumen ini.
    • Kapasitas penyimpanan: Kustom, 1.500 GB
      • Aktifkan peningkatan penyimpanan otomatis
    • Enkripsi: Google-owned and Google-managed encryption key
    • Connections: Private IP
      • Jaringan: default
      • IP Publik: Diaktifkan

  2. Klik Create instance.

  3. Setelah instance PostgreSQL dibuat, catat alamat IP Pribadi. Anda menggunakan IP sebagai PGHOST untuk membuat koneksi dengan benchmark.

Menyediakan mesin klien

  1. Menyediakan instance Cloud SQL untuk PostgreSQL. Untuk menjalankan benchmark OLTP pilihan Anda, Anda memerlukan mesin klien dengan daya CPU yang signifikan di zona yang sama dengan instance utama Cloud SQL untuk PostgreSQL di Cloud SQL.

  2. Opsional: Sebagai alternatif untuk langkah sebelumnya, Anda dapat menggunakan mesin klien yang sama dengan yang Anda siapkan untuk tolok ukur AlloyDB, asalkan hal berikut ini benar:

    • Mesin klien berada di zona yang sama dengan instance utama PostgreSQL (Cloud SQL untuk PostgreSQL) yang baru.
    • Mesin klien memenuhi persyaratan minimum CPU, RAM, dan ukuran disk.

    Dalam panduan tolok ukur ini, Anda menggunakan kembali mesin klien saat mesin tersebut ditempatkan di zona yang sama dengan instance utama, dan saat mesin tersebut cukup besar untuk membawa server ke kapasitas penuhnya.

  3. Jika Anda membuat mesin klien baru, siapkan mesin driver benchmark. Jika tidak, ikuti petunjuk dalam panduan ini untuk benchmark yang ingin Anda jalankan.

Langkah berikutnya