Bagaimana Streaming gRPC Dapat Membuat API Anda Lebih Cepat dan Lebih Andal

Jika Anda mencari cara untuk meningkatkan kinerja dan keandalan API Anda, Anda mungkin ingin mempertimbangkan untuk menggunakan gRPC streaming. gRPC adalah kerangka kerja modern dan sumber terbuka yang memungkinkan Anda membuat layanan yang efisien dan terukur menggunakan buffer protokol dan HTTP/2. Streaming adalah salah satu fitur utama gRPC yang memungkinkan Anda mengirim dan menerima banyak pesan dalam satu koneksi, tanpa menunggu setiap respons.

Dalam postingan blog ini, saya akan menjelaskan apa itu gRPC streaming, cara kerjanya, dan mengapa bermanfaat untuk API Anda. Saya juga akan menunjukkan cara menggunakan alat bernama apidog untuk menguji dan men-debug layanan gRPC streaming Anda. Pada akhir postingan ini, Anda akan memiliki pemahaman yang lebih baik tentang gRPC streaming dan cara menggunakannya dalam proyek Anda.

button

Apa itu gRPC Streaming?

gRPC streaming adalah cara mengirim dan menerima banyak pesan dalam satu koneksi, menggunakan HTTP/2 sebagai protokol transport yang mendasarinya. HTTP/2 adalah versi HTTP yang lebih baru yang mendukung multipleksing, yang berarti bahwa beberapa permintaan dan respons dapat dikirim melalui koneksi TCP yang sama, tanpa saling memblokir. Ini mengurangi overhead pembukaan dan penutupan koneksi, dan meningkatkan latensi dan throughput API Anda.

gRPC streaming memungkinkan Anda menggunakan empat jenis pola komunikasi:

Unary: Ini adalah pola yang paling sederhana dan paling umum, di mana klien mengirim satu permintaan dan menerima satu respons dari server. Ini mirip dengan permintaan dan respons HTTP biasa.
Server streaming: Dalam pola ini, klien mengirim satu permintaan dan menerima beberapa respons dari server. Server dapat melakukan streaming respons saat tersedia, tanpa menunggu klien memintanya. Ini berguna untuk skenario di mana server perlu mengirim sejumlah besar data ke klien, atau di mana server perlu mengirim pembaruan ke klien secara waktu nyata.
Client streaming: Dalam pola ini, klien mengirim beberapa permintaan dan menerima satu respons dari server. Klien dapat melakukan streaming permintaan saat tersedia, tanpa menunggu server mengakuinya. Ini berguna untuk skenario di mana klien perlu mengunggah sejumlah besar data ke server, atau di mana klien perlu mengirim beberapa parameter ke server dalam satu permintaan.
Bidirectional streaming: Dalam pola ini, klien dan server dapat mengirim dan menerima beberapa pesan di kedua arah. Pesan dapat dikirim dan diterima secara independen, tanpa mengikuti urutan yang ketat. Ini berguna untuk skenario di mana klien dan server perlu melakukan percakapan yang berkelanjutan dan dinamis, atau di mana klien dan server perlu bertukar data secara peer-to-peer.

Bagaimana Cara Kerja gRPC Streaming?

gRPC streaming bekerja dengan menggunakan buffer protokol dan HTTP/2 untuk menyandikan dan mengangkut pesan. Buffer protokol adalah format serialisasi biner yang memungkinkan Anda menentukan struktur dan jenis pesan Anda dalam file skema. Buffer protokol ringkas, cepat, dan mudah digunakan, serta mendukung kompatibilitas lintas bahasa dan lintas platform.

HTTP/2 adalah protokol biner yang mendukung multipleksing, kompresi, dan enkripsi. HTTP/2 memungkinkan Anda mengirim beberapa pesan melalui koneksi yang sama, menggunakan frame sebagai unit dasar komunikasi. Setiap frame memiliki header yang menunjukkan jenis, panjang, dan ID stream frame. ID stream adalah pengidentifikasi unik yang mengaitkan frame dengan permintaan atau respons tertentu. HTTP/2 juga mendukung kontrol aliran dan penanganan kesalahan, yang membantu memastikan keandalan dan efisiensi API Anda.

Untuk menggunakan gRPC streaming, Anda perlu menentukan layanan dan pesan Anda dalam file buffer protokol, menggunakan sintaks gRPC. Misalnya, berikut adalah layanan sederhana yang mendukung panggilan unary dan server streaming:

syntax = "proto3";

package example;

// A service that returns the current time
service TimeService {
  // Unary call: returns the current time
  rpc GetTime (GetTimeRequest) returns (GetTimeResponse) {}

  // Server streaming call: returns the current time every second
  rpc StreamTime (StreamTimeRequest) returns (stream StreamTimeResponse) {}
}

// A message that represents a request to get the current time
message GetTimeRequest {
  // The timezone of the requested time
  string timezone = 1;
}

// A message that represents a response with the current time
message GetTimeResponse {
  // The current time in ISO 8601 format
  string time = 1;
}

// A message that represents a request to stream the current time
message StreamTimeRequest {
  // The timezone of the requested time
  string timezone = 1;
}

// A message that represents a response with the current time
message StreamTimeResponse {
  // The current time in ISO 8601 format
  string time = 1;
}

Untuk mengimplementasikan layanan Anda, Anda perlu menggunakan pustaka gRPC untuk bahasa pemrograman pilihan Anda. gRPC mendukung banyak bahasa, seperti C#, C++, Go, Java, Node.js, Python, Ruby, dan lainnya. Setiap bahasa memiliki API dan konvensi sendiri untuk membuat dan menggunakan layanan gRPC. Misalnya, berikut adalah implementasi sederhana dari TimeService di Python:

import grpc
import time
from concurrent import futures
from example_pb2 import GetTimeRequest, GetTimeResponse, StreamTimeRequest, StreamTimeResponse
from example_pb2_grpc import TimeServiceServicer, add_TimeServiceServicer_to_server

# A class that implements the TimeService
class TimeService(TimeServiceServicer):
  # Unary call: returns the current time
  def GetTime(self, request, context):
    # Get the timezone from the request
    timezone = request.timezone
    # Get the current time in the requested timezone
    time = get_current_time(timezone)
    # Create and return a response with the current time
    response = GetTimeResponse(time=time)
    return response

  # Server streaming call: returns the current time every second
  def StreamTime(self, request, context):
    # Get the timezone from the request
    timezone = request.timezone
    # Loop indefinitely
    while True:
      # Get the current time in the requested timezone
      time = get_current_time(timezone)
      # Create and yield a response with the current time
      response = StreamTimeResponse(time=time)
      yield response
      # Wait for one second
      time.sleep(1)

# A function that returns the current time in a given timezone
def get_current_time(timezone):
  # TODO: implement this function
  pass

# Create a gRPC server
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
# Add the TimeService to the server
add_TimeServiceServicer_to_server(TimeService(), server)
# Start the server on port 50051
server.add_insecure_port('[::]:50051')
server.start()
# Wait for termination
server.wait_for_termination()

Untuk menggunakan layanan Anda, Anda perlu menggunakan klien gRPC untuk bahasa pemrograman pilihan Anda. Klien gRPC menggunakan stub untuk berkomunikasi dengan server gRPC. Stub dihasilkan dari file buffer protokol, dan mereka menyediakan metode yang sesuai dengan metode layanan. Misalnya, berikut adalah klien sederhana yang memanggil TimeService di Python:

import grpc
from example_pb2 import GetTimeRequest, StreamTimeRequest
from example_pb2_grpc import TimeServiceStub

# Create a gRPC channel to the server
channel = grpc.insecure_channel('localhost:50051')
# Create a stub for the TimeService
stub = TimeServiceStub(channel)

# Unary call: get the current time in UTC
request = GetTimeRequest(timezone='UTC')
response = stub.GetTime(request)
print(f'The current time in UTC is {response.time}')

# Server streaming call: stream the current time in PST
request = StreamTimeRequest(timezone='PST')
responses = stub.StreamTime(request)
for response in responses:
  print(f'The current time in PST is {response.time}')

Mengapa Menggunakan gRPC Streaming?

gRPC streaming menawarkan banyak manfaat untuk API Anda, seperti:

Kinerja: gRPC streaming mengurangi overhead pembukaan dan penutupan koneksi, dan memungkinkan Anda mengirim dan menerima beberapa pesan dalam satu koneksi. Ini meningkatkan latensi dan throughput API Anda, dan membuatnya lebih responsif dan efisien.
Keandalan: gRPC streaming menggunakan HTTP/2, yang mendukung kontrol aliran dan penanganan kesalahan. Kontrol aliran memungkinkan Anda mengontrol laju transfer data, dan menghindari kemacetan dan luapan buffer. Penanganan kesalahan memungkinkan Anda mendeteksi dan memulihkan dari kesalahan, dan mengakhiri koneksi dengan baik. Fitur-fitur ini membantu memastikan keandalan dan ketahanan API Anda, dan mencegah kehilangan dan kerusakan data.
Fleksibilitas: gRPC streaming memungkinkan Anda menggunakan pola komunikasi yang berbeda, tergantung pada kasus penggunaan dan persyaratan Anda. Anda dapat memilih antara unary, server streaming, client streaming, dan bidirectional streaming, dan beralih di antara mereka dengan mudah. Ini memberi Anda lebih banyak fleksibilitas dan kontrol atas API Anda, dan memungkinkan Anda menangani berbagai skenario dan tantangan.
Kesederhanaan: gRPC streaming menyederhanakan pengembangan dan pemeliharaan API Anda, dengan menggunakan buffer protokol dan pustaka gRPC. Buffer protokol memungkinkan Anda menentukan layanan dan pesan Anda dengan cara yang jelas dan ringkas, dan menghasilkan kode untuk berbagai bahasa dan platform. Pustaka gRPC memungkinkan Anda membuat dan menggunakan layanan Anda menggunakan API yang konsisten dan intuitif, dan menangani detail tingkat rendah streaming dan HTTP/2 untuk Anda. Ini membuat kode Anda lebih mudah dibaca, digunakan kembali, dan dipindahkan, dan mengurangi kompleksitas dan boilerplate API Anda.

Bagaimana Cara Menguji dan Men-debug Layanan gRPC Streaming?

Menguji dan men-debug layanan gRPC streaming bisa jadi menantang, terutama jika Anda menggunakan bahasa dan platform yang berbeda. Untungnya, ada alat yang dapat membantu Anda dalam hal itu: Apidog.

button

Apidog adalah alat berbasis web yang memungkinkan Anda menguji dan men-debug layanan gRPC streaming Anda, menggunakan antarmuka yang sederhana dan intuitif. apidog mendukung banyak bahasa, seperti C#, C++, Go, Java, Node.js, Python, Ruby, dan lainnya. Apidog juga mendukung pola komunikasi yang berbeda, seperti unary, server streaming, client streaming, dan bidirectional streaming.

Dengan apidog, Anda dapat:

Menghubungkan ke server gRPC Anda, menggunakan saluran yang aman atau tidak aman, dan menentukan layanan dan metode yang ingin Anda panggil.
Mengirim permintaan ke server gRPC Anda, menggunakan format JSON atau biner, dan menentukan metadata dan tenggat waktu untuk setiap permintaan.
Menerima respons dari server gRPC Anda, menggunakan format JSON atau biner, dan melihat metadata dan status untuk setiap respons.
Memantau kinerja dan status koneksi gRPC Anda, menggunakan grafik dan bagan yang menunjukkan latensi, throughput, dan kesalahan permintaan dan respons Anda.
Men-debug layanan gRPC Anda, menggunakan log dan jejak yang menunjukkan detail dan kesalahan permintaan dan respons Anda, dan memungkinkan Anda memfilter dan mencari peristiwa tertentu.

Apidog adalah alat yang ampuh dan mudah digunakan yang dapat membantu Anda menguji dan men-debug layanan gRPC streaming Anda, dan memastikan bahwa mereka berfungsi seperti yang diharapkan.

Kesimpulan

gRPC streaming adalah fitur yang dapat membuat API Anda lebih cepat dan lebih andal, dengan memungkinkan Anda mengirim dan menerima beberapa pesan dalam satu koneksi, menggunakan HTTP/2 dan buffer protokol. gRPC streaming juga menawarkan fleksibilitas dan kesederhanaan, dengan memungkinkan Anda menggunakan pola komunikasi dan bahasa yang berbeda, dan dengan memberi Anda API yang konsisten dan intuitif. gRPC streaming adalah pilihan yang bagus untuk API Anda, terutama jika Anda perlu menangani sejumlah besar data, pembaruan waktu nyata, atau interaksi yang kompleks.

Jika Anda ingin mempelajari lebih lanjut tentang gRPC streaming, Anda dapat melihat dokumentasi resmi di https://grpc.io/docs. Jika Anda ingin menguji dan men-debug layanan gRPC streaming Anda, Anda dapat menggunakan Apidog, alat berbasis web yang memungkinkan Anda menghubungkan, mengirim, menerima, memantau, dan men-debug layanan gRPC streaming Anda, menggunakan antarmuka yang sederhana dan intuitif. Anda dapat mencoba apidog secara gratis.

button