Geekly articles weekly

Organisasi interaksi microservices yang efektif

Baru-baru ini, arsitektur microservice telah menikmati popularitas. Kinerja dan skalabilitas solusi berdasarkan solusi tersebut dapat bergantung pada bagaimana interaksi layanan mikro. Interaksi ini mungkin sinkron atau asinkron. Materi, terjemahan yang kami sajikan untuk perhatian Anda hari ini, membahas metode sinkron untuk interaksi layanan mikro. Yaitu, kami akan fokus pada studi dua teknologi: HTTP / 1.1 dan gRPC. Teknologi pertama diwakili oleh panggilan HTTP standar. Yang kedua didasarkan pada penggunaan kerangka kerja RPC berkinerja tinggi Google. Penulis artikel menyarankan untuk melihat kode yang diperlukan untuk mengimplementasikan interaksi layanan microser menggunakan HTTP / 1.1 dan gRPC, mengambil pengukuran kinerja, dan memilih teknologi yang memungkinkan mengatur pertukaran data antara layanan microser dengan cara terbaik.



Aplikasi normal


Mari kita mulai dari yang kecil dan membuat sistem dua layanan microser yang dapat saling berinteraksi. Harap dicatat bahwa mode klaster tidak digunakan di sini. Berikut adalah diagram aplikasi kita.


Arsitektur Aplikasi Khas

Aplikasi terdiri dari komponen-komponen berikut:

  • Alat Pengujian Sistem: jMeter .
  • Layanan A: Layanan mikro yang mengeksekusi permintaan untuk layanan B dan mengembalikan respons yang diterima darinya.
  • Layanan B (Layanan B): layanan mikro yang mengirimkan data JSON statis sebagai tanggapan atas permintaan setelah penundaan 10 milidetik yang digunakan untuk semua API.
  • Mesin virtual (VM 1 dan VM 2): Amazon EC2 t2.xlarge instance.

▍HTTP / 1.1


HTTP / 1.1 adalah teknologi standar untuk mengatur interaksi layanan microser, yang digunakan saat menggunakan perpustakaan HTTP seperti aksioma atau superagent .

Berikut adalah kode layanan B yang mengimplementasikan API sistem kami:

server.route({  method: 'GET',  path: '/',  handler: async (request, h) => {    const response = await new Promise((resolve) => {      setTimeout(() => {        resolve({          id: 1,          name: 'Abhinav Dhasmana',          enjoys_coding: true,        });      }, 10);    });    return h.response(response);  }, });

Berikut adalah kode untuk layanan A yang mengakses layanan B menggunakan HTTP / 1.1:

 server.route({ method: 'GET', path: '/', handler: async (request, h) => { try { const response = await Axios({ url: 'http://localhost:8001/', method: 'GET', }); return h.response(response.data); } catch (err) { throw Boom.clientTimeout(err); } }, });

Dengan menjalankan layanan microser ini, kita dapat memanfaatkan jMeter untuk menjalankan tes kinerja. Kami akan mencari tahu bagaimana sistem berperilaku ketika bekerja dengan 50 pengguna, yang masing-masing melakukan 2000 permintaan. Seperti yang dapat dilihat pada gambar berikut, median hasil pengukuran adalah 37 ms.


Hasil Penelitian dari Sistem Mode Normal Menggunakan HTTP / 1.1 Menggunakan jMeter

▍gRPC


gRPC menggunakan teknologi Protokol Buffer secara default. Oleh karena itu, menggunakan gRPC, selain kode dua layanan, kita perlu menulis kode proto-file, yang menggambarkan antarmuka antar modul sistem.

 syntax = "proto3"; service SampleDataService { rpc GetSampleData (Empty) returns (SampleData) {} } message SampleData { int32 id = 1; string name = 2; bool enjoys_coding = 3; } message Empty {}

Sekarang, karena sekarang kami berencana untuk menggunakan gRPC, kami perlu menulis ulang kode layanan B:

 const grpc = require('grpc'); const proto = grpc.load('serviceB.proto'); const server = new grpc.Server(); const GetSampleData = (call, callback) => { setTimeout(() => {   callback(null, {     id: 1,     name: 'Abhinav Dhasmana',     enjoys_coding: true,   }); }, 10); }; server.addService(proto.SampleDataService.service, { GetSampleData, }); const port = process.env.PORT; console.log('port', port); server.bind(`0.0.0.0:${port}`, grpc.ServerCredentials.createInsecure()); server.start(); console.log('grpc server is running');

Perhatikan beberapa fitur kode ini:

  • Perintah const server = new grpc.Server(); kami membuat server grpc.
  • server.addService(proto... perintah server.addService(proto... kami menambahkan layanan ke server.
  • Perintah server.bind(`0.0.0.0:${port}... digunakan untuk mengikat port dan kredensial.

Sekarang tulis ulang layanan A menggunakan gRPC:

 const protoPath = `${__dirname}/../serviceB/serviceB.proto`; const proto = grpc.load(protoPath); const client = new proto.SampleDataService('localhost:8001', grpc.credentials.createInsecure()); const getDataViagRPC = () => new Promise((resolve, reject) => { client.GetSampleData({}, (err, response) => {   if (!response.err) {     resolve(response);   } else {     reject(err);   } }); }); server.route({ method: 'GET', path: '/', handler: async (request, h) => {   const allResults = await getDataViagRPC();   return h.response(allResults); }, });

Di antara fitur-fitur kode ini adalah sebagai berikut:

  • const client = new proto.SampleDataService... perintah const client = new proto.SampleDataService... kami membuat klien grpc.
  • Panggilan jarak jauh dilakukan menggunakan perintah client.GetSampleData({}...

Sekarang mari kita menguji apa yang kita dapatkan dengan jMeter.


Hasil Penelitian dari Sistem Mode Normal Menggunakan gRPC Menggunakan jMeter

Setelah perhitungan sederhana, Anda dapat mengetahui bahwa solusi menggunakan gRPC adalah 27% lebih cepat daripada solusi menggunakan HTTP / 1.1.

Aplikasi cluster


Berikut adalah diagram aplikasi yang mirip dengan yang baru saja kami teliti tetapi bekerja dalam mode klaster.


Arsitektur Aplikasi Mode Cluster

Jika Anda membandingkan arsitektur ini dengan yang sebelumnya dipertimbangkan, perubahan berikut dapat dicatat:

  • Ada load balancer (Load Balancer), yang menggunakan NGINX .
  • Layanan B sekarang hadir dalam tiga contoh yang mendengarkan pada port yang berbeda.

Arsitektur serupa adalah tipikal untuk proyek nyata.

Menjelajahi HTTP / 1.1 dan gRPC di lingkungan baru.

▍HTTP / 1.1


Saat menggunakan layanan microser yang menggunakan HTTP / 1.1 di lingkungan yang berkerumun, kode mereka tidak harus diubah. Anda hanya perlu mengkonfigurasi nginx untuk mengatur keseimbangan lalu lintas layanan B. Dalam kasus kami, untuk melakukan ini, Anda perlu membawa file /etc/nginx/sites-available/default ke form ini:

 upstream httpservers {  server ip_address:8001;  server ip_address:8002;  server ip_address:8003; } server {  listen 80;  location / {     proxy_pass http://httpservers;  } }

Sekarang mari kita jalankan apa yang kita miliki dan lihat hasil pengujian sistem menggunakan jMeter.


Hasil penelitian untuk sistem berbasis cluster menggunakan HTTP / 1.1 menggunakan jMeter

Median dalam hal ini adalah 41 ms.

▍gRPC


Dukungan GRPC muncul di nginx 1.13.10 . Oleh karena itu, kita memerlukan versi nginx terbaru, untuk instalasi yang perintah sudo apt-get install nginx tidak cocok.

Juga di sini kita tidak menggunakan Node.js dalam mode cluster , karena gRPC tidak didukung dalam mode ini.

Untuk menginstal versi nginx terbaru, gunakan urutan perintah berikut:

 sudo apt-get install -y software-properties-common sudo add-apt-repository ppa:nginx/stable sudo apt-get update sudo apt-get install nginx

Selain itu, kami akan memerlukan sertifikat SSL. Sertifikat yang ditandatangani sendiri dapat dibuat menggunakan openSSL :

 openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \ -keyout localhost-privatekey.pem -out localhost-certificate.pem

Untuk menggunakan gRPC, Anda perlu mengedit file / etc/nginx/sites-available/default :

 upstream httpservers {  server ip_address:8001;  server ip_address:8002;  server ip_address:8003; } server {  listen 80;  location / {     proxy_pass http://httpservers;  } }

Sekarang semuanya siap untuk menguji solusi cluster gRPC menggunakan jMeter.


Hasil dari sistem mode kluster menggunakan gRPC menggunakan jMeter

Dalam hal ini, median adalah 28 ms, yang 31% lebih cepat dibandingkan dengan indikator yang sama yang diperoleh ketika memeriksa solusi HTTP / 1.1 berkerumun.

Ringkasan


Hasil penelitian menunjukkan bahwa aplikasi berbasis microservice yang menggunakan gRPC adalah sekitar 30% lebih produktif daripada aplikasi serupa yang menggunakan HTTP / 1.1 untuk bertukar data antara layanan microser. Kode sumber untuk proyek yang dibahas dalam artikel ini dapat ditemukan di sini .

Pembaca yang budiman! Jika Anda mengembangkan layanan microser, silakan bicarakan bagaimana Anda mengatur pertukaran data di antara mereka.

Source: https://habr.com/ru/post/id421579/

More articles:


All Articles