104. Studi Kasus: Client iOS (Swift) dengan gRPC Go Backend

Saat mengembangkan sistem backend modern, penggunaan komunikasi antar aplikasi menjadi sangat vital. Salah satu pendekatan terkini yang banyak dipilih adalah penggunaan gRPC, sebuah framework RPC berbasis protokol buffer (Protobuf) yang efisien dan memiliki performa tinggi. Pada artikel kali ini, saya akan membahas studi kasus membangun komunikasi antara client iOS (menggunakan Swift) dengan backend Go, menggunakan gRPC sebagai protokol komunikasi.

Kita akan membahas alasan pemilihan arsitektur, langkah praktek, serta berbagi contoh kode praktis. Kasus ini cukup sering ditemui dalam pengembangan aplikasi modern yang mengutamakan performa dan maintainability.

Mengapa gRPC?

Sebelum masuk ke studi kasus, mari kita ulas: Kenapa gRPC?
Singkatnya, gRPC menawarkan:

• Efisiensi: Menggunakan Protobuf daripada JSON, lebih kecil dan cepat.
• Interface contract: Protobuf menyediakan strong typing lewat file .proto, sehingga client/backend punya kontrak yang jelas.
• Support berbagai bahasa: Termasuk Go, Swift, Java, dll.
• Streaming: Mendukung komunikasi streaming dua arah realtime.

Mari kita lihat perbedaan gRPC dan REST dalam hal tertentu melalui tabel berikut:

Kasus: Aplikasi Catatan Sederhana

Bayangkan skenario: kita membangun sebuah aplikasi todo-list sederhana.

• Client: iOS App (Swift)
• Backend: Go dengan gRPC

Aplikasi memungkinkan user melakukan CRUD (Create, Read, Update, Delete) catatan.

1. Mendesain Protobuf Contract

Langkah pertama: menuliskan API contract dalam file Protobuf (note.proto).

 1syntax = "proto3";
 2
 3package note;
 4
 5service NoteService {
 6    rpc CreateNote (CreateNoteRequest) returns (CreateNoteResponse);
 7    rpc GetNotes (GetNotesRequest) returns (GetNotesResponse);
 8    rpc DeleteNote (DeleteNoteRequest) returns (DeleteNoteResponse);
 9}
10
11message Note {
12    string id = 1;
13    string title = 2;
14    string content = 3;
15    string created_at = 4;
16}
17
18message CreateNoteRequest {
19    string title = 1;
20    string content = 2;
21}
22
23message CreateNoteResponse {
24    Note note = 1;
25}
26
27message GetNotesRequest {}
28
29message GetNotesResponse {
30    repeated Note notes = 1;
31}
32
33message DeleteNoteRequest {
34    string id = 1;
35}
36
37message DeleteNoteResponse {
38    bool success = 1;
39}

File ini adalah kontrak API yang akan digunakan Go backend dan client iOS.

2. Implementasi Backend: gRPC Go

a. Setup Protobuf & gRPC

Pastikan kamu sudah menginstal protoc , plugin Go, dan modul pendukung:

1go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
2go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Generate kode dari file .proto:

1protoc --go_out=. --go-grpc_out=. note.proto

b. Implementasi Service

Contoh partial implementation:

 1type server struct {
 2    note_pb.UnimplementedNoteServiceServer
 3    notes map[string]*note_pb.Note
 4}
 5
 6func (s *server) CreateNote(ctx context.Context, req *note_pb.CreateNoteRequest) (*note_pb.CreateNoteResponse, error) {
 7    id := uuid.NewString()
 8    now := time.Now().Format(time.RFC3339)
 9    note := &note_pb.Note{
10        Id: id,
11        Title: req.Title,
12        Content: req.Content,
13        CreatedAt: now,
14    }
15    s.notes[id] = note
16    return &note_pb.CreateNoteResponse{Note: note}, nil
17}
18
19// Implement method lain sesuai kontrak

c. Jalankan gRPC Server

1grpcServer := grpc.NewServer()
2note_pb.RegisterNoteServiceServer(grpcServer, &server{notes: map[string]*note_pb.Note{}})
3lis, _ := net.Listen("tcp", ":50051")
4grpcServer.Serve(lis)

Backend Go sudah siap!

3. Client iOS: Swift

a. Integrasi Library

gRPC Swift support dapat melalui Swift Package Manager atau CocoaPods.

1// swift-tools-version: 5.6
2.package(url: "https://github.com/grpc/grpc-swift.git", from: "1.10.0")

b. Generate Swift Code dari Protobuf

Pastikan sudah install plugin Swift:

1brew install grpc-swift
2protoc note.proto --swift_out=. --swift-grpc_out=.

c. Membuat Client dan Memanggil API

 1import GRPC
 2import NIO
 3import Note // hasil generate proto swift
 4
 5let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
 6let channel = try! GRPCChannelPool.with(
 7    target: .host("localhost", port: 50051),
 8    transportSecurity: .plaintext,
 9    eventLoopGroup: group
10)
11let client = Note_NoteServiceClient(channel: channel)
12
13let req = Note_CreateNoteRequest.with {
14    $0.title = "Belajar gRPC"
15    $0.content = "Menghubungkan Swift dengan Go"
16}
17let resp = try! client.createNote(req).response.wait()
18
19print("Berhasil membuat note dengan id \(resp.note.id)")

4. Diagram Alur

Menggambarkan proses data flow dari client ke server.

sequenceDiagram
    participant iOS as iOS App (Swift)
    participant GoGRPC as gRPC Server (Go)
    iOS->>GoGRPC: RPC CreateNote(title, content)
    GoGRPC-->>iOS: Catatan baru + ID
    iOS->>GoGRPC: RPC GetNotes()
    GoGRPC-->>iOS: List catatan

sequenceDiagram
    participant iOS as iOS App (Swift)
    participant GoGRPC as gRPC Server (Go)
    iOS->>GoGRPC: RPC CreateNote(title, content)
    GoGRPC-->>iOS: Catatan baru + ID
    iOS->>GoGRPC: RPC GetNotes()
    GoGRPC-->>iOS: List catatan

5. Simulasi: Membuat dan Mengambil Data

Langkah:

1. iOS app mengirim RPC CreateNote.
2. Server Go menyimpan note, mengembalikan response.
3. iOS app mengirim RPC GetNotes.
4. Server Go mengembalikan daftar semua note.

Hasil simulasi:

6. Tips dan Best Practice

• Versioning: Manfaatkan Protobuf optional field untuk backward compatibility.
• Transport Security: Aktifkan TLS pada produksi.
• Error Handling: Gunakan enum error Protobuf.
• Streaming: Gunakan streaming untuk real-time sync jika dibutuhkan.

7. Kesimpulan

gRPC membawa era baru komunikasi efisien antara aplikasi. Studi kasus di atas menunjukkan bagaimana backend Go dan client iOS bisa berkomunikasi dengan kontrak API yang jelas, performa tinggi, serta maintainable.
Kombinasi ini cocok untuk aplikasi modern, mulai dari microservices hingga mobile backend.

Jika kamu membangun aplikasi lintas platform, atur proses build Protobuf secara otomatis di CI/CD, gunakan dependensi yang sama di seluruh tim, dan jangan lupa test antar bahasa—karena gRPC didesain untuk lintas ekosistem, namun implementasi tiap bahasa punya nuansa masing-masing.

Referensi lebih lanjut:

• gRPC Docs
• gRPC Swift GitHub
• Go gRPC Example

Selamat mencoba gRPC—dan semoga studi kasus ini membantumu mengintegrasikan mobile app dan backend dengan lebih baik!