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).

syntax = "proto3";

package note;

service NoteService {
    rpc CreateNote (CreateNoteRequest) returns (CreateNoteResponse);
    rpc GetNotes (GetNotesRequest) returns (GetNotesResponse);
    rpc DeleteNote (DeleteNoteRequest) returns (DeleteNoteResponse);
}

message Note {
    string id = 1;
    string title = 2;
    string content = 3;
    string created_at = 4;
}

message CreateNoteRequest {
    string title = 1;
    string content = 2;
}

message CreateNoteResponse {
    Note note = 1;
}

message GetNotesRequest {}

message GetNotesResponse {
    repeated Note notes = 1;
}

message DeleteNoteRequest {
    string id = 1;
}

message DeleteNoteResponse {
    bool success = 1;
}

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:

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

Generate kode dari file .proto:

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

b. Implementasi Service

Contoh partial implementation:

type server struct {
    note_pb.UnimplementedNoteServiceServer
    notes map[string]*note_pb.Note
}

func (s *server) CreateNote(ctx context.Context, req *note_pb.CreateNoteRequest) (*note_pb.CreateNoteResponse, error) {
    id := uuid.NewString()
    now := time.Now().Format(time.RFC3339)
    note := &note_pb.Note{
        Id: id,
        Title: req.Title,
        Content: req.Content,
        CreatedAt: now,
    }
    s.notes[id] = note
    return &note_pb.CreateNoteResponse{Note: note}, nil
}

// Implement method lain sesuai kontrak

c. Jalankan gRPC Server

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

Backend Go sudah siap!

3. Client iOS: Swift

a. Integrasi Library

gRPC Swift support dapat melalui Swift Package Manager atau CocoaPods.

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

b. Generate Swift Code dari Protobuf

Pastikan sudah install plugin Swift:

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

c. Membuat Client dan Memanggil API

import GRPC
import NIO
import Note // hasil generate proto swift

let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
let channel = try! GRPCChannelPool.with(
    target: .host("localhost", port: 50051),
    transportSecurity: .plaintext,
    eventLoopGroup: group
)
let client = Note_NoteServiceClient(channel: channel)

let req = Note_CreateNoteRequest.with {
    $0.title = "Belajar gRPC"
    $0.content = "Menghubungkan Swift dengan Go"
}
let resp = try! client.createNote(req).response.wait()

print("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

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!