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 Always On (AOAG) dan Alat Pacemaker sebagai solusi ketersediaan tinggi (HA) dan pemulihan dari bencana (DR). Untuk tujuan dokumen ini, bencana adalah peristiwa ketika {i>database<i} utama gagal atau menjadi tidak tersedia.

Database utama dapat mengalami kegagalan jika region tempat database berada gagal atau tidak dapat diakses. Meskipun suatu region tersedia dan beroperasi secara normal, database utama dapat gagal karena error sistem. Dalam kasus ini, pemulihan dari bencana (disaster recovery) adalah proses penyediaan database sekunder bagi klien untuk melanjutkan pemrosesan.

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

Tujuan

Men-deploy SQL Server di Linux
Membuat grup ketersediaan yang Selalu Aktif untuk ketersediaan tinggi dan pemulihan dari bencana (disaster recovery)
Menginstal dan mengonfigurasikan Pacemaker untuk mengelola failover cluster SQL Server
Mengonfigurasi load balancer untuk merutekan traffic ke grup ketersediaan dengan SQL Server
Siapkan fence STONITH (Shoot The Other Node In The Head) untuk memastikan integritas HA
Jalankan uji 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 Anda.

Sebelum memulai

Untuk tutorial ini, Anda memerlukan proyek Google Cloud. Anda dapat membuat project baru, atau memilih 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

Guna menyiapkan project Google Cloud dan VPC untuk deployment grup ketersediaan SQL Server Always On, lakukan hal berikut:

Di konsol Google Cloud, buka Cloud Shell dengan mengklik tombol Activate Cloud Shell .

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. Zona ini harus berupa zona yang valid di region yang ditentukan di langkah sebelumnya.

Membuat VM Linux

Guna 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.

Update file host 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 Connect to Linux VM 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 antara 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 konfigurasi 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:

Mengimpor kunci repositori publik.

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

Daftarkan repositori SQL Server Ubuntu.

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

Konfigurasikan 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 yang disertakan, tetapi Anda hanya dapat menggunakannya untuk lingkungan non-produksi. Informasi selengkapnya tersedia terkait edisi SQL Server dan lisensi Microsoft.
  
  Catatan: Untuk setiap instance VM, diperlukan lisensi SQL Server. Jika Anda menjalankan server aplikasi Microsoft, License Mobility melalui Software Assurance 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 sedang berjalan.
```
systemctl status mssql-server --no-pager
```
Jika Anda telah mengaktifkan firewall pada VM, buka firewall untuk SQL Server:
1. Periksa apakah Uncomplicated Firewall telah 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 sebagaimana mestinya.

Terhubung ke SQL Server

Pada tahap ini, SQL Server sudah diinstal. Untuk menghubungkannya, buat mesin Windows di VPC yang sama, instal SQL Server Management Studio (SSMS) untuk terhubung ke instance SQL Server yang baru dibuat di VM:

Buat VM Windows:

Kembali ke Cloud Shell 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:
Update file hosts di node-4:
1. Buka notepad dalam mode administrator.
2. Klik File > Open 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 dari setiap VM.
4. Simpan dan keluar.
Verifikasi koneksi ke VM Linux:
1. Hubungkan ke VM Windows di node-4
2. Klik tombol Start, lalu masukkan powershell di 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, dan mulai aplikasi Windows PowerShell ISE.
3. Pada PowerShell{i> prompt<i}, unduh 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 Restart untuk memulai ulang komputer jarak jauh. Tindakan ini akan menutup sesi RDP.
Hubungkan ke instance SQL Server di 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 informasi selengkapnya, baca artikel tentang terhubung ke instance SQL Server menggunakan dokumentasi SQL Server Management Studio.
3. Masukkan sandi untuk akun SA yang dibuat selama penginstalan.
4. Pilih Percayai sertifikat server.
5. Klik Connect.

Mengaktifkan 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 Always On 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 set 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.

Transfer file kunci dan sertifikat

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

Untuk opsi transfer lainnya, lihat Mentransfer file ke VM Linux

Transfer file kunci dan sertifikat menggunakan Cloud Storage

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

Membuat bucket Cloud Storage:
1. Kembali ke Cloud Shell Anda, 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 pada node-1, node-2, dan node-3 untuk menginisialisasi Google Cloud CLI:
1. Jalankan perintah berikut untuk melakukan inisialisasi 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 dengan membatalkan perintah berikut.
```
sudo gsutil cp /var/opt/mssql/data/my_ag_certificate.cer gs://BUCKET_NAME/
sudo gsutil 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 gsutil cp gs://BUCKET_NAME/my_ag_certificate.cer /var/opt/mssql/data/
sudo gsutil 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 root shell.
```
chown mssql:mssql /var/opt/mssql/data/my_ag_certificate.*
chmod 660 /var/opt/mssql/data/my_ag_certificate.*
```
  Tips: Ingatlah untuk keluar dari shell root setelah menjalankan perintah.

Menyiapkan 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. Hubungkan ke database SQL Server di node-1, node-2, dan node-3 menggunakan SSMS. Ikuti langkah-langkah dari Connect to SQL Server menggunakan node-1, node-2, dan node-3 sebagai nama Server dan masing-masing sandi yang Anda setel 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 pada 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 Selalu Aktif

Selanjutnya, buat grup ketersediaan Always On SQL Server 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';

Membuat grup ketersediaan Selalu Aktif:

Jalankan perintah T-SQL berikut di SSMS pada node-1, node-2, dan node-3. Tindakan ini akan memastikan endpoint 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 pada 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 pada node-2 dan node-3 untuk setiap instance SQL Server untuk bergabung dengan 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 pada instance SQL Server yang berjalan pada node-1. Node-2 dan node-3 telah ditambahkan ke grup ketersediaan dan data dalam database bookshelf akan direplikasi secara sinkron di seluruh instance SQL Server di ketiga node.

Menginstal dan mengonfigurasi Alat pacu jantung

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 alat pacu jantung

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 pada 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 alat pacu jantung.

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.

Pasang Alat Pacu Jantung

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

Buka port firewall untuk alat pacu jantung:
1. Periksa apakah Uncomplicated Firewall telah diinstal dan diaktifkan dengan menjalankan perintah berikut pada 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 sebagaimana mestinya

Instal Alat pacu jantung 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: Tetapkan sandi yang sama di ketiga node. Sandi ini akan diperlukan selama penyiapan berikutnya.
```
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
```

Modifikasi file konfigurasi Corosync:

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

Perbarui bagian yang ditandai. Setelah diedit, 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 yang dihasilkan dan file konfigurasi corosync dari node-1 ke bucket Cloud Storage Anda:
```
sudo gsutil cp /etc/corosync/authkey gs://BUCKET_NAME/
sudo gsutil cp  /etc/corosync/corosync.conf gs://BUCKET_NAME/
```
Ganti BUCKET_NAME dengan nama bucket yang telah dibuat sebelumnya.
Download file Authkey dan konfigurasi ke node-2 dan node-3:
```
sudo gsutil cp gs://BUCKET_NAME/authkey /etc/corosync/
sudo gsutil 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 pada node-1, node-2, dan node-3:
```
sudo systemctl restart pacemaker corosync
```
Konfirmasi status cluster dengan menjalankan perintah di node-1:
```
sudo crm status
```
Anda akan melihat ketiga node tersebut secara online.

Menyiapkan Cluster

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

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 dalam cluster dengan menjalankan perintah pada node-1. Gunakan sandi yang disetel sebelumnya untuk akun hacluster:
```
sudo pcs cluster auth -u hacluster
```
Anda akan melihat bahwa ketiga node tersebut telah diberi otorisasi.
Instal agen resource SQL Server untuk integrasi dengan Alat Pacemaker pada 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. Ketik dalam 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. Ketik commit untuk melakukan commit perubahan.
  
  Catatan: Anda akan menerima peringatan bahwa belum ada aturan pemagaran. Abaikan pesan ini, aturan anggar akan disiapkan pada langkah berikutnya.
5. Ketik exit untuk keluar dari pengelola resource 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 mengarahkan traffic ke grup ketersediaan.

Kembali ke Cloud Shell dan cadangkan 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 Anda 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 mana 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 gratis dan 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 mana pun pada jaringan VPC atau jaringan yang terhubung, Anda harus 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 sudah disiapkan dengan benar, instal dan konfigurasi HAProxy tcp listener pada 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 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 sebelumnya dipilih. Misalnya, 6000.
6. Mulai layanan untuk memastikan bahwa layanan telah dikonfigurasi dengan benar:
```
sudo systemctl start haproxy.service
sudo systemctl enable haproxy.service
sudo systemctl restart haproxy.service
```
7. Buka halaman Load balancing, klik load balancer Anda. Amati tiga grup instance yang tidak dikelola, grup instance tersebut sekarang akan dilaporkan 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 dilaporkan responsif, lanjutkan ke langkah berikutnya.
  
  Catatan: Jika grup instance yang tidak dikelola tidak berstatus responsif, Anda mungkin perlu memulai ulang haproxy.service dari node yang dimaksud.
```
sudo systemctl restart haproxy.service
```
Buat referensi 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 di 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 responsif untuk node-1.
  
  Buka Load balancing
Buat resource alamat IP virtual di cluster Pacemaker Anda:
1. Kembali ke SSH di node-1, lalu temukan nama antarmuka jaringan node Anda. Anda akan membutuhkannya di langkah berikutnya.
```
ip -c link
```
2. Membuat 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 di node utama, pindahkan dengan perintah berikut.
```
sudo pcs resource move aoag1-vip node-1
```
5. Mengelompokkan 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 yang utama.
```
sudo pcs constraint colocation add master aoag1-group with master ms-ag1 score=INFINITY
```

Membuat pemroses untuk grup ketersediaan SQL Server

Koneksi ke SQL Server dengan grup ketersediaan harus menggunakan nama pemroses grup ketersediaan, bukan nama server. Jika terjadi failover, pemroses akan otomatis mengalihkan koneksi ke node utama baru dalam 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 di klaster HA. Layanan STONITH bekerja pada level node dan melindungi cluster dari node yang tidak responsif atau dalam keadaan yang tidak diketahui. Sebaiknya gunakan perangkat pagar fence_gce khusus untuk Compute Engine di Google Cloud.

Siapkan perangkat pagar

Periksa apakah fence_gce - Agen pagar 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 menjalankan agen.
```
sudo pcs stonith describe fence_gce
```

Di 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 anggar 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 diinginkan:

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 anggar di cluster alat pacu jantung Anda 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 penyiapan perangkat pagar, sebaiknya Anda mengujinya menggunakan langkah-langkah berikut.

Hentikan fence di node-2:
1. Hubungkan ke node-1 dan jalankan perintah berikut untuk menguji perangkat fence 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 dan mulai ulang instance 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
```

Konfigurasi Corosync untuk mulai ulang yang tertunda

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

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

Buat file drop-in bersistem yang menetapkan penundaan dimulainya layanan Corosync pada node-1, node-2, dan node-3:
1. Buka corosync.service untuk mengedit.
```
sudo systemctl edit corosync.service
```
2. Tambahkan baris berikut, simpan file, dan keluar dari editor.
```
[Service]
ExecStartPre=/bin/sleep 60
```
3. Muat ulang service manager dan periksa apakah konfigurasi dipertimbangkan.
```
sudo systemctl daemon-reload
systemctl status corosync.service --no-pager
```
  Jika Anda melihat bagian Drop-In, berarti setelan di file drop-in Anda telah berhasil dipertimbangkan

Menguji failover

Sekarang Anda siap untuk 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 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 failback 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.