Seiring waktu, setiap proyek tumbuh dan menerapkan fungsi baru menjadi monolit yang ada menjadi lebih sulit, lebih lama dan lebih mahal untuk bisnis.

Salah satu solusi untuk masalah ini adalah penggunaan arsitektur microservice. Untuk pemula atau bagi mereka yang baru mengenal arsitektur ini untuk pertama kalinya, mungkin sulit untuk mengetahui dari mana memulainya, apa yang perlu dilakukan, dan apa yang tidak layak dilakukan.

Artikel ini akan menulis layanan microser paling sederhana di Nodejs & RabbitMQ, dan juga menunjukkan proses migrasi monolith ke layanan microser.

Apa yang ada dalam arsitektur microservice?

Gerbang Server utama yang menerima permintaan dan mengarahkan mereka ke layanan Microsoft yang diinginkan. Lebih sering daripada tidak, tidak ada logika bisnis di gateway.
Layanan microser. Layanan mikro itu sendiri, yang memproses permintaan pengguna dengan logika bisnis yang jelas.
Transportasi Ini adalah bagian melalui mana Gateway & Microservice akan berkomunikasi. Transport mungkin HTTP, gRPC, RabbitMQ, dll.

Kenapa RabbitMQ?

Tentu saja, Anda tidak dapat menggunakan RabbitMQ, ada opsi lain untuk komunikasi antara layanan microser. Yang paling sederhana adalah HTTP, ada gRPC dari Google.

Saya menggunakan RabbitMQ, karena saya merasa cukup sederhana untuk mulai menulis layanan microser, dapat diandalkan dan nyaman karena Anda dapat yakin bahwa ketika sebuah pesan dikirim ke antrian, pesan tersebut akan mencapai layanan microser (bahkan jika dimatikan saat ini dan kemudian dihidupkan ) Berkat keunggulan ini, Anda dapat menulis layanan microser yang andal dan menggunakan penyebaran yang mulus.

Mulai

Pertama, kami menerapkan gateway sederhana yang akan menerima permintaan HTTP saat mendengarkan port tertentu.

Kami menggunakan RabbitMQ (melalui itu layanan dan gateway kami akan berkomunikasi):

$ docker run -d -p 5672:5672 rabbitmq

Kami menginisialisasi proyek dan menginstal paket NPM micromq :

 $ npm init -y $ npm i micromq -S

Menulis gateway

 //   Gateway     micromq const Gateway = require('micromq/gateway'); //    Gateway const app = new Gateway({ //  ,      microservices: ['users'], //  rabbitmq rabbit: { //     rabbitmq (default: amqp://guest:guest@localhost:5672) url: process.env.RABBIT_URL, }, }); //    /friends & /status   GET app.get(['/friends', '/status'], async (req, res) => { //     users await res.delegate('users'); }); //    app.listen(process.env.PORT);

Bagaimana cara kerjanya:

Server mulai, ia mulai mendengarkan port dan menerima permintaan
Pengguna mengirim permintaan ke https://mysite.com/friends
Gateway, sesuai dengan logika yang kami jelaskan, mendelegasikan permintaan:
3.1 Pesan sedang dikirim (parameter permintaan, tajuk, informasi koneksi, dll.) Ke antrian RabbitMQ
3.2. Microservice mendengarkan antrian ini, memproses permintaan baru
3.3. Microservice mengirimkan respons ke antrian
3.4. Gateway mendengarkan antrian respons, menerima respons dari layanan mikro
3.5. Gateway mengirim respons ke klien
Pengguna menerima respons

Kami menulis layanan microser

 //   MicroService     micromq const MicroMQ = require('micromq'); //    MicroService const app = new MicroMQ({ //   (    ,    Gateway) name: 'users', //  rabbitmq rabbit: { //     rabbitmq (default: amqp://guest:guest@localhost:5672) url: process.env.RABBIT_URL, }, }); //   /friends   GET app.get('/friends', (req, res) => { //  json  res.json([ { id: 1, name: 'Mikhail Semin', }, { id: 2, name: 'Ivan Ivanov', }, ]); }); //   /status   GET app.get('/status', (req, res) => { //  json  res.json({ text: 'Thinking...', }); }); //     app.start();

Bagaimana cara kerjanya:

Layanan Microsoft dimulai, mulai mendengarkan antrian permintaan yang akan ditulis Gateway.
Layanan Microsoft menerima permintaan, memprosesnya, menjalankan semua middlewares yang tersedia
Microservice mengirim respons ke Gateway
3.1. Pesan sedang dikirim (tajuk, badan respons kode HTTP) ke antrian RabbitMQ
3.2. Gateway mendengarkan antrian ini, menerima pesan, menemukan klien kepada siapa ia perlu mengirim respons
3.3 Gateway mengirim respons ke klien

Migrasi monolit ke arsitektur layanan mikro

Misalkan kita sudah memiliki aplikasi ekspres, dan kami ingin mulai porting ke layanan microser.

Ini terlihat seperti ini:

 const express = require('express'); const app = express(); app.get('/balance', (req, res) => { res.json({ amount: 500, }); }); app.get('/friends', (req, res) => { res.json([ { id: 1, name: 'Mikhail Semin', }, { id: 2, name: 'Ivan Ivanov', }, ]); }); app.get('/status', (req, res) => { res.json({ text: 'Thinking...', }); }); app.listen(process.env.PORT);

Kami ingin mendapatkan 2 titik akhir: / teman dan / status. Apa yang perlu kita lakukan untuk ini?

Tarik logika bisnis ke dalam layanan mikro
Laksanakan pendelegasian permintaan untuk dua titik akhir ini ke layanan mikro
Dapatkan respons dari layanan microser
Kirim respons ke klien

Pada contoh di atas, ketika kami membuat microservice pengguna, kami menerapkan dua metode / teman dan / status, yang melakukan hal yang sama seperti yang dilakukan monolith kami.

Untuk permintaan proxy ke microservice dari gateway, kami akan menggunakan paket yang sama dengan menghubungkan middleware ke aplikasi ekspres kami:

 const express = require('express'); //   Gateway     micromq const Gateway = require('micromq/gateway'); const app = express(); //    Gateway const gateway = new Gateway({ //   (    ,    Gateway) microservices: ['users'], //  rabbitmq rabbit: { //     rabbitmq (default: amqp://guest:guest@localhost:5672) url: process.env.RABBIT_URL, }, }); //  middleware  ,      app.use(gateway.middleware()); //    ,          app.get('/balance', (req, res) => { res.json({ amount: 500, }); }); //    /friends & /status   GET app.get(['/friends', '/status'], async (req, res) => { //     users //  res.delegate   middleware,     await res.delegate('users'); }); //   app.listen(process.env.PORT);

Ini bekerja dengan cara yang sama seperti pada contoh di atas, di mana kami menulis Gateway yang bersih. Dalam contoh ini, satu-satunya perbedaan adalah bahwa bukan Gateway yang menerima permintaan, tetapi monolith yang ditulis secara tertulis.

Apa selanjutnya

RPC (panggilan aksi jarak jauh) dari layanan microser ke monolith / gateway (misalnya, untuk otorisasi)
Berkomunikasi antara layanan microser melalui antrian RabbitMQ untuk informasi lebih lanjut, karena setiap layanan microser memiliki database sendiri

Saya sudah mengatakan ini dalam artikel "Belajar Berkomunikasi Antar Layanan Mikro di Node.js melalui RabbitMQ" .

Kami sedang menulis microservice pertama di Node.js dengan komunikasi melalui RabbitMQ