Haruskah kita merancang program untuk bunuh diri secara acak? [Tutup]

Singkatnya, haruskah kita merancang kematian ke dalam program, proses, dan utas pada tingkat rendah, untuk kebaikan sistem secara keseluruhan?

Kegagalan terjadi. Proses mati. Kami merencanakan bencana dan sesekali pulih dari itu. Tetapi kami jarang merancang dan mengimplementasikan program kematian yang tidak dapat diprediksi. Kami berharap bahwa uptime layanan kami selama kami peduli untuk tetap beroperasi.

Contoh makro dari konsep ini adalah Netflix's Chaos Monkey , yang secara acak mengakhiri instance AWS dalam beberapa skenario. Mereka mengklaim bahwa ini telah membantu mereka menemukan masalah dan membangun sistem yang lebih berlebihan.

Yang saya bicarakan adalah level yang lebih rendah. Idenya adalah untuk proses lama secara tradisional untuk secara acak keluar. Ini harus memaksa redundansi ke dalam desain dan pada akhirnya menghasilkan sistem yang lebih tangguh.

Apakah konsep ini sudah memiliki nama? Apakah sudah digunakan di industri?

SUNTING

Berdasarkan komentar dan jawaban, saya khawatir saya tidak jelas dalam pertanyaan saya. Untuk kejelasan:

• ya, maksud saya secara acak,
• ya, maksud saya dalam produksi, dan
• tidak, tidak hanya untuk pengujian.

Untuk menjelaskan, saya ingin menggambar analogi dengan organisme multiseluler.

Di alam, organisme terdiri dari banyak sel. Sel-sel bercabang sendiri untuk membuat redundansi, dan mereka akhirnya mati. Tetapi harus selalu ada sel yang cukup dari jenis yang tepat bagi organisme untuk berfungsi. Sistem yang sangat berlebihan ini juga memfasilitasi penyembuhan saat terluka. Sel-sel mati sehingga organisme hidup.

Memasukkan kematian acak ke dalam suatu program akan memaksa sistem yang lebih besar untuk mengadopsi strategi redundansi agar tetap layak. Apakah strategi yang sama ini membantu sistem tetap stabil dalam menghadapi jenis kegagalan lain yang tidak dapat diprediksi?

Dan, jika ada yang mencoba ini, apa namanya? Saya ingin membaca lebih lanjut tentang itu jika sudah ada.

Tidak.

Kita harus merancang penanganan jalur buruk yang tepat, dan merancang uji kasus (dan peningkatan proses lainnya) untuk memvalidasi bahwa program menangani kondisi luar biasa ini dengan baik. Hal-hal seperti Chaos Monkey dapat menjadi bagian dari itu, tetapi segera setelah Anda membuat "harus crash secara acak" persyaratan crash nyata yang sebenarnya menjadi hal yang tidak dapat diajukan penguji sebagai bug.

Proses memperkenalkan cacat dalam perangkat lunak atau perangkat keras untuk menguji mekanisme toleransi kesalahan disebut injeksi kesalahan .

Dari Wikipedia:

Teknik injeksi kesalahan tanggal kembali ke tahun 1970-an ketika pertama kali digunakan untuk menginduksi kesalahan pada tingkat perangkat keras. Jenis injeksi kesalahan ini disebut Hardware Implemented Fault Injection (HWIFI) dan berupaya mensimulasikan kegagalan perangkat keras dalam suatu sistem. Percobaan pertama dalam injeksi kesalahan perangkat keras melibatkan tidak lebih dari koneksi korslet pada papan sirkuit dan mengamati efek pada sistem (menjembatani kesalahan). Itu digunakan terutama sebagai tes ketergantungan sistem perangkat keras. Belakangan perangkat keras khusus dikembangkan untuk memperluas teknik ini, seperti perangkat untuk membombardir area tertentu dari papan sirkuit dengan radiasi besar. Segera ditemukan bahwa kesalahan dapat disebabkan oleh teknik perangkat lunak dan bahwa aspek teknik ini dapat berguna untuk menilai sistem perangkat lunak.

Iya. Tidak, mungkin.

Pemutusan periodik adalah pedang bermata dua. Anda akan mendapatkan pukulan dengan satu sisi atau yang lain, dan yang lebih rendah dari dua kejahatan tergantung pada situasi Anda.

Satu sisi adalah keandalan: Jika Anda memaksa program untuk mengakhiri secara acak (atau dapat diprediksi) dan dengan cara yang teratur, Anda dapat dipersiapkan untuk acara itu dan menanganinya. Anda dapat menjamin bahwa proses akan keluar saat tidak sibuk melakukan sesuatu yang bermanfaat. Ini juga menjamin bahwa bug yang akan memanifestasikan diri mereka di luar jangka waktu sanksi tidak akan memundurkan kepala jelek mereka dalam produksi, yang merupakan hal yang baik. Apache HTTPD memiliki pengaturan yang akan memungkinkan Anda menyesuaikan berapa banyak permintaan proses anak (atau utas dalam versi yang lebih baru) akan ditayangkan sebelum diakhiri.

Sisi lain juga reliabilitas: Jika Anda tidak membiarkan program berjalan lama, Anda tidak akan pernah menemukan bug yang muncul dengan sendirinya seiring waktu. Ketika akhirnya Anda menemukan salah satu bug itu, kemungkinan besar program akan mengembalikan jawaban yang salah atau gagal mengembalikannya sama sekali. Lebih buruk lagi, jika Anda menjalankan banyak utas dari pekerjaan yang sama, bug yang diinduksi waktu atau hitungan dapat memengaruhi sejumlah besar tugas sekaligus dan mengakibatkan perjalanan jam 3 pagi ke kantor.

Dalam pengaturan di mana Anda menjalankan banyak utas yang sama (misalnya, pada server web), solusi praktisnya adalah dengan mengambil pendekatan campuran yang menghasilkan tingkat kegagalan yang dapat diterima. Jika Anda menjalankan 100 utas, menjalankan rasio pendek-ke-panjang dari 99: 1 berarti hanya satu yang akan menunjukkan bug jangka panjang sementara yang lain terus melakukan apa pun yang mereka lakukan tanpa gagal. Bandingkan dengan menjalankan 100% lama, di mana Anda menjalankan risiko yang jauh lebih tinggi karena semua utas gagal pada saat yang sama.

Di mana Anda memiliki utas tunggal, mungkin lebih baik membiarkannya berjalan dan gagal, karena waktu mati selama restart dapat mengakibatkan latensi yang tidak diinginkan ketika ada pekerjaan nyata untuk dilakukan yang akan selesai dengan sukses.

Dalam kedua kasus, penting bahwa ada sesuatu yang mengawasi proses sehingga mereka dapat segera dimulai kembali. Juga, tidak ada undang-undang yang mengatakan keputusan awal Anda tentang berapa lama suatu proses harus dijalankan. Mengumpulkan data operasional akan membantu Anda menyesuaikan sistem Anda untuk menjaga kegagalan hingga tingkat yang dapat diterima.

Saya akan merekomendasikan untuk tidak melakukan penghentian acak, karena itu membuatnya lebih sulit untuk mengatasi bug yang berhubungan dengan waktu. Chaos Monkey melakukannya untuk memastikan perangkat lunak pengawas bekerja, yang merupakan masalah yang sedikit berbeda.

Apakah maksud Anda benar-benar acak? Memiliki perangkat lunak Anda secara acak membunuh sendiri terdengar seperti ide yang buruk. Apa gunanya?

Saya menduga apa yang Anda maksudkan adalah bahwa kita harus realistis tentang thread / proses yang berjalan lama dan menerima bahwa semakin lama mereka berjalan, semakin besar kemungkinan mereka akan menemukan semacam bug tersembunyi, dan masuk ke non-fungsional negara. Jadi, sebagai langkah pragmatis murni, masa proses dan utas harus dibatasi.

Saya percaya bahwa pada akhir 90-an server web Apache menggunakan sesuatu seperti ini. Mereka memiliki kumpulan proses pekerja (bukan benang) dan setiap proses pekerja akan terbunuh setelah masa hidup yang tetap. Ini membuat server tidak dimonopoli oleh proses pekerja yang terjebak dalam beberapa kondisi patologis.

Saya belum pernah bekerja di daerah itu untuk beberapa waktu, jadi saya tidak tahu apakah ini masih terjadi.

Masalah yang saya lihat adalah bahwa jika program seperti itu mati, kita hanya akan mengatakan "Oh itu hanya penghentian acak - tidak ada yang perlu dikhawatirkan". Tetapi bagaimana jika ada masalah nyata yang perlu diperbaiki? Itu akan diabaikan.

Program yang sudah "acak" gagal karena pengembang membuat mystaykes, bug membuatnya menjadi sistem produksi, kegagalan perangkat keras, dll. Ketika hal ini terjadi, kami ingin mengetahuinya sehingga kami dapat memperbaikinya. Merancang kematian ke dalam program hanya meningkatkan kemungkinan kegagalan dan hanya akan memaksa kita untuk meningkatkan redundansi, yang membutuhkan biaya.

Saya melihat tidak ada yang salah dengan membunuh proses secara acak di lingkungan pengujian ketika menguji sistem yang berlebihan (ini harus terjadi lebih dari itu) tetapi tidak dalam lingkungan produksi. Apakah kita akan mengeluarkan beberapa hard drive dari sistem produksi langsung setiap beberapa hari, atau menonaktifkan salah satu komputer di pesawat karena itu terbang penuh penumpang? Dalam skenario pengujian - baik. Dalam skenario produksi langsung - saya lebih suka tidak.

Menambahkan kode keluar acak ke aplikasi seharusnya tidak perlu. Penguji dapat menulis skrip yang secara acak membunuh proses aplikasi.

Dalam jaringan, perlu untuk mensimulasikan jaringan yang tidak dapat diandalkan demi menguji implementasi protokol. Ini tidak dibangun ke dalam protokol; dapat disimulasikan pada tingkat driver perangkat, atau dengan beberapa perangkat keras eksternal.

Jangan menambahkan kode tes lakukan program untuk situasi yang dapat dicapai secara eksternal.

Jika ini dimaksudkan untuk produksi, saya tidak percaya ini serius!

Pertama, kecuali proses keluar secara tiba-tiba sehingga transaksi yang sedang berlangsung dan data volatile hilang, maka itu bukan implementasi konsep yang jujur. Pintu keluar yang terencana dan anggun, meskipun waktunya acak, tidak cukup membantu mempersiapkan arsitektur untuk menghadapi tabrakan nyata, yang tidak anggun.

Jika malfungsi nyata atau realistis dibangun ke dalam aplikasi mereka dapat mengakibatkan kerugian ekonomi, seperti kerusakan nyata, dan kerugian ekonomi yang disengaja pada dasarnya adalah tindakan kriminal hampir secara definisi.

Anda mungkin dapat lolos dari klausul dalam perjanjian lisensi yang membebaskan tanggung jawab perdata dari segala kerusakan yang timbul dari pengoperasian perangkat lunak, tetapi jika kerusakan itu terjadi karena desain, Anda mungkin tidak dapat melepaskan tanggung jawab pidana.

Jangan pernah berpikir tentang aksi seperti ini: membuatnya bekerja sekuat yang Anda bisa, dan memasukkan skenario kegagalan palsu hanya ke dalam bangunan atau konfigurasi khusus.

Anda mungkin ingin mencari " pemulihan proaktif " dan " peremajaan " dalam konteks sistem terdistribusi toleransi kesalahan, untuk menangani kesalahan sewenang-wenang (yaitu, tidak hanya proses macet, tetapi data rusak dan perilaku berbahaya juga). Ada banyak penelitian tentang seberapa sering dan dalam kondisi apa suatu proses (dalam arti abstrak, sebenarnya bisa berupa VM atau host) dimulai kembali. Secara intuitif, Anda dapat memahami keuntungan dari pendekatan ini karena lebih suka berurusan dengan proses mati daripada dengan proses pengkhianat ...

Ini benar-benar tidak berbeda dengan pengujian. Jika Anda merancang solusi failover yang selalu tersedia (seperti Netflix), maka ya - Anda harus mengujinya. Saya tidak tahu bahwa pintu keluar acak yang ditaburkan di seluruh basis kode adalah cara yang tepat untuk mengujinya. Kecuali jika Anda benar-benar berniat menguji bahwa desain Anda tangguh untuk menembak diri sendiri, sepertinya akan lebih tepat untuk mengujinya dengan memanipulasi lingkungan di sekitar kode dan memverifikasi bahwa perilakunya berperilaku tepat.

Jika Anda tidak merancang sistem yang berlebihan, maka tidak - Anda tidak harus menambahkan fitur itu karena Anda menambahkan beberapa pintu keluar acak. Anda hanya harus menghapus pintu keluar acak, dan kemudian Anda tidak akan memiliki masalah itu. Lingkungan Anda mungkin masih gagal pada Anda, pada titik mana Anda akan mencatatnya sebagai tidak didukung / tidak akan memperbaiki atau mengeraskan kode Anda terhadap kegagalan itu dan menambahkan tes untuk itu. Lakukan itu cukup sering, dan Anda akan menyadari bahwa Anda sebenarnya sedang merancang sistem yang berlebihan - lihat skenario # 1.

Pada titik tertentu, Anda dapat menentukan bahwa Anda tidak lagi yakin apa kegagalan itu atau tidak ditangani. Sekarang Anda dapat mulai menarik karpet secara acak untuk mendeteksi titik kegagalan.

Satu-satunya hal yang menarik tentang contoh Netflix adalah mereka menjalankan tes ini dalam produksi. Itu masuk akal - beberapa bug benar-benar hanya produksi hal-hal yang sangat sulit atau tidak mungkin untuk disimulasikan di lingkungan yang terisolasi. Saya menduga bahwa Netflix menghabiskan waktu yang lama di lingkungan pengujian sebelum mereka cukup nyaman untuk melakukan ini dalam produksi. Dan sebenarnya yang mereka lakukan adalah mencoba agar crash terjadi selama jam kerja, yang masuk akal bagi pasar mereka tetapi tidak untuk banyak orang lain.

Istilah yang Anda cari baru-baru ini diciptakan oleh Nassim Nicholas Taleb: Antifragility. Bukunya Antifragile pasti direkomendasikan. Itu hampir tidak menyebutkan IT, tetapi paralel, jelas tak terucapkan paling menginspirasi. Idenya adalah untuk memperluas skala antifragile rapuh <-> kuat ke rapuh <-> kuat. Istirahat rapuh dengan acara acak, mengelola kuat dengan acara acak dan keuntungan anti-rapuh dengan acara acak.

Tergantung. Saya telah memperhatikan bahwa programmer cenderung terlalu generalisasi teknik yang berlaku untuk domain spesifik mereka mengabaikan semua yang lain. Misalnya, merilis program dengan biaya memperbaiki semua bug mungkin baik ... kecuali Anda memprogram pengontrol pesawat, reaktor nuklir, dll. "Jangan mengoptimalkan - biaya programmer lebih besar daripada biaya menjalankan program" tidak diperlukan berlaku untuk HPC karena ada program yang relatif sederhana dapat menempati cluster selama berbulan-bulan dll. (atau bahkan program populer yang digunakan oleh sejumlah besar pengguna). Jadi, bahkan jika perusahaan X melakukan Y untuk alasan yang sangat baik Anda tidak perlu mengikuti jejak mereka karena situasi Anda mungkin berbeda.

Biasanya rutinitas penanganan kesalahan adalah bagian yang paling diuji dari kode - sementara tampaknya sederhana sulit untuk mensimulasikan bahwa ada memori tidak mencukupi atau beberapa file penting tidak ada. Untuk alasan itu saya membaca teks yang diusulkan untuk kernel Unix gagal secara acak beberapa panggilan sistem. Namun itu akan membuat program sederhana lebih sulit untuk ditulis (jika saya perlu menyambungkan 3 C ++ libraries bersama untuk menjalankan program pada 2 file setelah saya tidak ingin repot dengan penanganan kesalahan). Bahkan dengan pengecualian, GC Anda perlu memastikan bahwa Anda meninggalkan keadaan yang konsisten (bayangkan pengecualian di tengah menambahkan node ke daftar tertaut).

Semakin banyak layanan terdistribusi yang Anda miliki semakin banyak kegagalan adalah pertanyaan tentang "seberapa sering" maka "jika" atau "kapan". Di pusat data, penggantian disk di RAID adalah bagian dari operasi rutin dari apa yang saya ketahui - bukan kegagalan yang tidak terduga. Jika Anda beroperasi dalam skala besar, Anda perlu memperhitungkannya meskipun kemungkinan kegagalan satu komponen kecil, kemungkinan ada sesuatu yang gagal.

Saya tidak tahu apa yang sebenarnya Anda lakukan tetapi untuk mengetahui apakah itu layak, Anda perlu berpikir jika kegagalan adalah sesuatu yang perlu Anda perhitungkan (karena mengabaikan biayanya) atau itu adalah sesuatu yang terlalu mahal untuk dianalisis (seperti mengambil kesalahan memperhitungkan waktu pengembangan biaya).

Server IIS memiliki fitur yang dapat dikonfigurasi yang secara otomatis mendaur ulang proses pekerja baik setelah mereka menggunakan sejumlah memori atau setelah melayani sejumlah permintaan tertentu atau setelah mereka hidup untuk rentang waktu tertentu. ( http://msdn.microsoft.com/en-us/library/ms525803(v=vs.90).aspx ) dan ( http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/ 1652e79e-21f9-4e89-bc4b-c13f894a0cfe.mspx? Mfr = true )

Ketika wadah seperti IIS melakukannya, masuk akal untuk melindungi server dari proses jahat. Namun saya lebih suka untuk mematikan ini, karena tidak masuk akal jika Anda telah cukup menguji kode Anda.

Kami sudah bekerja pada lapisan yang tidak dapat diandalkan (perangkat keras, jaringan) jadi saya tidak akan pernah menulis kode apa pun yang secara acak membunuh utasnya atau memprosesnya dengan sengaja. Pembunuhan acak juga merupakan ide buruk dari perspektif ekonomi - tidak ada yang akan menggunakan API saya jika mereka pikir saya telah memprogramnya untuk crash secara acak. Terakhir, jika saya mengkonsumsi API atau menggunakan sistem dengan utas macet secara acak, saya harus menghabiskan banyak uang untuk membuat mekanisme pemantauan yang cukup kuat sehingga saya bisa tidur nyenyak di malam hari.

Sebaliknya Jika saya sedang mengembangkan suatu sistem atau API saya akan menulis skrip atau menggunakan harness yang akan melakukan ini murni untuk menekankan menguji ketahanan sistem. Dan saya akan melakukan uji coba seperti itu pada semua build untuk mengidentifikasi build yang buruk. Namun, sementara ini akan menjadi tes yang diperlukan, itu tidak akan pernah menjadi tes "cukup".

Ada literatur terkait ide ini, yang disebut Crash-Only software (juga Recovery Oriented Computing) dan Anda dapat mulai dengan kertas usenix ini oleh Candea & Fox dari tahun 2003. Daripada membunuh secara acak, penulis berpendapat Anda dapat meningkatkan keandalan sistem hanya dengan pernah menghentikan program Anda dengan membunuhnya, sehingga memiliki saklar pembunuh tunggal sebagai tombol mematikan dan satu jalur start-up yang dijalankan dengan baik untuk pemulihan.

Meskipun saya tidak yakin seberapa baik ide itu tertangkap, beberapa teknik spesifik tetap bermanfaat. Misalnya tidak mempercayai perangkat lunak Anda untuk dapat mematikan dirinya sendiri ketika diminta dan menggunakan program pengawasan khusus (misalnya, pengawas, dll.), Dan juga berpikir dengan hati-hati tentang status program yang penting dan memastikannya dicatat pada waktu yang tepat di penyimpanan data yang dirancang untuk mengaktifkan pemulihan (mis. database sql).

Benar-benar acak, tidak. Tapi itu mungkin ide yang bagus untuk proses / utas yang berjalan lama untuk keluar / memulai kembali pada interval tertentu, atau setelah menganggur selama durasi tertentu (tetapi tergantung pada kriteria tertentu), atau setelah menjalankan jenis tugas tertentu. Proses yang berjalan lama membangun keadaan tak terhindarkan termasuk hal-hal basi, mungkin bisa bertahan pada memori mencegah ruang swap untuk dirilis, yang semuanya mendapatkan (atau harus mendapatkan) dibersihkan ketika mereka keluar, meningkatkan stabilitas sistem umum.

Itu tergantung pada jenis aplikasi yang Anda desain.

Kecelakaan acak adalah cara terbaik untuk menguji dan meningkatkan kekokohan sistem terdistribusi (jaringan).

Dalam contoh Netflix, ketika program Anda bergantung pada layanan jarak jauh yang dapat gagal karena berbagai alasan yang di luar kendali Anda (hard disk memburuk, kehilangan daya, meteor menabrak pusat data, dll). Layanan Anda harus tetap berjalan entah bagaimana.

Bagaimana kamu melakukannya? Menambahkan redundansi dan penskalaan adalah solusi umum.

Misalnya, jika mouse mengunyah melalui kabel daya server Anda maka layanan Anda harus memiliki beberapa solusi untuk terus berjalan. Misalnya dapat menyimpan server cadangan berlebihan yang akan mulai digunakan.

Namun, jika program Anda adalah aplikasi proses tunggal yang tidak beroperasi dalam jaringan, maka mematikannya sendiri tidak akan menguji apa pun karena tidak ada cara untuk memulihkannya.

Berikut ini beberapa komentar tambahan tentang konsep Chaos Monkeys http://www.codinghorror.com/blog/2011/04/working-with-the-chaos-monkey.html

Ada kemungkinan bahwa flip bit acak terjadi karena radiasi kosmik . Masalah ini dikenali, dan berbagai teknik dikembangkan untuk mencegah terjadinya flipping bit.

Namun, tidak mungkin untuk memperbaikinya 100%, dan kerusakan memori masih dapat menyebabkan masalah, dan masalah ini masih terjadi ( dengan probabilitas sangat rendah ).

Sekarang untuk menjawab pertanyaan Anda. Apakah Anda perlu merancang sistem yang sangat kuat, itu tergantung pada apa yang Anda lakukan. Jika Anda perlu membuat pesawat ruang angkasa, lebih baik Anda membuatnya menjadi sangat kuat, dan kemudian Anda harus memperhitungkan setiap masalah yang mungkin terjadi.

Jika Anda perlu merancang aplikasi desktop biasa, maka Anda harus melihat crash secara acak sebagai bug dalam kode Anda.

Ini sepertinya tidak masuk akal dari sebuah ide.

OS Android secara acak membunuh dan memulai ulang aplikasi / layanan pengguna setiap saat. Dalam pengalaman saya, itu pasti membantu saya berpikir lebih dalam tentang kondisi kesalahan serta merancang arsitektur yang lebih kuat.