Dalam arsitektur microservices yang digabungkan secara longgar, bagaimana Anda melacak dependensi Anda?

Pilihan arsitektur tingkat tinggi yang populer dalam program modern adalah sistem layanan-mikro berbasis REST. Ini memiliki beberapa keunggulan seperti kopling longgar, mudah digunakan kembali, pembatasan terbatas pada teknologi yang dapat digunakan, skalabilitas tinggi, dll.

Tetapi salah satu masalah yang saya perkirakan dalam arsitektur seperti itu adalah visibilitas yang buruk ke dalam apa ketergantungan suatu aplikasi. Sebagai contoh, katakanlah saya memiliki aplikasi yang menggunakan satu set panggilan REST setiap hari. Aplikasi ini juga menggunakan set kedua panggilan REST, tetapi hanya sekali seperempat. Jika saya harus memindai log selama seminggu terakhir saya akan melihat semua panggilan harian, tapi saya kemungkinan tidak akan melihat panggilan triwulanan. Ketika tiba saatnya untuk refactor, panggilan triwulanan beresiko tinggi terputus.

Pola atau alat apa yang dapat digunakan untuk mengurangi risiko ini dan memberikan visibilitas yang lebih besar ke dalam apa dependensi arsitektur yang digabungkan secara longgar?

— David mengatakan Reinstate Monica
sumber

Inilah mengapa kopling longgar bisa jadi buruk. Ketika tidak ada dependensi waktu kompilasi, satu-satunya cara untuk mendeteksi kesalahan, dan Anda tidak pernah menangkap semuanya, adalah menggunakan pengujian otomatis. Solusinya adalah beberapa jenis pengujian otomatis, yang mungkin mencakup pengujian unit serta pengujian integrasi.

— Frank Hileman

Pengujian @ FrankHileman jelas membantu, tapi saya merasa sulit untuk percaya bahwa ini adalah satu-satunya solusi di luar sana. Plus ada banyak bahasa yang tidak memiliki pemeriksaan waktu kompilasi (yaitu JS atau Python), jadi bahkan dengan penggabungan ketat di sana Anda masih akan mengalami masalah.

— David mengatakan Reinstate Monica

sistem tipe statis dapat menangkap sejumlah besar kesalahan selama fase kompilasi. Satu-satunya kompensasi untuk kurangnya sistem seperti itu adalah pengujian otomatis, setahu saya. Deteksi kesalahan statis melalui bukti otomatis atau hanya kompilasi akan selalu lebih dapat diandalkan daripada tes.

— Frank Hileman

Salah satu cara yang mungkin bisa dilakukan adalah mengimplementasikan klien API setiap layanan secara terpisah dan, termasuk klien ini sebagai dependensi proyek. Dengan API, klien juga akan lebih mudah untuk melacak versi layanan mana yang kami konsumsi.

— Laiv

@ Longv Saya secara khusus ingin tahu tentang layanan tenang, jadi itu bukan pilihan karena siapa pun dapat mengirim permintaan HTTP lebih atau kurang.

— David mengatakan Reinstate Monica

Jawaban:

Pola atau alat apa yang dapat digunakan untuk mengurangi risiko ini

Menjaga agar API dan kemampuan bisnis Anda tetap kompatibel.

memberikan visibilitas yang lebih besar ke dalam apa dependensi dari arsitektur yang digabungkan secara longgar

Pemeriksaan kesehatan.

Layanan saya adalah klien untuk kemampuan api bulanan Anda. Tetapi layanan saya adalah klien api Anda setiap kali layanan saya berjalan. Jadi layanan saya bangun setiap 10 menit, atau apa pun, terhubung ke api bulanan Anda, dan menjalankan protokol untuk memastikan bahwa kemampuan yang dibutuhkan layanan saya masih tersedia.

Jadi log Anda akan menunjukkan seberapa sering beberapa layanan lain memeriksa untuk melihat bahwa setiap layanan tertentu yang Anda tawarkan masih tersedia, sama seperti itu menunjukkan seberapa sering setiap layanan tertentu yang Anda tawarkan benar-benar digunakan.

— VoiceOfUnreason
sumber

Setidaknya ada dua lokasi di mana Anda dapat menemukan dependensi:

Konfigurasi. Mengakses API eksternal harus mengetahui banyak informasi tentang masing-masing API tersebut. ID akses, kunci rahasia, titik akhir. Semua ini tidak boleh dalam kode, karena informasi tersebut akan berubah. Sebagai contoh, saya baru-baru ini mulai memigrasi semua layanan microser saya ke SSL. Ini berarti bahwa setiap layanan yang bergantung pada layanan yang sedang dimigrasi harus dikonfigurasi ulang untuk menunjuk ke https://versi alih-alih http://. Saya senang titik akhir berada dalam konfigurasi bukannya hardcoded.
Antarmuka. Anda tidak mengakses layanan langsung dari kode Anda, karena versi API akan berubah, dan Anda bahkan dapat memutuskan untuk beralih ke API lain. Sebagai gantinya, Anda membuat lapisan abstraksi, dan menggunakan dependensi melalui antarmuka. Dengan mengikuti logika umum saat membuat antarmuka itu, Anda dapat membuat hidup Anda lebih mudah nanti ketika mencari dependensi.

Ketika tiba saatnya untuk refactor, panggilan triwulanan beresiko tinggi terputus.

Ini adalah tujuan pengujian regresi.

Anda tidak bisa hanya melihat kode, mengubahnya, dan percaya diri bahwa tidak ada yang rusak. Ini tidak akan berfungsi dalam arsitektur layanan microser. Ini juga tidak akan berfungsi dalam aplikasi monolitik. Kompiler dapat menangkap beberapa kesalahan yang akan Anda perkenalkan saat memodifikasi kode. Dalam beberapa bahasa, seperti Haskell, kompiler bisa sangat mampu dan menangkap sebagian besar kesalahan; kompiler untuk bahasa umum, tidak akan banyak membantu Anda. Jika Anda tidak memiliki tes, Anda kacau. Kehadiran layanan mikro tidak relevan.

— Arseni Mourzenko
sumber

-2

REST APIs ditentukan secara longgar sehingga pada titik tertentu mungkin berguna untuk pindah ke gRPC, google protobufs atau Thrift untuk mendefinisikan antarmuka RPC dan kemudian menggantinya.

— Patrick
sumber

Ini mungkin lebih baik sebagai komentar ... tapi jujur ini tidak menjelaskan banyak hal.

— David berkata Reinstate Monica

Cukup adil. API sisanya tidak memiliki ketergantungan waktu kompilasi khusus pada layanan lain karena tautan antara keduanya hanyalah panggilan HTTP, sesuatu seperti host dan path. Dengan gRPC, atau Protobuf atau Hemat, antarmuka didefinisikan yang digunakan untuk menghasilkan kode. Kode yang dihasilkan dikompilasi, dan diversi, dan kemudian layanan Anda dibangun terhadap antarmuka tersebut. Hasilnya adalah bahwa setiap layanan jelas tergantung pada satu atau lebih antarmuka layanan Anda yang lain. Harapan yang menjelaskan jawaban saya!

— Patrick