Mencapai Zero Downtime Deployment menyentuh pada masalah yang sama tetapi saya memerlukan beberapa saran tentang strategi yang saya pertimbangkan.
Konteks
Aplikasi berbasis web dengan Apache / PHP untuk pemrosesan sisi server dan MySQL DB / sistem file untuk kegigihan.
Kami sedang membangun infrastruktur. Semua perangkat keras jaringan akan memiliki redundansi dan semua kabel jaringan utama akan digunakan dalam pasangan terikat untuk toleransi kesalahan. Server dikonfigurasikan sebagai pasangan ketersediaan tinggi untuk toleransi kesalahan perangkat keras dan akan seimbang beban untuk toleransi kesalahan mesin virtual dan kinerja umum.
Adalah maksud saya bahwa kami dapat menerapkan pembaruan ke aplikasi tanpa down-time. Saya telah bersusah payah ketika merancang infrastruktur untuk memastikan bahwa saya dapat menyediakan 100% up-time; akan sangat mengecewakan untuk memiliki downtime 10-15 menit setiap kali pembaruan diterapkan. Ini sangat penting karena kami bermaksud memiliki siklus rilis yang sangat cepat (kadang-kadang dapat mencapai satu atau lebih rilis per hari.
Topologi Jaringan
Ini adalah ringkasan dari jaringan:
Load Balancer
|----------------------------|
/ / \ \
/ / \ \
| Web Server | DB Server | Web Server | DB Server |
|-------------------------|-------------------------|
| Host-1 | Host-2 | Host-1 | Host-2 |
|-------------------------|-------------------------|
Node A \ / Node B
| / |
| / \ |
|---------------------| |---------------------|
Switch 1 Switch 2
And onward to VRRP enabled routers and the internet
Catatan: Server DB menggunakan replikasi master-master
Strategi yang Disarankan
Untuk mencapai ini, saya saat ini sedang berpikir untuk memecah skrip upgrade skema DB menjadi dua bagian. Upgrade akan terlihat seperti ini:
- Web-Server pada node A diambil secara off-line; lalu lintas terus diproses oleh web-server pada node B.
- Perubahan Skema Transisi diterapkan ke server DB
- Web-Server Basis kode diperbarui, cache dihapus, dan tindakan pemutakhiran lainnya diambil.
- Web-Server A dibawa online dan web-server B diambil offline.
- Basis-kode-B server-web diperbarui, cache dihapus, dan tindakan pemutakhiran lainnya diambil.
- Web-server B dibawa online.
- Perubahan Skema Akhir diterapkan ke DB
'Skema Transisi' akan dirancang untuk membuat DB yang kompatibel dengan versi silang. Ini sebagian besar akan menggunakan tampilan tabel yang mensimulasikan skema versi lama sementara tabel itu sendiri akan diubah ke skema baru. Ini memungkinkan versi lama untuk berinteraksi dengan DB seperti biasa. Nama tabel akan menyertakan nomor versi skema untuk memastikan bahwa tidak akan ada kebingungan tentang tabel yang akan ditulis.
'Skema Akhir' akan menghapus kompatibilitas ke belakang dan merapikan skema.
Pertanyaan
Singkatnya, akankah ini berhasil?
lebih spesifik:
Apakah akan ada masalah karena potensi untuk menulis bersamaan pada titik tertentu dari perubahan skema transisi? Apakah ada cara untuk memastikan bahwa grup kueri yang memodifikasi tabel dan membuat tampilan yang kompatibel mundur dijalankan secara berurutan? yaitu dengan kueri lain yang disimpan dalam buffer hingga perubahan skema selesai, yang umumnya hanya dalam milidetik.
Apakah ada metode yang lebih sederhana yang memberikan tingkat stabilitas ini sementara juga memungkinkan pembaruan tanpa down-time? Ini juga lebih disukai untuk menghindari strategi skema 'evolusi' karena saya tidak ingin menjadi terkunci dalam kompatibilitas skema mundur.
sumber
Strategi Anda sehat. Saya hanya akan menawarkan untuk mempertimbangkan memperluas "Skema Transisi" ke dalam satu set lengkap "tabel transaksi".
Dengan tabel transaksi, SELECT (kueri) dilakukan terhadap tabel yang dinormalisasi untuk memastikan kebenaran. Tetapi semua database INSERT, UPDATE, dan DELETEs selalu ditulis ke tabel transaksi yang didenormalkan.
Kemudian, proses bersamaan yang terpisah menerapkan perubahan tersebut (mungkin menggunakan Prosedur Tersimpan) ke tabel yang dinormalisasi sesuai dengan aturan bisnis dan persyaratan skema yang ditetapkan.
Sebagian besar waktu, ini akan hampir seketika. Tetapi memisahkan tindakan memungkinkan sistem untuk mengakomodasi aktivitas berlebihan dan penundaan pembaruan skema.
Selama perubahan skema pada database (B), pembaruan data pada database aktif (A) akan masuk ke tabel transaksinya dan segera diterapkan ke tabel yang dinormalisasi.
Saat mengembalikan basis data (B), transaksi dari (A) akan diterapkan dengan menuliskannya ke tabel transaksi (B). Setelah bagian itu selesai, (A) dapat diturunkan dan skema perubahan diterapkan di sana. (B) akan selesai menerapkan transaksi dari (A) sambil juga menangani transaksi langsungnya yang akan mengantri seperti (A) dan "yang hidup" akan diterapkan dengan cara yang sama ketika (A) kembali.
Baris tabel transaksi mungkin terlihat seperti ...
"Tabel" transaksi sebenarnya dapat berupa baris dalam basis data NoSQL yang terpisah atau bahkan file berurutan, tergantung pada persyaratan kinerja. Bonusnya adalah pengkodean aplikasi (situs web dalam hal ini) menjadi sedikit lebih sederhana karena hanya menulis ke tabel transaksi.
Idenya mengikuti prinsip yang sama seperti pembukuan entri ganda, dan untuk alasan yang sama.
Tabel transaksi dianalogikan dengan "pembukuan" jurnal. Tabel yang dinormalkan sepenuhnya analog dengan "buku besar" pembukuan dengan masing-masing tabel agak seperti "akun" pembukuan.
Dalam pembukuan, setiap transaksi mendapat dua entri dalam jurnal. Satu untuk akun buku besar "yang didebit", dan satu lagi untuk akun "dikreditkan".
Dalam RDBMS, "jurnal" (tabel transaksi) mendapat entri untuk setiap tabel yang dinormalisasi untuk diubah oleh transaksi itu.
Kolom DB dalam ilustrasi tabel di atas menunjukkan di basis data mana transaksi berasal, sehingga memungkinkan baris antrian dari database lain disaring dan tidak diterapkan kembali ketika database kedua dibawa kembali.
sumber