Halaman ini diterjemahkan oleh Cloud Translation API.

Menyiapkan cluster SQL Server di Linux dengan grup ketersediaan Always On dan Alat Pacemaker

Tutorial ini menjelaskan cara men-deploy sistem database Microsoft SQL Server di Linux menggunakan grup ketersediaan Selalu Aktif (AOAG) dan Pacemaker sebagai solusi ketersediaan tinggi (HA) dan pemulihan bencana (DR). Untuk tujuan dokumen ini, bencana adalah peristiwa ketika {i>database<i} utama gagal atau menjadi tidak tersedia.

Database utama dapat gagal jika ada region yang gagal atau tidak dapat diakses. Meskipun region tersedia dan beroperasi secara normal, database utama dapat gagal karena error sistem. Dalam kasus ini, pemulihan dari bencana (disaster recovery) adalah proses menyediakan database sekunder bagi klien untuk pemrosesan berkelanjutan.

Tutorial ini ditujukan untuk arsitek, administrator, dan engineer database.

Tujuan

Men-deploy SQL Server di Linux
Buat grup ketersediaan yang Selalu Aktif untuk ketersediaan tinggi dan pemulihan dari bencana
Instal dan konfigurasi Pacemaker untuk mengelola failover cluster SQL Server
Mengonfigurasi load balancer untuk merutekan traffic ke grup ketersediaan Anda dengan SQL Server
Menyiapkan fence STONITH (Shoot The Other Node In The Head) untuk memastikan integritas HA
Lakukan pengujian failover untuk memastikan cluster SQL Server berfungsi seperti yang diharapkan

Biaya

Tutorial ini menggunakan komponen Google Cloud yang dapat ditagih, termasuk:

Gunakan kalkulator harga untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan.

Sebelum memulai

Untuk tutorial ini, Anda memerlukan proyek Google Cloud. Anda dapat membuat yang baru, atau pilih project yang sudah Anda buat:

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Catatan: Jika tidak berencana untuk menyimpan resource yang Anda buat dalam prosedur ini, buatlah project, bukan memilih project yang ada. Setelah menyelesaikan langkah ini, Anda dapat menghapus project, yang menghapus semua resource yang terkait dengan project ini.

Buka pemilih project
Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.
Pastikan NetApp Cloud Volumes API diaktifkan untuk project Google Cloud Anda.
Di konsol Google Cloud, aktifkan Cloud Shell.

Aktifkan Cloud Shell

Menyiapkan project dan jaringan

Untuk menyiapkan VPC dan project Google Cloud Anda untuk deployment SQL Server Grup ketersediaan Selalu Aktif, lakukan tindakan berikut:

Di Konsol Google Cloud, buka Cloud Shell dengan mengklik Mengaktifkan Cloud Shell tombol.

Buka konsol Google Cloud.
Tetapkan project ID default Anda:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan ID project Google Cloud Anda.
Tetapkan region default Anda:
```
gcloud config set compute/region REGION
```
Ganti REGION dengan ID region tempat Anda ingin men-deploy.
Tetapkan zona default Anda:
```
gcloud config set compute/zone ZONE
```
Ganti ZONE dengan ID zona tempat Anda ingin men-deploy. Ini harus berupa zona yang valid di region yang ditentukan pada langkah sebelumnya.

Membuat VM Linux

Untuk mencapai HA dan kuorum untuk cluster SQL Server, deploy tiga virtual machine (VM) Linux untuk menghosting cluster SQL Server.

Lakukan inisialisasi variabel berikut:
```
PD_SIZE=30
MACHINE_TYPE=n2-standard-8
```

Buat VM Linux:

gcloud compute instances create node-1 \
--project=PROJECT_ID \
--zone REGION-a \
--machine-type $MACHINE_TYPE \
--subnet SUBNET_NAME \
--create-disk=auto-delete=yes,boot=yes,device-name=node-1,image=projects/ubuntu-os-cloud/global/images/ubuntu-2004-focal-v20240426,mode=rw,size=$PD_SIZE,type=projects/PROJECT_ID/zones/ZONE/diskTypes/pd-balanced \
--scopes=https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/trace.append,https://www.googleapis.com/auth/devstorage.read_write

gcloud compute instances create node-2 \
--project=PROJECT_ID \
--zone REGION-b \
--machine-type $MACHINE_TYPE \
--subnet SUBNET_NAME \
--create-disk=auto-delete=yes,boot=yes,device-name=node-2,image=projects/ubuntu-os-cloud/global/images/ubuntu-2004-focal-v20240426,mode=rw,size=$PD_SIZE,type=projects/PROJECT_ID/zones/ZONE/diskTypes/pd-balanced \
--scopes=https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/trace.append,https://www.googleapis.com/auth/devstorage.read_write

gcloud compute instances create node-3 \
--project=PROJECT_ID \
--zone REGION-c \
--machine-type $MACHINE_TYPE \
--subnet SUBNET_NAME \
--create-disk=auto-delete=yes,boot=yes,device-name=node-3,image=projects/ubuntu-os-cloud/global/images/ubuntu-2004-focal-v20240426,mode=rw,size=$PD_SIZE,type=projects/PROJECT_ID/zones/ZONE/diskTypes/pd-balanced \
--scopes=https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/trace.append,https://www.googleapis.com/auth/devstorage.read_write

Ganti subnet SUBNET_NAME dengan nama subnet VPC Anda.

Perbarui file hosts di node-1, node-2, dan node-3:

Catatan: Untuk penggunaan produksi, resolusi domain harus dikelola oleh server Domain Name System (DNS) khusus.
1. Hubungkan ke setiap VM Anda menggunakan SSH. Lihat dokumentasi Menghubungkan ke VM Linux untuk informasi selengkapnya.
2. Buka file hosts untuk diedit.
```
sudo vi /etc/hosts
```
3. Temukan alamat IP internal untuk setiap VM Linux dan tambahkan entri host ke bagian bawah file.
  
  Buka Compute Engine
```
NODE1_INTERNAL_IP node-1
NODE2_INTERNAL_IP node-2
NODE3_INTERNAL_IP node-3
```
  Ganti NODE1_INTERNAL_IP, NODE2_INTERNAL_IP, dan NODE3_INTERNAL_IP dengan alamat IP internal setiap VM Linux.
Periksa komunikasi antar-VM Anda. Semua VM yang berpartisipasi dalam grup ketersediaan Selalu Aktif harus dapat berkomunikasi dengan VM lain:
1. Kembali ke setiap VM Linux, jalankan perintah dari setiap VM, dan pastikan semua VM dapat berkomunikasi satu sama lain.
```
ping -c 4 node-1
ping -c 4 node-2
ping -c 4 node-3
```

Menginstal dan mengonfigurasi SQL Server

Download, instal, dan konfigurasikan mesin SQL Server di tiga VM Linux yang akan berpartisipasi dalam grup ketersediaan Always On.

Jalankan SSH ke node-1, node-2, dan node-3, lalu jalankan langkah-langkah berikut:

Impor kunci repositori publik.

wget -qO- https://packages.microsoft.com/keys/microsoft.asc \
| sudo tee /etc/apt/trusted.gpg.d/microsoft.asc

Mendaftarkan repositori Ubuntu SQL Server.

sudo add-apt-repository \
"$(wget -qO- https://packages.microsoft.com/config/ubuntu/20.04/mssql-server-2019.list)"

Perbarui file indeks paket dan instal SQL Server.

sudo apt-get update
sudo apt-get install -y mssql-server

Konfigurasi SQL Server:
1. Jalankan alat mssql-conf.
```
sudo /opt/mssql/bin/mssql-conf setup
```
2. Pilih edisi Developer untuk edisi SQL Server dan setujui perjanjian lisensi.
  
  Edisi developer menyertakan semua fitur perusahaan, tetapi Anda hanya dapat menggunakannya untuk lingkungan non-produksi. Tersedia informasi selengkapnya terkait edisi SQL Server dan lisensi Microsoft.
  
  Catatan: Untuk setiap instance VM, lisensi SQL Server diperlukan. Jika Anda menjalankan server aplikasi Microsoft, Mobilitas Lisensi melalui Software Assurance akan membantu Anda bertransisi ke Google Cloud. Untuk informasi selengkapnya, lihat Menggunakan Mobilitas Lisensi dengan aplikasi server Microsoft. Jika Anda tidak membawa lisensi sendiri dan perlu membeli lisensi melalui Google (PAYG), ikuti langkah-langkah dalam Menambahkan lisensi SQL Server ke boot disk untuk memastikan Anda membeli lisensi untuk setiap instance VM.
3. Tentukan sandi untuk akun SA.
4. Pastikan layanan mssql-server sudah berjalan.
```
systemctl status mssql-server --no-pager
```
Jika Anda mengaktifkan firewall di VM, buka firewall untuk SQL Server:
1. Periksa apakah Uncomplicated Firewall diinstal dan diaktifkan dengan menjalankan perintah berikut.
```
sudo ufw status
```
2. Jika statusnya aktif, jalankan perintah berikut untuk membuka port.
```
sudo ufw allow 1433
sudo ufw allow 5022
sudo ufw reload
```
  Catatan: Jika Anda menggunakan port lain untuk SQL Server atau untuk endpoint grup ketersediaan, ubah aturan firewall sesuai kebutuhan.

Menghubungkan ke SQL Server

Pada tahap ini, SQL Server telah diinstal. Untuk terhubung ke instance tersebut, buat mesin windows di VPC yang sama, instal SQL Server management Studio (SSMS) untuk terhubung ke instance SQL Server yang baru dibuat di VM Anda:

Buat VM Windows:

Kembali ke Cloud Shell Anda dan jalankan perintah berikut.

gcloud compute instances create node4 \
--project=PROJECT_ID \
--zone ZONE \
--subnet SUBNET_NAME \
--machine-type=n2-standard-4 \
--create-disk=auto-delete=yes,boot=yes,device-name=node4,image=projects/windows-cloud/global/images/windows-server-2022-dc-v20240415,mode=rw,size=50,type=projects/p3rf-sqlserver/zones/ZONE/diskTypes/pd-balanced

Hubungkan ke VM Windows di node-4 menggunakan Desktop Jarak Jauh:
Perbarui file hosts di node-4:
1. Buka notepad dalam mode administrator.
2. Klik File > Buka dan buka file hosts.
```
c:\Windows\System32\drivers\etc\hosts
```
3. Tambahkan entri host ke bagian bawah file.
```
NODE1_INTERNAL_IP node-1
NODE2_INTERNAL_IP node-2
NODE3_INTERNAL_IP node-3
```
  Ganti NODE1_INTERNAL_IP, NODE2_INTERNAL_IP, dan NODE3_INTERNAL_IP dengan alamat IP internal masing-masing VM.
4. Simpan dan keluar.
Verifikasi koneksi ke VM Linux:
1. Menghubungkan ke VM Windows di node-4
2. Klik tombol Mulai, lalu masukkan powershell ke kotak penelusuran.
3. Klik untuk membuka aplikasi Windows PowerShell ISE.
4. Menguji konektivitas dengan menjalankan perintah berikut.
```
ping node-1
ping node-2
ping node-3
```
Instal Microsoft SQL Server Management Studio (SSMS) dengan langkah-langkah berikut:
1. Hubungkan ke VM Windows di node-4 menggunakan Desktop Jarak Jauh.
2. Dalam sesi RDP, minimalkan semua jendela, lalu mulai aplikasi Windows PowerShell ISE.
3. Pada prompt PowerShell, download dan jalankan penginstal SSMS.
```
Start-BitsTransfer `
-Source "https://aka.ms/ssmsfullsetup" `
-Destination "$env:Temp\ssms-setup.exe"
& $env:Temp\ssms-setup.exe
```
4. Di penginstal SSMS, klik Instal.
5. Setujui prompt untuk mengizinkan perubahan.
6. Setelah penginstalan selesai, klik Mulai ulang untuk memulai ulang mesin jarak jauh. Tindakan ini akan menutup sesi RDP.
Hubungkan ke instance SQL Server pada node-1:
1. Kembali ke VM node-4 menggunakan RDP.
2. Buka SSMS dan hubungkan ke node-1 menggunakan parameter berikut.
```
Server name: node-1
Authentication: SQL Server Authentication
Login: sa
```
  Untuk mengetahui informasi selengkapnya, baca artikel menghubungkan ke instance SQL Server menggunakan dokumentasi Management Studio SQL Server.
3. Masukkan sandi untuk akun SA yang dibuat selama penginstalan.
4. Pilih Trust server certificate.
5. Klik Connect.

Aktifkan grup ketersediaan Selalu Aktif

Di Linux, Anda harus membuat grup ketersediaan terlebih dahulu sebelum dapat menambahkannya sebagai resource yang akan dikelola oleh Pacemaker:

Mengaktifkan fitur grup ketersediaan Selalu Aktif untuk setiap instance SQL Server yang berpartisipasi dalam grup ketersediaan. Jalankan perintah berikut di node-1, node-2, dan node-3:

Catatan: Mulai ulang layanan mssql-server agar perubahan diterapkan.
```
sudo /opt/mssql/bin/mssql-conf set hadr.hadrenabled 1
sudo systemctl restart mssql-server
```
Hubungkan ke instance yang merupakan host utama dalam grup ketersediaan menggunakan SSMS:

Tips: Sebaiknya pilih node-1 sebagai host utama.
1. Buka jendela kueri baru.
2. Jalankan cuplikan kode berikut untuk membuat kunci enkripsi, sertifikat, dan kunci pribadi.
  
  Tips: Pilih sandi yang kuat untuk kunci enkripsi dan kunci pribadi. Ingat sandi ini karena Anda akan menggunakannya nanti.
  Catatan: Panjang sandi minimal 8 karakter dan berisi karakter dari tiga dari empat kumpulan berikut: huruf besar, huruf kecil, basis 10 digit, dan simbol.
```
USE MASTER;

CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'ENCRYPTION_KEY_PASSWORD';
CREATE CERTIFICATE my_ag_certificate WITH SUBJECT = 'my_ag_cert';
BACKUP CERTIFICATE my_ag_certificate
TO FILE = '/var/opt/mssql/data/my_ag_certificate.cer'
WITH PRIVATE KEY (
    FILE = '/var/opt/mssql/data/my_ag_certificate.pvk',
    ENCRYPTION BY PASSWORD = 'PRIVATE_KEY_PASSWORD'
);
```
  Ganti ENCRYPTION_KEY_PASSWORD dan PRIVATE_KEY_PASSWORD dengan sandi untuk kunci enkripsi dan kunci pribadi.

Mentransfer file sertifikat dan kunci

File sertifikat dan kunci yang dibuat pada langkah sebelumnya harus dipindahkan ke node sekunder SQL Server. Ada beberapa metode untuk memindahkan sertifikat dan file kunci ke node sekunder di node-2 dan node-3.

Untuk opsi transfer lainnya, lihat Mentransfer file ke VM Linux

Mentransfer sertifikat dan file kunci menggunakan Cloud Storage

Membuat Cloud Storage untuk mentransfer file dari node cluster utama ke sekunder.

Membuat bucket Cloud Storage:
1. Kembali ke Cloud Shell, jalankan perintah berikut:
```
gcloud storage buckets create gs://BUCKET_NAME \
--project=PROJECT_ID \
--location=REGION \
--public-access-prevention
```
  Ganti BUCKET_NAME dengan nama bucket yang akan dibuat. Ganti PROJECT_ID dengan ID project Google Cloud Anda dan ganti REGION dengan ID region tempat Anda ingin bucket di-deploy.
Untuk informasi selengkapnya, lihat Membuat Bucket.
Kembali ke SSh di node-1, node-2, dan node-3 untuk menginisialisasi Google Cloud CLI:
1. Jalankan perintah berikut untuk menginisialisasi Google Cloud CLI.
```
gcloud init
```
2. Pilih option [1] untuk menggunakan akun layanan yang telah diinstal sebelumnya.
3. Masukkan nama project Anda.
4. Masukkan n ke pertanyaan untuk menyiapkan Region dan Zona default.
Kembali ke node-1 untuk menyalin file ke Cloud Storage:
1. Upload dua file yang baru dibuat ke Cloud Storage Anda dengan membatalkan perintah berikut.
```
sudo gcloud storage cp /var/opt/mssql/data/my_ag_certificate.cer gs://BUCKET_NAME/
sudo gcloud storage cp /var/opt/mssql/data/my_ag_certificate.pvk gs://BUCKET_NAME/
```
  Ganti BUCKET_NAME dengan nama bucket yang dibuat.
Kembali ke node-2 dan node-3 untuk menyalin file dari Cloud Storage:
1. Download kedua file tersebut dari Cloud Storage Anda ke node-2.
```
sudo gcloud storage cp gs://BUCKET_NAME/my_ag_certificate.cer /var/opt/mssql/data/
sudo gcloud storage cp gs://BUCKET_NAME/my_ag_certificate.pvk /var/opt/mssql/data/
```
  Ganti BUCKET_NAME dengan nama bucket yang dibuat.
2. Ubah kepemilikan file di node-2 dan node-3 dengan menjalankan perintah di shell root.
```
chown mssql:mssql /var/opt/mssql/data/my_ag_certificate.*
chmod 660 /var/opt/mssql/data/my_ag_certificate.*
```
  Tips: Jangan lupa untuk keluar dari shell root setelah menjalankan perintah.

Siapkan endpoint pencerminan database

Di bagian ini, Anda akan membuat endpoint database menggunakan kunci enkripsi dan sertifikat yang dibagikan oleh setiap node di cluster SQL Server untuk memastikan replikasi data yang aman.

Kembali ke VM Windows di node-4 untuk membuat endpoint pencerminan database:
1. Menghubungkan ke database SQL Server di node-1, node-2, dan node-3 menggunakan SSMS. Ikuti langkah-langkah dari Menghubungkan ke SQL Server menggunakan node-1, node-2, dan node-3 sebagai nama Server dan masing-masing sandi yang Anda tetapkan untuk akun SA.
2. Buat sertifikat di VM sekunder node-2 dan node-3 dari file yang disalin. Gunakan sandi yang Anda berikan saat membuat sertifikat dan kunci di node utama.
```
USE MASTER;

CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'ENCRYPTION_KEY_PASSWORD';
CREATE CERTIFICATE my_ag_certificate
FROM FILE = '/var/opt/mssql/data/my_ag_certificate.cer'
WITH PRIVATE KEY (
    FILE = '/var/opt/mssql/data/my_ag_certificate.pvk',
    DECRYPTION BY PASSWORD = 'PRIVATE_KEY_PASSWORD'
);
```
  Ganti ENCRYPTION_KEY_PASSWORD dan PRIVATE_KEY_PASSWORD dengan sandi untuk kunci enkripsi dan kunci pribadi.
3. Kembali ke SSMS untuk membuat endpoint pencerminan database dengan menjalankan perintah T-SQL untuk node-1, node-2, dan node-3.
  
  Tips: Port pemrosesan default adalah 5022, tetapi Anda dapat menggunakan port lain yang tersedia.
```
CREATE ENDPOINT [my_ag_endpoint]
    AS TCP (LISTENER_PORT = 5022)
    FOR DATABASE_MIRRORING (
        ROLE = ALL,
        AUTHENTICATION = CERTIFICATE my_ag_certificate,
        ENCRYPTION = REQUIRED ALGORITHM AES
    );

ALTER ENDPOINT [my_ag_endpoint] STATE = STARTED;
```

Membuat dan mengonfigurasi grup ketersediaan Always On

Selanjutnya, buat grup ketersediaan SQL Server Always On menggunakan SQL Server Management Studio dan gunakan endpoint yang dibuat sebelumnya untuk replikasi.

Kembali ke VM Windows dan buka SSMS:
1. Hubungkan ke mesin database SQL Server di node-1 dan buka jendela kueri baru.

Buat database dan cadangkan database sebagai persiapan untuk replikasi:

USE MASTER;

CREATE DATABASE [bookshelf];
ALTER DATABASE [bookshelf] SET RECOVERY FULL;
BACKUP DATABASE [bookshelf]
TO DISK = N'/var/opt/mssql/data/bookshelf.bak';

Buat grup ketersediaan Always On:

Jalankan perintah T-SQL berikut di SSMS pada node-1, node-2, dan node-3. Tindakan ini akan memastikan endpoint telah diaktifkan dan SQL Server di setiap node siap untuk replikasi data.

IF (SELECT state FROM sys.endpoints WHERE name = N'my_ag_endpoint') <> 0
BEGIN
    ALTER ENDPOINT [my_ag_endpoint] STATE = STARTED
END
GO

IF EXISTS(SELECT * FROM sys.server_event_sessions WHERE name='AlwaysOn_health')
BEGIN
    ALTER EVENT SESSION [AlwaysOn_health] ON SERVER WITH (STARTUP_STATE=ON);
END
IF NOT EXISTS(SELECT * FROM sys.dm_xe_sessions WHERE name='AlwaysOn_health')
BEGIN
    ALTER EVENT SESSION [AlwaysOn_health] ON SERVER STATE=START;
END
GO

Jalankan perintah T-SQL berikut di node-1 untuk membuat AOAG.

USE [master]
GO

CREATE AVAILABILITY GROUP [aoag1]
WITH (
    AUTOMATED_BACKUP_PREFERENCE = SECONDARY,
    DB_FAILOVER = OFF,
    DTC_SUPPORT = NONE,
    CLUSTER_TYPE = EXTERNAL,
    REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 0
)
FOR DATABASE [bookshelf]
REPLICA ON N'node-1' WITH (
    ENDPOINT_URL = N'TCP://node-1:5022', FAILOVER_MODE = EXTERNAL, AVAILABILITY_MODE = SYNCHRONOUS_COMMIT, BACKUP_PRIORITY = 50, SEEDING_MODE = AUTOMATIC, SECONDARY_ROLE(ALLOW_CONNECTIONS = NO)),
    N'node-2' WITH (ENDPOINT_URL = N'TCP://node-2:5022', FAILOVER_MODE = EXTERNAL, AVAILABILITY_MODE = SYNCHRONOUS_COMMIT, BACKUP_PRIORITY = 50, SEEDING_MODE = AUTOMATIC, SECONDARY_ROLE(ALLOW_CONNECTIONS = NO)),
    N'node-3' WITH (ENDPOINT_URL = N'TCP://node-3:5022', FAILOVER_MODE = EXTERNAL, AVAILABILITY_MODE = SYNCHRONOUS_COMMIT, BACKUP_PRIORITY = 50, SEEDING_MODE = AUTOMATIC, SECONDARY_ROLE(ALLOW_CONNECTIONS = NO)
);
GO

Jalankan perintah T-SQL berikut di node-2 dan node-3 untuk setiap instance SQL Server agar bergabung ke grup ketersediaan baru.

ALTER AVAILABILITY GROUP [aoag1] JOIN WITH (CLUSTER_TYPE = EXTERNAL);
GO

ALTER AVAILABILITY GROUP [aoag1] GRANT CREATE ANY DATABASE;
GO

Anda telah membuat database baru bernama bookshelf dan menambahkan database baru ke grup ketersediaan baru bernama aoag1 di instance SQL Server yang berjalan di node-1. Node-2 dan node-3 ditambahkan ke grup ketersediaan dan data di database bookshelf akan direplikasi secara sinkron di seluruh instance SQL Server di ketiga node.

Menginstal dan mengonfigurasi Pacemaker

Pacemaker adalah software pengelola resource ketersediaan tinggi open source, yang digunakan dengan mesin Cluster Corosync. Di bagian ini, Anda akan menginstal dan mengonfigurasi Pacemaker di setiap VM.

Membuat login SQL Server untuk pengelola cluster pacemaker

Di bagian ini, Anda akan membuat akun SQL Server baru untuk Pacemaker yang akan digunakan untuk login ke setiap instance SQL Server dan mengelola grup ketersediaan.

Jalankan perintah T-SQL berikut di node-1, node-2, dan node-3:
```
USE [master];

CREATE LOGIN [pacemaker] with PASSWORD= N'PACEMAKER_LOGIN_PASSWORD';
GO
```
Ganti PACEMAKER_LOGIN_PASSWORD dengan sandi untuk akun pacemaker.

Jalankan perintah T-SQL untuk memberikan izin login alat pacu jantung ke grup ketersediaan:

GRANT ALTER, CONTROL, VIEW DEFINITION ON AVAILABILITY GROUP::[aoag1] TO [pacemaker];
GRANT VIEW SERVER STATE TO [pacemaker];
GO

Kembali ke SSH di node-1, node-2, dan node-3 untuk menjalankan perintah guna menyimpan login dan sandi Pacemaker di folder secret SQL Server:

echo 'pacemaker' >> ~/pacemaker-passwd
echo 'PACEMAKER_LOGIN_PASSWORD' >> ~/pacemaker-passwd
sudo mv ~/pacemaker-passwd /var/opt/mssql/secrets/passwd
sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Ganti PACEMAKER_LOGIN_PASSWORD dengan sandi untuk akun alat pacu jantung.

Instal Pacemaker

Selanjutnya, instal Pacemaker dan siapkan akun login di semua VM Linux untuk pengelolaan resource.

Membuka port firewall untuk alat pacu jantung:
1. Periksa apakah Uncomplicated Firewall diinstal dan diaktifkan dengan menjalankan perintah berikut di node-1, node-2, dan node-3.
```
sudo ufw status
```
2. Jika ufw diaktifkan, buka port firewall di node-1, node-2, dan node-3.
```
sudo ufw allow 2224/tcp
sudo ufw allow 3121/tcp
sudo ufw allow 5405/udp
sudo ufw allow 21064/tcp
sudo ufw allow 1433/tcp
sudo ufw allow 5022/tcp
sudo ufw reload
```
  Catatan: Jika Anda menggunakan port lain untuk SQL Server atau untuk endpoint grup ketersediaan, ubah aturan firewall sesuai kebutuhan

Instal Pacemaker di node-1, node-2, dan node-3:

sudo apt-get install -y pacemaker pacemaker-cli-utils crmsh resource-agents  fence-agents corosync python3-azure pcs

Setel sandi baru untuk pengguna hacluster di node-1, node-2, dan node-3:

Catatan: Setel sandi yang sama di ketiga node. Sandi ini akan diperlukan selama proses penyiapan.
```
sudo passwd hacluster
```

Menyiapkan Corosync

Sekarang Anda akan mengonfigurasi Corosync untuk mengelola keanggotaan dan pesan cluster di seluruh cluster.

Buat kunci autentikasi untuk Corosync di node-1:
```
sudo corosync-keygen
```

Ubah file konfigurasi Corosync:

Kembali ke node-1 dan ubah file corosync.conf.
```
sudo vi /etc/corosync/corosync.conf
```

Perbarui bagian yang ditandai. Setelah mengedit, file akan terlihat seperti contoh berikut.

# Please read the corosync.conf.5 manual page
totem {
    version: 2

    # Corosync itself works without a cluster name, but DLM needs one.
    # The cluster name is also written into the VG metadata of newly
    # created shared LVM volume groups, if lvmlockd uses DLM locking.
    cluster_name: my_agcluster

    # crypto_cipher and crypto_hash: Used for mutual node authentication.
    # If you choose to enable this, then do remember to create a shared
    # secret with "corosync-keygen".
    # enabling crypto_cipher, requires also enabling of crypto_hash.
    # crypto works only with knet transport
    transport: udpu
    crypto_cipher: none
    crypto_hash: none
}

logging {
    # Log the source file and line where messages are being
    # generated. When in doubt, leave off. Potentially useful for
    # debugging.
    fileline: off
    # Log to standard error. When in doubt, set to yes. Useful when
    # running in the foreground (when invoking "corosync -f")
    to_stderr: yes
    # Log to a log file. When set to "no", the "logfile" option
    # must not be set.
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
    # Log to the system log daemon. When in doubt, set to yes.
    to_syslog: yes
    # Log debug messages (very verbose). When in doubt, leave off.
    debug: off
    # Log messages with time stamps. When in doubt, set to hires (or on)
    #timestamp: hires
    logger_subsys {
        subsys: QUORUM
        debug: off
    }
}
quorum {
    # Enable and configure quorum subsystem (default: off)
    # see also corosync.conf.5 and votequorum.5
    provider: corosync_votequorum
}
nodelist {
    # Change/uncomment/add node sections to match cluster configuration

    node {
        # Hostname of the node
        name: node-1
        # Cluster membership node identifier
        nodeid: 1
        # Address of first link
        ring0_addr: NODE1_INTERNAL_IP
        # When knet transport is used it's possible to define up to 8 links
        #ring1_addr: 192.168.1.1
    }
    node {
        name: node-2
        nodeid: 2
        ring0_addr: NODE2_INTERNAL_IP
    }
    node {
        name: node-3
        nodeid: 3
        ring0_addr: NODE3_INTERNAL_IP
    }
    # ...
}

Ganti NODE1_INTERNAL_IP, NODE2_INTERNAL_IP, dan NODE3_INTERNAL_IP dengan alamat IP internal setiap node.

Mentransfer file konfigurasi menggunakan Cloud Storage

Upload kunci autentikasi dan file konfigurasi corosync yang dihasilkan dari node-1 ke bucket Cloud Storage Anda:
```
sudo gcloud storage cp /etc/corosync/authkey gs://BUCKET_NAME/
sudo gcloud storage cp  /etc/corosync/corosync.conf gs://BUCKET_NAME/
```
Ganti BUCKET_NAME dengan nama bucket yang dibuat sebelumnya.
Download Authkey dan file konfigurasi untuk node-2 dan node-3:
```
sudo gcloud storage cp gs://BUCKET_NAME/authkey /etc/corosync/
sudo gcloud storage cp gs://BUCKET_NAME/corosync.conf /etc/corosync/
```
Ganti BUCKET_NAME dengan nama bucket tempat file konfigurasi Corosync ditransfer.

Perbarui izin file di node-2 dan node-3:

sudo chmod 400 /etc/corosync/authkey
sudo chmod 400 /etc/corosync/corosync.conf

Memulai ulang dan memverifikasi Komunikasi cluster

Mulai ulang layanan Pacemaker dan Corosync di node-1, node-2, dan node-3:
```
sudo systemctl restart pacemaker corosync
```
Konfirmasi status cluster dengan menjalankan perintah pada node-1:
```
sudo crm status
```
Anda akan melihat ketiga node secara online.

Menyiapkan Cluster

Selanjutnya, Anda akan menyiapkan cluster Pacemaker dengan membuat resource baru untuk grup ketersediaan SQL Server Always On.

Jalankan perintah berikut di node-1 untuk menetapkan properti Cluster:

sudo crm configure property stonith-enabled=false
sudo crm configure property cluster-recheck-interval=2min
sudo crm configure property start-failure-is-fatal=true

Untuk mengetahui informasi selengkapnya, lihat Opsi Cluster.

Izinkan node di cluster dengan menjalankan perintah pada node-1. Gunakan sandi yang ditetapkan sebelumnya untuk akun hacluster:
```
sudo pcs cluster auth -u hacluster
```
Anda akan melihat ketiga node telah diberi otorisasi.
Instal agen resource SQL Server untuk integrasi dengan Pacemaker di node-1, node-2, dan node-3:
```
sudo apt-get install mssql-server-ha
```
Kembali ke node-1 dan buat resource grup ketersediaan di cluster:
1. Jalankan Cluster Resource Manager.
```
sudo crm
```
2. Ketikkan configure untuk masuk ke menu konfigurasi.
3. Masukkan konfigurasi berikut.
```
primitive aoag1-cluster \
ocf:mssql:ag \
params ag_name="aoag1" \
meta failure-timeout=60s \
op start timeout=60s \
op stop timeout=60s \
op promote timeout=60s \
op demote timeout=10s \
op monitor timeout=60s interval=10s \
op monitor timeout=60s on-fail=demote interval=11s role="Master" \
op monitor timeout=60s interval=12s role="Slave" \
op notify timeout=60s
ms ms-ag1 aoag1-cluster \
meta master-max="1" master-node-max="1" clone-max="3" \
clone-node-max="1" notify="true"
```
4. Ketikkan commit untuk melakukan commit untuk perubahan.
  
  Catatan: Anda akan menerima peringatan bahwa tidak ada aturan pagar yang disiapkan. Abaikan pesan ini, aturan pagar akan disiapkan di langkah berikutnya.
5. Ketik exit untuk keluar dari Resource manager Cluster.
6. Verifikasi konfigurasi.
```
sudo crm status
```
  Anda akan melihat bahwa node-1 telah dipromosikan ke node utama. Node-2 dan node-3 harus ditetapkan sebagai node sekunder.

Menyiapkan load balancer dan pemroses Grup Ketersediaan

Di bagian ini, Anda akan membuat alamat IP virtual dan resource health check di cluster menggunakan load balancer TCP passthrough internal yang merutekan traffic ke grup ketersediaan.

Kembali ke Cloud Shell dan pesan alamat IP statis yang akan Anda gunakan sebagai IP cluster:

gcloud compute addresses create aoag1-cluster \
--region REGION \
--subnet SUBNET_NAME
CLUSTER_ADDRESS=$(gcloud compute addresses describe aoag1-cluster \
--region $(gcloud config get-value compute/region) \
--format=value\(address\)) && \
echo "Cluster IP address: $CLUSTER_ADDRESS"

Ganti REGION dan SUBNET_NAME dengan region dan subnet tempat VM Linux di-deploy.

Buat grup instance yang tidak dikelola untuk setiap node cluster dan tetapkan ke grup instance yang baru dibuat. Jalankan perintah berikut di Cloud Shell:

gcloud compute instance-groups unmanaged create node-1-uig \
--zone=REGION-a
gcloud compute instance-groups unmanaged add-instances node-1-uig \
--zone=REGION-a \
--instances=node-1

gcloud compute instance-groups unmanaged create node-2-uig \
--zone=REGION-b
gcloud compute instance-groups unmanaged add-instances node-2-uig \
--zone=REGION-b \
--instances=node-2

gcloud compute instance-groups unmanaged create node-3-uig \
--zone=REGION-c
gcloud compute instance-groups unmanaged add-instances node-3-uig \
--zone=REGION-c \
--instances=node-3

Ganti REGION dengan region tempat VM Linux di-deploy.

Membuat health check TCP. Load balancer menggunakan health check untuk menentukan backend instance yang merespons traffic dengan benar.
```
gcloud compute health-checks create tcp aoag1-healthcheck \
--port=HEALTH_CHECK_PORT --proxy-header=NONE \
--check-interval=10 --timeout=10 --unhealthy-threshold=2 \
--healthy-threshold=2
```
Pilih dan ganti HEALTH_CHECK_PORT dengan nilai port yang bebas dan berada dalam rentang pribadi 49152-65535. Misalnya, 60000.

Untuk mengetahui informasi selengkapnya, baca ringkasan health check.

Tambahkan tag jaringan ke node cluster Anda. Tag jaringan digunakan oleh aturan firewall untuk health check:

gcloud compute instances add-tags node-1 \
--tags NETWORK_TAG_NAME \
--zone REGION-a
gcloud compute instances add-tags node-2 \
--tags NETWORK_TAG_NAME \
--zone REGION-b
gcloud compute instances add-tags node-3 \
--tags NETWORK_TAG_NAME \
--zone REGION-c

Ganti NETWORK_TAG_NAME dengan nama untuk tag jaringan.

Buat aturan firewall untuk mengizinkan health check menjangkau node cluster berdasarkan nama tag:

gcloud compute firewall-rules create mssql-aoag1-fw-rule \
--network VPC_NAME \
--action ALLOW \
--direction INGRESS \
--source-ranges 35.191.0.0/16,130.211.0.0/22 \
--target-tags NETWORK_TAG_NAME \
--rules tcp:HEALTH_CHECK_PORT

Untuk mengetahui informasi selengkapnya, lihat Aturan firewall untuk health check.

Buat layanan backend load balancer:

gcloud compute backend-services create aoag1-backend \
--load-balancing-scheme internal \
--health-checks aoag1-healthcheck \
--no-connection-drain-on-failover \
--drop-traffic-if-unhealthy \
--failover-ratio 1.0 \
--region REGION \
--global-health-checks

Tambahkan tiga grup instance yang tidak dikelola ke layanan backend:

gcloud compute backend-services add-backend aoag1-backend \
--instance-group node-1-uig \
--instance-group-zone REGION-a \
--region REGION

gcloud compute backend-services add-backend aoag1-backend \
--instance-group node-2-uig \
--instance-group-zone REGION-b \
--failover \
--region REGION

gcloud compute backend-services add-backend aoag1-backend \
--instance-group node-3-uig \
--instance-group-zone REGION-c \
--failover \
--region REGION

Tentukan aturan penerusan untuk load balancer. Aturan penerusan menentukan protokol dan port tempat load balancer menerima traffic:
```
gcloud compute forwarding-rules create aoag1-fwd-rule \
--load-balancing-scheme internal \
--address CLUSTER_ADDRESS \
--subnet SUBNET_NAME \
--region REGION \
--backend-service aoag1-backend \
--ports ALL
```
Ganti CLUSTER_ADDRESS dengan alamat IP yang dicadangkan sebelumnya.

Tips: Jika ingin cluster dapat diakses oleh klien di region jaringan VPC atau jaringan yang terhubung, Anda perlu menyertakan --allow-global-access dalam definisi aturan penerusan.

Untuk mengetahui informasi selengkapnya, lihat Aturan penerusan
Untuk menyelesaikan penyiapan dan menguji apakah load balancer jaringan Anda disiapkan dengan benar, instal dan konfigurasikan HAProxy tcp listener di node-1, node-2, dan node-3:
1. Instal HAProxy.
```
sudo apt-get install haproxy
```
2. Pilih Y untuk menyelesaikan penginstalan.
3. Edit file haproxy.cfg.
```
sudo vi /etc/haproxy/haproxy.cfg
```
4. Di bagian default pada haproxy.cfg file, ubah mode menjadi tcp.
5. Tambahkan bagian berikut di akhir file haproxy.cfg
```
#---------------------------------------------------------------
# Set up health check listener for SQL Server Availability Group
#---------------------------------------------------------------
listen healthcheck
bind *:HEALTH_CHECK_PORT
```
  Ganti HEALTH_CHECK_PORT dengan port health check yang dipilih sebelumnya. Misalnya, 6000.
6. Mulai layanan untuk mengonfirmasi bahwa konfigurasinya sudah benar:
```
sudo systemctl start haproxy.service
sudo systemctl enable haproxy.service
sudo systemctl restart haproxy.service
```
7. Buka halaman Load balancing, lalu klik load balancer Anda. Amati tiga grup instance tidak terkelola Anda, grup tersebut sekarang akan melaporkan kondisinya sebagai responsif.
  
  Buka Load balancing
  - Atau, Anda dapat menjalankan perintah berikut di Cloud Shell untuk melihat status layanan backend.
```
gcloud compute backend-services get-health aoag1-backend \
--region REGION
```
    Ganti REGION dengan region tempat VM Linux di-deploy.
8. Setelah ketiga grup instance yang tidak dikelola memiliki pelaporan yang baik, lanjutkan ke langkah berikutnya.
  
  Catatan: Jika grup instance yang tidak dikelola tidak melaporkan responsif, Anda mungkin perlu memulai ulang haproxy.service dari node yang dimaksud.
```
sudo systemctl restart haproxy.service
```
Buat resource health check di Pacemaker:
1. Jalankan SSH ke node-1 dan buat resource health check untuk layanan HAProxy di cluster alat pacu jantung Anda:
```
sudo pcs resource create aoag1-healthcheck \
service:haproxy \
op monitor interval=10s timeout=20s
```
2. Pastikan resource kesehatan dimulai pada node utama node-1:
```
sudo crm status
```
3. Jika resource health check tidak dimulai di node utama, pindahkan dengan perintah berikut:
```
sudo pcs resource move aoag1-healthcheck node-1
sudo pcs resource clear aoag1-healthcheck
```
  Anda akan melihat bahwa health check untuk load balancer hanya akan sehat untuk node-1.
  
  Buka Load balancing
Buat resource alamat IP virtual di cluster Pacemaker Anda:
1. Kembali ke SSH di node-1, lalu cari nama antarmuka jaringan node Anda. Anda akan membutuhkannya di langkah berikutnya.
```
ip -c link
```
2. Buat resource alamat IP virtual.
```
sudo pcs resource create aoag1-vip ocf:heartbeat:IPaddr2 \
ip="CLUSTER_ADDRESS" nic=NIC_NAME cidr_netmask=32 \
op monitor interval=3600s timeout=60s
```
  Ganti NIC_NAME dengan nama antarmuka jaringan dari langkah sebelumnya dan CLUSTER_ADDRESS dengan alamat IP yang dicadangkan.
3. Pastikan resource alamat IP virtual dimulai di host utama.
```
sudo crm status
```
4. Jika resource alamat IP virtual tidak dimulai pada node utama, pindahkan resource tersebut dengan perintah berikut.
```
sudo pcs resource move aoag1-vip node-1
```
5. Kelompokkan resource health check dan alamat IP virtual bersama-sama.
```
sudo pcs resource group add aoag1-group \
aoag1-healthcheck aoag1-vip
```
6. Buat batasan yang menemukan grup baru pada node yang sama dengan node utama.
```
sudo pcs constraint colocation add master aoag1-group with master ms-ag1 score=INFINITY
```

Membuat pemroses untuk grup ketersediaan SQL Server Anda

Koneksi ke SQL Server dengan grup ketersediaan harus menggunakan nama pemroses grup ketersediaan, bukan nama server. Jika terjadi failover, pemroses akan secara otomatis mengalihkan koneksi ke node utama baru di cluster.

Kembali ke SSMS dan hubungkan ke database node-1.

Jalankan kueri berikut:

ALTER AVAILABILITY GROUP aoag1
ADD LISTENER 'aoag1-listener' (
    WITH IP (('CLUSTER_ADDRESS','255.255.255.0')), PORT=1433
);
GO

Ganti CLUSTER_ADDRESS dengan alamat IP yang dicadangkan.

Siapkan pagar STONITH

STONITH adalah strategi pagar untuk menjaga integritas node dalam cluster HA. Layanan STONITH berfungsi di level node dan melindungi cluster dari node yang tidak responsif atau dalam status tidak diketahui. Sebaiknya gunakan perangkat pembatasan fence_gce yang dikhususkan untuk Compute Engine di Google Cloud.

Menyiapkan perangkat pagar

Periksa apakah agen fence_gce - Fence untuk Compute Engine diinstal di node1:
```
sudo pcs stonith list | grep fence_gce
```
Untuk informasi selengkapnya, lihat:
- Agen pagar untuk Google Compute Engine.
- Untuk melihat parameter yang terkait dengan operasi agen.
```
sudo pcs stonith describe fence_gce
```

Pada node-1, buat resource jenis pagar fence_gce untuk setiap node yang berpartisipasi:

sudo pcs stonith create node-1-fence fence_gce \
plug=node-1 \
zone=REGION-a \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

sudo pcs stonith create node-2-fence fence_gce \
plug=node-2 \
zone=REGION-b \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

sudo pcs stonith create node-3-fence fence_gce \
plug=node-3 \
zone=REGION-c \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

Ganti REGION dengan region tempat VM Linux di-deploy dan ganti PROJECT_ID dengan project ID Anda.

Anda dapat menguji status agen pagar dengan menjalankan perintah status:

sudo fence_gce -o status -n node-1 --zone=REGION-a
sudo fence_gce -o status -n node-2 --zone=REGION-b
sudo fence_gce -o status -n node-3 --zone=REGION-c

Buat batasan lokasi untuk perangkat pagar Anda guna memastikan bahwa perangkat tersebut hanya berjalan pada instance yang dimaksud:

sudo pcs constraint location node-1-fence avoids node-1
sudo pcs constraint location node-2-fence avoids node-2
sudo pcs constraint location node-3-fence avoids node-3

Aktifkan pagar di cluster alat pacu jantung dan setel waktu tunggu pagar cluster:

sudo pcs -f stonith_cfg property set stonith-enabled=true
sudo pcs property set stonith-timeout="300s"

Periksa status cluster:
```
sudo crm status
```

Menguji perangkat pagar

Setelah menyiapkan perangkat pagar, sebaiknya Anda mengujinya menggunakan langkah-langkah berikut.

Menghentikan fence di node-2:
1. Hubungkan ke node-1 dan jalankan perintah berikut untuk menguji perangkat pagar yang terkait dengan node-2 dari cluster Anda.
```
fence_gce -o off -n node-2 --zone=REGION-b
```
2. Periksa status cluster.
```
sudo crm status
```
3. Anda juga akan melihat bahwa node-2 dinonaktifkan di Compute Engine.
  
  Buka Compute Engine
Mulai ulang fence pada node-2:
1. Kembali ke node-1, lalu mulai ulang instance ini dengan menjalankan perintah berikut.
```
fence_gce -o on -n node-2 --zone=REGION-b
```
2. Periksa status cluster di Pacemaker dan Compute Engine. Setelah beberapa saat, Anda akan melihat bahwa node-2 kembali online.
```
sudo crm status
```

Mengonfigurasi Corosync untuk mulai ulang yang tertunda

Untuk menghindari masalah pengaturan waktu dan memastikan urutan operasi yang benar yang dilakukan jika ada tindakan pagar, sebaiknya tunda mulai ulang layanan Corosync selama 60 detik.

Untuk mengetahui informasi selengkapnya, lihat artikel pusat informasi Red Hat.

Buat file drop-in sistem yang menetapkan penundaan waktu mulai layanan Corosync di node-1, node-2, dan node-3:
1. Buka corosync.service untuk mengedit.
```
sudo systemctl edit corosync.service
```
2. Tambahkan baris berikut, simpan file, lalu keluar dari editor.
```
[Service]
ExecStartPre=/bin/sleep 60
```
3. Muat ulang pengelola layanan dan periksa apakah konfigurasi dipertimbangkan.
```
sudo systemctl daemon-reload
systemctl status corosync.service --no-pager
```
  Jika Anda melihat bagian Mampir, berarti setelan di file {i>drop-in<i} Anda berhasil dipertimbangkan

Menguji failover

Sekarang Anda siap menguji apakah failover berfungsi seperti yang diharapkan.

Hubungkan ke VM Windows di node-4 melalui Desktop Jarak Jauh:
Buka sesi PowerShell:

Jalankan skrip berikut:

while ($True){
  $Conn = New-Object System.Data.SqlClient.SqlConnection
  $Conn.ConnectionString = "Server=CLUSTER_ADDRESS;User ID=sa;Password=SA_PASSWORD;Initial Catalog=master"
  $Conn.Open()

  $Cmd = New-Object System.Data.SqlClient.SqlCommand
  $Cmd.Connection = $Conn
  $Cmd.CommandText = "SELECT @@SERVERNAME"

  $Adapter = New-Object System.Data.SqlClient.SqlDataAdapter $Cmd
  $Data = New-Object System.Data.DataSet
  $Adapter.Fill($Data) | Out-Null
  $Data.Tables[0] + (Get-Date -Format "MM/dd/yyyy HH:mm:ss")

  Start-Sleep -Seconds 2
}

Ganti CLUSTER_ADDRESS dengan alamat IP pemroses dan SA_PASSWORD dengan sandi akun SA di SQL Server.

Setiap 2 detik, skrip akan terhubung ke SQL Server menggunakan pemroses grup ketersediaan atau pemroses DNN, dan mengkueri nama server.

Biarkan skrip berjalan.

Kembali ke SSH di node-1 dan jalankan perintah untuk memicu failover ke node-2:

sudo pcs resource move ms-ag1 node-2 --master
sudo pcs resource move aoag1-group  node-2
sudo pcs resource move aoag1-vip node-2

Kembali ke sesi PowerShell di node-4:
1. Amati output skrip yang berjalan dan perhatikan bahwa nama server berubah dari node-1 menjadi node-2 sebagai akibat dari failover.

Kembali ke node-1 dan mulai failover ke node-1:

sudo pcs resource move ms-ag1 node-1 --master
sudo pcs resource move aoag1-group  node-1
sudo pcs resource move aoag1-vip node-1

Kembali ke Powershell di node-4 dan hentikan skrip dengan menekan Ctrl+C.

Pembersihan

Setelah menyelesaikan tutorial, Anda dapat membersihkan resource yang dibuat agar resource tersebut berhenti menggunakan kuota dan dikenai biaya. Bagian berikut menjelaskan cara menghapus atau menonaktifkan resource ini.

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

Untuk menghapus project:

Perhatian: Menghapus project memiliki efek berikut:

Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.