Perbedaan gRPC dan RESTful

Apa itu gRPC ? bagaimana jika gRPC vs REST ?

gRPC adalah kerangka kerja (framework) open-source yang dikembangkan oleh Google untuk memungkinkan komunikasi jaringan efisien antara aplikasi yang berjalan di lingkungan yang berbeda. gRPC menggunakan protocol buffers sebagai format data untuk pesan yang ditransmisikan dan mendukung berbagai bahasa pemrograman seperti C++, Java, Python, dan lainnya.

gRPC memungkinkan pengembang untuk membangun aplikasi client-server dengan mudah dan efisien, dengan menggunakan prosedur pemanggilan jarak jauh (remote procedure call atau RPC) untuk memanggil fungsi yang didefinisikan pada server dari aplikasi client.

Hal ini memungkinkan pengembang untuk membuat aplikasi terdistribusi yang dapat berjalan pada berbagai platform dan bahasa pemrograman, gRPC juga menyediakan fitur-fitur seperti streaming data, penggunaan tekanan (compression), dan manajemen kesalahan yang memudahkan pengembangan aplikasi jaringan yang kompleks.

Apps ternama dengan gRPC dan perbedaannya dengan JSON

Beberapa aplikasi terkenal yang menggunakan gRPC diantaranya adalah Netflix, Uber, dan Square.

Perbedaan utama antara gRPC dan JSON adalah pada format data yang digunakan untuk pertukaran pesan. gRPC menggunakan protocol buffers, sedangkan JSON menggunakan format teks yang lebih mudah dibaca manusia. Meskipun JSON lebih mudah dibaca manusia dan lebih umum digunakan, gRPC memiliki beberapa keunggulan:

Performa yang lebih cepat: Protocol buffers lebih efisien dalam penggunaan bandwidth dan parsing data, sehingga gRPC dapat mengirim dan menerima pesan dengan lebih cepat dan membutuhkan penggunaan bandwidth yang lebih sedikit.

Kode yang mudah digunakan: gRPC menyediakan kode yang mudah digunakan dan dapat digenerate secara otomatis, sehingga memudahkan pengembangan aplikasi client-server yang terdistribusi.

Dukungan untuk streaming data: gRPC mendukung streaming data, sehingga dapat digunakan untuk mengirim data dalam jumlah besar secara bertahap dan real-time.

Multi-platform dan multi-bahasa: gRPC dapat digunakan untuk menghubungkan aplikasi yang berjalan pada berbagai platform dan bahasa pemrograman yang berbeda.

Secara umum, penggunaan gRPC atau JSON tergantung pada kebutuhan aplikasi dan preferensi pengembang. Jika performa dan efisiensi bandwidth menjadi prioritas, maka gRPC bisa menjadi pilihan yang lebih baik. Namun, jika kebutuhan aplikasi lebih sederhana dan data yang ditransmisikan tidak terlalu besar, JSON bisa menjadi pilihan yang lebih tepat.

Contoh perbedaan gRPC dan JSON

Perbedaan struktur antara aplikasi menggunakan JSON dan gRPC terletak pada format data yang digunakan untuk pertukaran pesan.

JSON menggunakan format teks yang mudah dibaca manusia dan terdiri dari pasangan key-value yang dikelompokkan dalam objek (object) atau array. Contoh struktur JSON:


{
"name": "John",
"age": 30,
"email": "[email protected]",
"phones": [
{
"number": "1234567890",
"type": "home"
},
{
"number": "9876543210",
"type": "work"
}
]
}

Sedangkan gRPC menggunakan protocol buffers, yaitu sebuah format data biner yang lebih efisien dalam penggunaan bandwidth dan parsing data. Protocol buffers terdiri dari definisi pesan (message)
dan field-field yang dimiliki oleh pesan tersebut. Contoh struktur protocol buffers:


message Person {
string name = 1;
int32 age = 2;
repeated Phone phones = 3;

message Phone {
string number = 1;
string type = 2;
}
}

Dalam contoh di atas, terdapat definisi pesan "Person" yang memiliki field "name" dengan tipe data string dan nomor field 1, field "age" dengan tipe data integer dan nomor field 2, serta field "phones" dengan tipe data "repeated Phone" yang merupakan array dari pesan "Phone". Pesan "Phone" sendiri memiliki field "number" dan "type" dengan tipe data string.

Perbedaan struktur ini akan mempengaruhi cara aplikasi mengirim dan menerima data, sehingga perlu diperhatikan dalam memilih format data yang tepat untuk aplikasi yang dibangun.

Untuk mengintegrasikan gRPC pada aplikasi Django, dapat dilakukan dengan menggunakan package django-grpc-framework yang dapat diinstall melalui pip.

Berikut ini adalah contoh sederhana implementasi client-server menggunakan gRPC pada aplikasi Django:

Install django-grpc-framework dengan perintah:

pip install django-grpc-framework

Buat file proto dengan nama helloworld.proto yang berisi definisi pesan dan service yang akan digunakan:


syntax = "proto3";

package helloworld;

message HelloRequest {
string name = 1;
}

message HelloReply {
string message = 1;
}

service Greeter {
rpc SayHello (HelloRequest) returns (HelloReply) {}
}

Generate kode gRPC dari file proto dengan perintah:


python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

Tambahkan konfigurasi gRPC pada settings.py:

GRPC_APPLICATIONS = (
{
'APPLICATION': 'helloworld',
'SRV_ADDR': 'localhost:50051',
'PROTOS': [
'helloworld.proto',
],
},
)

Implementasikan service yang didefinisikan pada file proto pada views.py:

from django_grpc_framework import generics
from helloworld.grpc_pb2 import HelloReply
from helloworld.grpc_pb2 import HelloRequest
from helloworld.grpc_pb2_grpc import GreeterServicer


class GreeterService(GreeterServicer):
def SayHello(self, request, context):
return HelloReply(message=f'Hello, {request.name}!')

Tambahkan URL pattern pada urls.py:

from django.urls import path
from django_grpc_framework import services

from .views import GreeterService


grpc_application = services.build_application('helloworld')

urlpatterns = [
path('grpc', grpc_application),
]

Jalankan server dengan perintah:

python manage.py runserver

Jalankan client untuk memanggil service dengan perintah:


python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

from grpc import insecure_channel
from helloworld.grpc_pb2_grpc import GreeterStub
from helloworld.grpc_pb2 import HelloRequest

channel = insecure_channel('localhost:50051')
stub = GreeterStub(channel)

response = stub.SayHello(HelloRequest(name='John'))
print(response.message)

Dalam contoh di atas, terdapat satu service yang didefinisikan pada file proto yaitu "Greeter" yang memiliki satu method yaitu "SayHello" yang akan membalas pesan dengan format
"Hello, {name}!".

Kemudian pada views.py, service tersebut diimplementasikan dengan menggunakan class "GreeterService". Pada urls.py, URL pattern untuk gRPC diaktifkan dengan memanggil fungsi "build_application" dari package django_grpc_framework. Terakhir, pada client, dilakukan pemanggilan method "SayHello" pada service "GreeterStub" dengan parameter "HelloRequest(name='John')".


GreeterStub adalah sebuah objek stub yang dibuat berdasarkan definisi service yang terdapat pada file proto, dalam contoh sebelumnya pada service "Greeter". Objek GreeterStub digunakan pada client untuk memanggil method yang didefinisikan pada service "Greeter".

GreeterStub sendiri adalah salah satu bagian dari kode yang dihasilkan dari proses generate kode gRPC, yang menghasilkan class-class untuk setiap service dan pesan yang didefinisikan pada file proto. Ketika proses generate kode selesai, class-class tersebut dapat digunakan pada client maupun server untuk mengimplementasikan service dan berkomunikasi dengan protokol gRPC.

gRPC dan Django REST Framework (DRF) adalah dua kerangka kerja yang berbeda untuk membangun API pada aplikasi Django. DRF menggunakan format JSON untuk pertukaran pesan antara client dan server, sedangkan gRPC menggunakan protocol buffers.

DRF memiliki fokus pada pengembangan API RESTful, sementara gRPC memiliki fokus pada pengembangan aplikasi terdistribusi yang efisien dan cepat. Meskipun keduanya dapat digunakan untuk membangun API pada aplikasi Django, pemilihan kerangka kerja yang tepat akan tergantung pada kebutuhan aplikasi yang dibangun.

Dalam beberapa kasus, gRPC dapat menjadi pilihan yang lebih baik ketika performa dan efisiensi bandwidth menjadi prioritas, sedangkan DRF dapat menjadi pilihan yang lebih tepat jika API yang dibangun membutuhkan fitur-fitur RESTful seperti caching, autentikasi, dan authorisasi. Namun, keputusan tersebut perlu dipertimbangkan secara hati-hati tergantung pada kebutuhan aplikasi yang dibangun.

Kekurangan gRPC dan RESTful

Berikut adalah beberapa kelemahan atau kekurangan gRPC dan RESTful:

Kekurangan gRPC:

Penggunaan protocol buffers yang lebih kompleks daripada format JSON yang digunakan oleh RESTful dapat mengakibatkan kurva belajar yang lebih curam bagi pengembang yang belum terbiasa dengan format tersebut.
Karena protocol buffers menggunakan format biner, debugging pesan yang ditransmisikan antara client dan server dapat menjadi lebih sulit.
gRPC hanya mendukung protokol HTTP/2, yang tidak kompatibel dengan beberapa aplikasi dan infrastruktur jaringan yang lebih lama.

Kekurangan RESTful:

Karena menggunakan format JSON yang lebih mudah dibaca oleh manusia, overhead untuk parsing data dapat menjadi lebih besar daripada protocol buffers yang digunakan oleh gRPC.
Memiliki fitur yang kompleks seperti caching, autentikasi, dan authorisasi dapat menyebabkan kompleksitas kode dan performa yang menurun.
RESTful sering kali mengharuskan pengembang untuk merancang endpoint yang spesifik untuk setiap tipe permintaan, yang dapat membuat pengembangan dan pemeliharaan API menjadi lebih rumit.

Pilihan antara gRPC dan RESTful akan tergantung pada kebutuhan aplikasi yang dibangun. Jika aplikasi membutuhkan performa yang lebih tinggi dan data yang besar, gRPC mungkin menjadi pilihan yang lebih baik. Jika API harus berjalan di lingkungan yang berbeda atau lebih mudah dibaca oleh manusia, RESTful mungkin menjadi pilihan yang lebih tepat. Namun, perlu diingat bahwa setiap kerangka kerja memiliki kelebihan dan kekurangan tersendiri, sehingga harus dipertimbangkan dengan cermat tergantung pada kebutuhan aplikasi yang dibangun.

Kelebihan gRPC dan RESTful

Kelebihan gRPC:

Penggunaan protocol buffers yang efisien dalam penggunaan bandwidth dan parsing data, sehingga dapat meningkatkan performa aplikasi dan mengurangi penggunaan sumber daya.
Mendukung streaming data, sehingga dapat digunakan untuk mengirim data dalam jumlah besar secara bertahap dan real-time.
Dapat digunakan pada berbagai bahasa pemrograman dan platform yang berbeda.
Mendukung protokol HTTP/2, yang memungkinkan koneksi yang lebih cepat dan efisien.

Kelebihan RESTful:

Mudah dipahami dan dibaca oleh manusia karena menggunakan format JSON yang sederhana.
Lebih mudah dikonsumsi oleh aplikasi yang berbeda karena tidak bergantung pada bahasa pemrograman tertentu.
Lebih mudah untuk membangun API yang bersifat RESTful, karena fitur caching, autentikasi, dan authorisasi sudah terintegrasi pada kerangka kerja.
Mudah diimplementasikan pada lingkungan jaringan yang berbeda.

Pilihan antara gRPC dan RESTful tergantung pada kebutuhan aplikasi yang dibangun. Jika aplikasi membutuhkan performa yang lebih tinggi dan data yang besar, gRPC mungkin menjadi pilihan yang lebih baik.
Jika API harus berjalan di lingkungan yang berbeda atau lebih mudah dibaca oleh manusia, RESTful mungkin menjadi pilihan yang lebih tepat.

Namun, perlu diingat bahwa setiap kerangka kerja memiliki kelebihan dan kekurangan tersendiri, sehingga harus dipertimbangkan dengan cermat tergantung pada kebutuhan aplikasi yang dibangun.