











{"author":"Faiq Najib Al-Aziz","body":"\nBayangkan 500 GPS tracker nyambung ke server bersamaan. Masing-masing kirim posisi tiap 10-30 detik, sementara sebagian cuma kirim _heartbeat_ kalau lagi diam. Koneksinya bisa awet berjam-jam, putus tanpa pamit, atau kirim data dalam potongan-potongan. Ehem, ramai sekali.\n\nKalau kamu terbiasa dengan HTTP API, ingat bahwa TCP sendiri tidak punya struktur _request-response_. Listener cuma menerima aliran byte, dan aplikasilah yang harus menafsirkannya.\n\nDi [Part 1](/writing/2026/memahami-gps-protocol/) kita sudah membahas cara device berkomunikasi lewat koneksi TCP persisten dan paket _binary_ dengan aturan berbeda di tiap vendor. Nah, di sini kita bikin _TCP listener_ di Go untuk menerima koneksi-koneksi itu.\n\nPolanya sama dengan yang menangani ratusan device di sistem produksi saya. Implementasinya hanya pakai _standard library_ Go, tanpa _framework_.\n\n## Yang Kita Bangun di Artikel Ini\n\nTargetnya satu program kecil yang:\n\n1. Menerima banyak koneksi secara _concurrent_, satu _goroutine_ per koneksi\n2. Menyusun ulang **frame GT06** dari _stream_ TCP mentah (bagian ini yang paling sering bikin salah)\n3. Memutus koneksi \"zombie\" yang sudah mati tanpa kabar\n4. Mati dengan sopan saat di-_deploy_ ulang (_graceful shutdown_)\n\nKita belum akan men-_decode_ isi paket, menyimpan data ke database, atau menambah antrean pesan. Paket login, paket posisi, dan balasan ACK yang valid butuh CRC-ITU; itu dibahas di [Part 3](/writing/2026/decode-packet-gt06-teltonika/). Listener cukup menerima dan menyusun frame, urusan setelahnya belakangan.\n\n## TCP Server Dasar\n\nKita mulai dari server paling sederhana:\n\n```go\nlistener, err := net.Listen(\"tcp\", \":5094\")\nif err != nil {\n    log.Fatal(err)\n}\ndefer listener.Close()\n\nfor {\n    conn, err := listener.Accept()\n    if err != nil {\n        log.Printf(\"accept error: %v\", err)\n        continue\n    }\n    go handleConnection(conn)\n}\n```\n\n`net.Listen` membuka port, lalu _loop_ `Accept` menerima koneksi. Setiap koneksi ditangani _goroutine_ sendiri. **Goroutine itu murah**: stack awalnya cuma beberapa kilobyte, bukan megabyte seperti thread OS. Jadi pola \"satu goroutine per koneksi\" tetap ringan saat koneksinya banyak.\n\nUntuk GPS listener, saya tidak menyarankan HTTP: ada overhead _header_ per request, koneksi berumur pendek, dan _parsing_ HTTP tidak berguna untuk paket _binary_ mentah. Lagipula device kamu tidak kirim `Content-Type` hehe.\n\n## Jebakan Pertama: TCP Itu Stream, Bukan Pesan\n\nIni beda utama antara TCP listener GPS dan HTTP handler.\n\nKode HTTP terbiasa dengan asumsi: satu request = satu paket utuh. Di TCP **tidak ada jaminan begitu**. `conn.Read(buf)` cuma bilang \"kasih aku byte yang ada sekarang\", artinya:\n\n- **Satu frame bisa terpotong.** Device kirim frame 70 byte, `Read` pertama dapat 40 byte, sisanya datang 200 ms kemudian.\n- **Dua frame bisa nempel jadi satu.** Device kirim dua frame beruntun, `Read` dapat keduanya sekaligus.\n- **Byte sampah bisa muncul.** Device yang baru _boot_ kadang menyembur junk sebelum paket pertamanya.\n\nKalau hasil `Read` dianggap satu paket utuh, proses decode bisa gagal secara acak, dan masalahnya gampang disangka dari device. (Saya pernah. Lama.)\n\nSolusinya **framing manual**. Kita pakai `bufio.Reader` untuk membaca _stream_, cari _start bit_ GT06 (`0x78 0x78`), baca _length_, lalu ambil sisa frame sesuai panjangnya:\n\n```go\n// readFrame membaca satu frame GT06 dari stream:\n//\n//\t78 78 | len | protocol | data | serial | crc | 0D 0A\nfunc readFrame(r *bufio.Reader) ([]byte, error) {\n\t// 1. sinkronisasi: buang byte sampai ketemu start bit 78 78\n\tfor {\n\t\tb, err := r.ReadByte()\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tif b != 0x78 {\n\t\t\tcontinue // byte sampah, lewati\n\t\t}\n\t\tb2, err := r.ReadByte()\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tif b2 != 0x78 {\n\t\t\tcontinue // 0x78 tunggal, bukan start bit; lanjut cari\n\t\t}\n\t\tbreak\n\t}\n\n\tframe := []byte{0x78, 0x78}\n\n\t// 2. baca length (1 byte: jumlah byte protocol sampai CRC, inklusif)\n\tlenByte, err := r.ReadByte()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tframe = append(frame, lenByte)\n\n\t// 3. tarik sisa frame: len + 2 byte (isi + CRC + stop bit 0D 0A)\n\trest := make([]byte, int(lenByte)+2)\n\tif _, err := io.ReadFull(r, rest); err != nil {\n\t\treturn nil, err\n\t}\n\tframe = append(frame, rest...)\n\n\t// 4. validasi stop bit\n\tif frame[len(frame)-2] != 0x0D || frame[len(frame)-1] != 0x0A {\n\t\treturn nil, fmt.Errorf(\"stop bit tidak valid: %X\", frame[len(frame)-2:])\n\t}\n\treturn frame, nil\n}\n```\n\n`io.ReadFull` **menunggu sampai buffer terisi penuh**, jadi byte yang datang terpotong-potong tetap tersusun jadi satu frame. `bufio.Reader` menyimpan byte yang belum terpakai; kalau dua frame datang berurutan, byte frame kedua tetap tersedia untuk pembacaan berikutnya.\n\nIngat aturan framing dari Part 1: angka `len` dihitung dari _protocol number_ sampai CRC inklusif. Itulah kenapa setelah _length byte_ kita tarik `len + 2` byte lagi (isi frame + CRC + _stop bit_).\n\n## handleConnection: Loop Baca Frame\n\nDengan framing tadi, handler tinggal membaca frame dari tiap koneksi:\n\n```go\nfunc handleConnection(ctx context.Context, conn net.Conn) {\n\tdefer conn.Close()\n\tremote := conn.RemoteAddr().String()\n\tlog.Printf(\"connected: %s\", remote)\n\n\treader := bufio.NewReader(conn)\n\tfor {\n\t\tconn.SetReadDeadline(time.Now().Add(readTimeout))\n\n\t\tframe, err := readFrame(reader)\n\t\tif err != nil {\n\t\t\tif errors.Is(err, io.EOF) {\n\t\t\t\tlog.Printf(\"disconnected: %s\", remote)\n\t\t\t} else if ctx.Err() == nil {\n\t\t\t\tlog.Printf(\"read error (%s): %v\", remote, err)\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t\tlog.Printf(\"frame from %s: %X (%d bytes)\", remote, frame, len(frame))\n\t\t// TODO part 3: decode payload + balas ACK valid (butuh CRC-ITU)\n\t}\n}\n```\n\nUntuk sekarang, handler cuma mencatat frame dalam format _hex_. Di Part 3, baris `TODO` itu kita ganti dengan decoder.\n\n## Koneksi Zombie dan Read Deadline\n\nBaris `conn.SetReadDeadline(...)` menentukan berapa lama handler menunggu data.\n\nDevice GPS di jaringan GSM bisa putus tanpa mengirim paket penutup TCP (FIN), misalnya karena sinyal hilang, baterai dicabut, atau _carrier_ me-_reset_ koneksi. Server lalu masih mencatat koneksi yang **sudah mati tapi dikira hidup**. Kalau dibiarkan, koneksi begini menumpuk dan menghabiskan _file descriptor_.\n\nDengan `SetReadDeadline`, kalau tidak ada byte yang datang sebelum batas waktu, `Read` gagal dengan _timeout error_. Handler keluar dan koneksi ditutup.\n\n**Deadline harus lebih besar dari interval heartbeat device.** Seperti di Part 1, device yang diam mengirim _heartbeat_ tiap 2-5 menit. Deadline 90 detik akan memutus device sehat yang cuma lagi diam. Makanya nilainya saya set:\n\n```go\n// harus LEBIH BESAR dari interval heartbeat device (GT06: 2-5 menit saat idle)\nvar readTimeout = 10 * time.Minute\n```\n\nDeadline di-_reset_ setiap kali frame berhasil dibaca, sehingga device yang aktif tetap terhubung.\n\n## Mati dengan Sopan: Graceful Shutdown\n\nListener production bisa di-_restart_ saat deploy, _scaling_, atau pemeliharaan. Saat container atau sistem dihentikan, OS biasanya mengirim sinyal `SIGTERM` dan memberi proses waktu untuk menutup diri sebelum dimatikan paksa.\n\nWaktu itu kita pakai untuk menutup _listener_, menutup koneksi aktif, dan menunggu _goroutine_ selesai sebelum program keluar.\n\n```go\nfunc main() {\n\tctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)\n\tdefer stop()\n\n\tlistener, err := net.Listen(\"tcp\", \":5094\")\n\tif err != nil {\n\t\tlog.Fatal(err)\n\t}\n\n\tvar wg sync.WaitGroup\n\tconns := newConnTracker()\n\n\t// goroutine penutup: saat sinyal datang, tutup listener + semua koneksi aktif\n\tgo func() {\n\t\t\u003c-ctx.Done()\n\t\tlog.Println(\"shutting down: menutup listener dan koneksi aktif\")\n\t\tlistener.Close()\n\t\tconns.CloseAll()\n\t}()\n\n\tlog.Println(\"listening on :5094\")\n\tfor {\n\t\tconn, err := listener.Accept()\n\t\tif err != nil {\n\t\t\tif ctx.Err() != nil {\n\t\t\t\tbreak // shutdown: keluar dari accept loop\n\t\t\t}\n\t\t\tlog.Printf(\"accept error: %v\", err)\n\t\t\tcontinue\n\t\t}\n\t\twg.Add(1)\n\t\tconns.Add(conn)\n\t\tgo func() {\n\t\t\tdefer wg.Done()\n\t\t\tdefer conns.Remove(conn)\n\t\t\thandleConnection(ctx, conn)\n\t\t}()\n\t}\n\n\twg.Wait()\n\tlog.Println(\"bye\")\n}\n```\n\n`connTracker` menyimpan koneksi aktif agar semuanya bisa ditutup sekaligus:\n\n```go\ntype connTracker struct {\n\tmu    sync.Mutex\n\tconns map[net.Conn]struct{}\n}\n\nfunc newConnTracker() *connTracker {\n\treturn \u0026connTracker{conns: make(map[net.Conn]struct{})}\n}\n\nfunc (t *connTracker) Add(c net.Conn) {\n\tt.mu.Lock()\n\tt.conns[c] = struct{}{}\n\tt.mu.Unlock()\n}\n\nfunc (t *connTracker) Remove(c net.Conn) {\n\tt.mu.Lock()\n\tdelete(t.conns, c)\n\tt.mu.Unlock()\n}\n\nfunc (t *connTracker) CloseAll() {\n\tt.mu.Lock()\n\tdefer t.mu.Unlock()\n\tfor c := range t.conns {\n\t\tc.Close()\n\t}\n}\n```\n\n`signal.NotifyContext` mengubah `SIGTERM` atau Ctrl+C menjadi `ctx.Done()`. Goroutine penutup menutup _listener_, sehingga `Accept` gagal dan _loop_ utama berhenti, lalu menutup koneksi aktif. `sync.WaitGroup` menunggu semua handler selesai sebelum `main` keluar.\n\n## Menguji Tanpa Device Asli\n\nKamu bisa mencoba kode ini tanpa tracker fisik. Fitur `/dev/tcp` di Bash cukup untuk mengirim data seolah-olah dari device GT06:\n\n```bash\nexec 3\u003c\u003e/dev/tcp/127.0.0.1/5094\nprintf '\\x78\\x78\\x0d\\x01\\x01\\x23\\x45\\x67\\x89\\x01\\x23\\x45\\x00\\x01\\x8c\\xdd\\x0d\\x0a' \u003e\u00263\n```\n\nItu frame _login_ GT06 dari datasheet, dengan terminal ID `123456789012345`, yang dibahas di [Part 1](/writing/2026/memahami-gps-protocol/). Saya menguji program di atas melalui loopback di laptop dengan skenario berikut:\n\n| Skenario                                                     | Hasil                                               |\n| ------------------------------------------------------------ | --------------------------------------------------- |\n| Satu frame utuh                                              | Terbaca satu frame, 18 byte ✓                       |\n| Frame dikirim terpotong dua tahap (sisanya 1 detik kemudian) | Tetap tersusun jadi satu frame ✓                    |\n| Dua frame dikirim dalam satu write                           | Terpisah jadi dua frame ✓                           |\n| Byte sampah (`FF DE AD`) sebelum frame                       | Sampah di-skip, frame tetap terbaca ✓               |\n| 20 koneksi konkuren, tiap koneksi kirim frame                | 20 frame terbaca tanpa race ✓                       |\n| `SIGTERM` saat ada koneksi aktif                             | Listener + koneksi ditutup, program keluar bersih ✓ |\n\nBerikut output log dari saat server mulai hingga berhenti:\n\n```text\n2026/09/12 20:25:31 listening on :5094\n2026/09/12 20:25:32 connected: 127.0.0.1:45870\n2026/09/12 20:25:32 frame from 127.0.0.1:45870: 78780D01012345678901234500018CDD0D0A (18 bytes)\n2026/09/12 20:25:33 shutting down: menutup listener dan koneksi aktif\n2026/09/12 20:25:33 bye\n```\n\n## Catatan Sebelum Lanjut\n\n- **Goroutine per koneksi** itu pola standar untuk TCP server di Go. Goroutine ringan, jadi satu goroutine per koneksi tetap masuk akal. Batas sebenarnya bergantung pada memori, _file descriptor_, dan beban kerja, jadi ukur dulu sebelum menyebut angka.\n- **TCP adalah stream.** Satu `Read` ≠ satu paket. Framing manual (start bit + length + `io.ReadFull`) satu-satunya cara yang benar untuk membaca protokol binary.\n- **Deadline \u003e interval heartbeat.** SetReadDeadline membantu membersihkan koneksi yang putus, tapi nilai yang terlalu pendek akan memutus device sehat.\n- **Tutup koneksi saat shutdown.** `SIGTERM` memberi kesempatan untuk menutup listener dan koneksi aktif dengan rapi.\n\nListener ini sudah menerima dan menyusun frame, tapi belum membaca payload atau membalas ACK. Tanpa ACK, device sungguhan mengira server tidak merespons dan terus mengirim ulang paket lama. Dua-duanya butuh CRC-ITU dan pemahaman struktur payload GT06.\n\n## Selanjutnya\n\nArtikel ini bagian dari seri **Membangun GPS Backend dari Nol**.\n\n- Sebelumnya: [Part 1: Memahami GPS Protocol](/writing/2026/memahami-gps-protocol/)\n- Selanjutnya: [Part 3: Decode Packet: GT06 \u0026 Teltonika Protocol](/writing/2026/decode-packet-gt06-teltonika/). Di sana kita tulis decoder asli: parse login \u0026 posisi, hitung CRC, dan balas ACK yang valid.\n\n## Ngobrol\n\nKalau ada yang mau didiskusikan soal listener GPS ini, hubungi saya lewat [Contact](/contact/). Kamu juga bisa subscribe [RSS](/writing/index.xml) untuk mengikuti artikel berikutnya.\n","body_clean":"Bayangkan 500 GPS tracker nyambung ke server bersamaan. Masing-masing kirim posisi tiap 10-30 detik, sementara sebagian cuma kirim heartbeat kalau lagi diam. Koneksinya bisa awet berjam-jam, putus tanpa pamit, atau kirim data dalam potongan-potongan. Ehem, ramai sekali.\nKalau kamu terbiasa dengan HTTP API, ingat bahwa TCP sendiri tidak punya struktur request-response. Listener cuma menerima aliran byte, dan aplikasilah yang harus menafsirkannya.\nDi Part 1 kita sudah membahas cara device berkomunikasi lewat koneksi TCP persisten dan paket binary dengan aturan berbeda di tiap vendor. Nah, di sini kita bikin TCP listener di Go untuk menerima koneksi-koneksi itu.\nPolanya sama dengan yang menangani ratusan device di sistem produksi saya. Implementasinya hanya pakai standard library Go, tanpa framework.\nYang Kita Bangun di Artikel Ini #Targetnya satu program kecil yang:\nMenerima banyak koneksi secara concurrent, satu goroutine per koneksi Menyusun ulang frame GT06 dari stream TCP mentah (bagian ini yang paling sering bikin salah) Memutus koneksi \u0026ldquo;zombie\u0026rdquo; yang sudah mati tanpa kabar Mati dengan sopan saat di-deploy ulang (graceful shutdown) Kita belum akan men-decode isi paket, menyimpan data ke database, atau menambah antrean pesan. Paket login, paket posisi, dan balasan ACK yang valid butuh CRC-ITU; itu dibahas di Part 3. Listener cukup menerima dan menyusun frame, urusan setelahnya belakangan.\nTCP Server Dasar #Kita mulai dari server paling sederhana:\nlistener, err := net.Listen(\u0026#34;tcp\u0026#34;, \u0026#34;:5094\u0026#34;) if err != nil { log.Fatal(err) } defer listener.Close() for { conn, err := listener.Accept() if err != nil { log.Printf(\u0026#34;accept error: %v\u0026#34;, err) continue } go handleConnection(conn) } net.Listen membuka port, lalu loop Accept menerima koneksi. Setiap koneksi ditangani goroutine sendiri. Goroutine itu murah: stack awalnya cuma beberapa kilobyte, bukan megabyte seperti thread OS. Jadi pola \u0026ldquo;satu goroutine per koneksi\u0026rdquo; tetap ringan saat koneksinya banyak.\nUntuk GPS listener, saya tidak menyarankan HTTP: ada overhead header per request, koneksi berumur pendek, dan parsing HTTP tidak berguna untuk paket binary mentah. Lagipula device kamu tidak kirim Content-Type hehe.\nJebakan Pertama: TCP Itu Stream, Bukan Pesan #Ini beda utama antara TCP listener GPS dan HTTP handler.\nKode HTTP terbiasa dengan asumsi: satu request = satu paket utuh. Di TCP tidak ada jaminan begitu. conn.Read(buf) cuma bilang \u0026ldquo;kasih aku byte yang ada sekarang\u0026rdquo;, artinya:\nSatu frame bisa terpotong. Device kirim frame 70 byte, Read pertama dapat 40 byte, sisanya datang 200 ms kemudian. Dua frame bisa nempel jadi satu. Device kirim dua frame beruntun, Read dapat keduanya sekaligus. Byte sampah bisa muncul. Device yang baru boot kadang menyembur junk sebelum paket pertamanya. Kalau hasil Read dianggap satu paket utuh, proses decode bisa gagal secara acak, dan masalahnya gampang disangka dari device. (Saya pernah. Lama.)\nSolusinya framing manual. Kita pakai bufio.Reader untuk membaca stream, cari start bit GT06 (0x78 0x78), baca length, lalu ambil sisa frame sesuai panjangnya:\n// readFrame membaca satu frame GT06 dari stream: // //\t78 78 | len | protocol | data | serial | crc | 0D 0A func readFrame(r *bufio.Reader) ([]byte, error) { // 1. sinkronisasi: buang byte sampai ketemu start bit 78 78 for { b, err := r.ReadByte() if err != nil { return nil, err } if b != 0x78 { continue // byte sampah, lewati } b2, err := r.ReadByte() if err != nil { return nil, err } if b2 != 0x78 { continue // 0x78 tunggal, bukan start bit; lanjut cari } break } frame := []byte{0x78, 0x78} // 2. baca length (1 byte: jumlah byte protocol sampai CRC, inklusif) lenByte, err := r.ReadByte() if err != nil { return nil, err } frame = append(frame, lenByte) // 3. tarik sisa frame: len + 2 byte (isi + CRC + stop bit 0D 0A) rest := make([]byte, int(lenByte)+2) if _, err := io.ReadFull(r, rest); err != nil { return nil, err } frame = append(frame, rest...) // 4. validasi stop bit if frame[len(frame)-2] != 0x0D || frame[len(frame)-1] != 0x0A { return nil, fmt.Errorf(\u0026#34;stop bit tidak valid: %X\u0026#34;, frame[len(frame)-2:]) } return frame, nil } io.ReadFull menunggu sampai buffer terisi penuh, jadi byte yang datang terpotong-potong tetap tersusun jadi satu frame. bufio.Reader menyimpan byte yang belum terpakai; kalau dua frame datang berurutan, byte frame kedua tetap tersedia untuk pembacaan berikutnya.\nIngat aturan framing dari Part 1: angka len dihitung dari protocol number sampai CRC inklusif. Itulah kenapa setelah length byte kita tarik len + 2 byte lagi (isi frame + CRC + stop bit).\nhandleConnection: Loop Baca Frame #Dengan framing tadi, handler tinggal membaca frame dari tiap koneksi:\nfunc handleConnection(ctx context.Context, conn net.Conn) { defer conn.Close() remote := conn.RemoteAddr().String() log.Printf(\u0026#34;connected: %s\u0026#34;, remote) reader := bufio.NewReader(conn) for { conn.SetReadDeadline(time.Now().Add(readTimeout)) frame, err := readFrame(reader) if err != nil { if errors.Is(err, io.EOF) { log.Printf(\u0026#34;disconnected: %s\u0026#34;, remote) } else if ctx.Err() == nil { log.Printf(\u0026#34;read error (%s): %v\u0026#34;, remote, err) } return } log.Printf(\u0026#34;frame from %s: %X (%d bytes)\u0026#34;, remote, frame, len(frame)) // TODO part 3: decode payload + balas ACK valid (butuh CRC-ITU) } } Untuk sekarang, handler cuma mencatat frame dalam format hex. Di Part 3, baris TODO itu kita ganti dengan decoder.\nKoneksi Zombie dan Read Deadline #Baris conn.SetReadDeadline(...) menentukan berapa lama handler menunggu data.\nDevice GPS di jaringan GSM bisa putus tanpa mengirim paket penutup TCP (FIN), misalnya karena sinyal hilang, baterai dicabut, atau carrier me-reset koneksi. Server lalu masih mencatat koneksi yang sudah mati tapi dikira hidup. Kalau dibiarkan, koneksi begini menumpuk dan menghabiskan file descriptor.\nDengan SetReadDeadline, kalau tidak ada byte yang datang sebelum batas waktu, Read gagal dengan timeout error. Handler keluar dan koneksi ditutup.\nDeadline harus lebih besar dari interval heartbeat device. Seperti di Part 1, device yang diam mengirim heartbeat tiap 2-5 menit. Deadline 90 detik akan memutus device sehat yang cuma lagi diam. Makanya nilainya saya set:\n// harus LEBIH BESAR dari interval heartbeat device (GT06: 2-5 menit saat idle) var readTimeout = 10 * time.Minute Deadline di-reset setiap kali frame berhasil dibaca, sehingga device yang aktif tetap terhubung.\nMati dengan Sopan: Graceful Shutdown #Listener production bisa di-restart saat deploy, scaling, atau pemeliharaan. Saat container atau sistem dihentikan, OS biasanya mengirim sinyal SIGTERM dan memberi proses waktu untuk menutup diri sebelum dimatikan paksa.\nWaktu itu kita pakai untuk menutup listener, menutup koneksi aktif, dan menunggu goroutine selesai sebelum program keluar.\nfunc main() { ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() listener, err := net.Listen(\u0026#34;tcp\u0026#34;, \u0026#34;:5094\u0026#34;) if err != nil { log.Fatal(err) } var wg sync.WaitGroup conns := newConnTracker() // goroutine penutup: saat sinyal datang, tutup listener + semua koneksi aktif go func() { \u0026lt;-ctx.Done() log.Println(\u0026#34;shutting down: menutup listener dan koneksi aktif\u0026#34;) listener.Close() conns.CloseAll() }() log.Println(\u0026#34;listening on :5094\u0026#34;) for { conn, err := listener.Accept() if err != nil { if ctx.Err() != nil { break // shutdown: keluar dari accept loop } log.Printf(\u0026#34;accept error: %v\u0026#34;, err) continue } wg.Add(1) conns.Add(conn) go func() { defer wg.Done() defer conns.Remove(conn) handleConnection(ctx, conn) }() } wg.Wait() log.Println(\u0026#34;bye\u0026#34;) } connTracker menyimpan koneksi aktif agar semuanya bisa ditutup sekaligus:\ntype connTracker struct { mu sync.Mutex conns map[net.Conn]struct{} } func newConnTracker() *connTracker { return \u0026amp;connTracker{conns: make(map[net.Conn]struct{})} } func (t *connTracker) Add(c net.Conn) { t.mu.Lock() t.conns[c] = struct{}{} t.mu.Unlock() } func (t *connTracker) Remove(c net.Conn) { t.mu.Lock() delete(t.conns, c) t.mu.Unlock() } func (t *connTracker) CloseAll() { t.mu.Lock() defer t.mu.Unlock() for c := range t.conns { c.Close() } } signal.NotifyContext mengubah SIGTERM atau Ctrl+C menjadi ctx.Done(). Goroutine penutup menutup listener, sehingga Accept gagal dan loop utama berhenti, lalu menutup koneksi aktif. sync.WaitGroup menunggu semua handler selesai sebelum main keluar.\nMenguji Tanpa Device Asli #Kamu bisa mencoba kode ini tanpa tracker fisik. Fitur /dev/tcp di Bash cukup untuk mengirim data seolah-olah dari device GT06:\nexec 3\u0026lt;\u0026gt;/dev/tcp/127.0.0.1/5094 printf \u0026#39;\\x78\\x78\\x0d\\x01\\x01\\x23\\x45\\x67\\x89\\x01\\x23\\x45\\x00\\x01\\x8c\\xdd\\x0d\\x0a\u0026#39; \u0026gt;\u0026amp;3 Itu frame login GT06 dari datasheet, dengan terminal ID 123456789012345, yang dibahas di Part 1. Saya menguji program di atas melalui loopback di laptop dengan skenario berikut:\nSkenario Hasil Satu frame utuh Terbaca satu frame, 18 byte ✓ Frame dikirim terpotong dua tahap (sisanya 1 detik kemudian) Tetap tersusun jadi satu frame ✓ Dua frame dikirim dalam satu write Terpisah jadi dua frame ✓ Byte sampah (FF DE AD) sebelum frame Sampah di-skip, frame tetap terbaca ✓ 20 koneksi konkuren, tiap koneksi kirim frame 20 frame terbaca tanpa race ✓ SIGTERM saat ada koneksi aktif Listener + koneksi ditutup, program keluar bersih ✓ Berikut output log dari saat server mulai hingga berhenti:\n2026/09/12 20:25:31 listening on :5094 2026/09/12 20:25:32 connected: 127.0.0.1:45870 2026/09/12 20:25:32 frame from 127.0.0.1:45870: 78780D01012345678901234500018CDD0D0A (18 bytes) 2026/09/12 20:25:33 shutting down: menutup listener dan koneksi aktif 2026/09/12 20:25:33 bye Catatan Sebelum Lanjut # Goroutine per koneksi itu pola standar untuk TCP server di Go. Goroutine ringan, jadi satu goroutine per koneksi tetap masuk akal. Batas sebenarnya bergantung pada memori, file descriptor, dan beban kerja, jadi ukur dulu sebelum menyebut angka. TCP adalah stream. Satu Read ≠ satu paket. Framing manual (start bit + length + io.ReadFull) satu-satunya cara yang benar untuk membaca protokol binary. Deadline \u0026gt; interval heartbeat. SetReadDeadline membantu membersihkan koneksi yang putus, tapi nilai yang terlalu pendek akan memutus device sehat. Tutup koneksi saat shutdown. SIGTERM memberi kesempatan untuk menutup listener dan koneksi aktif dengan rapi. Listener ini sudah menerima dan menyusun frame, tapi belum membaca payload atau membalas ACK. Tanpa ACK, device sungguhan mengira server tidak merespons dan terus mengirim ulang paket lama. Dua-duanya butuh CRC-ITU dan pemahaman struktur payload GT06.\nSelanjutnya #Artikel ini bagian dari seri Membangun GPS Backend dari Nol.\nSebelumnya: Part 1: Memahami GPS Protocol Selanjutnya: Part 3: Decode Packet: GT06 \u0026amp; Teltonika Protocol. Di sana kita tulis decoder asli: parse login \u0026amp; posisi, hitung CRC, dan balas ACK yang valid. Ngobrol #Kalau ada yang mau didiskusikan soal listener GPS ini, hubungi saya lewat Contact. Kamu juga bisa subscribe RSS untuk mengikuti artikel berikutnya.\n","canonical":"https://najib.id/writing/2026/tcp-listener-gps-go/","description":"Cara membuat TCP server di Go untuk menerima koneksi dari ratusan GPS tracker secara concurrent: dari net.Listen, framing paket binary dari stream TCP, read deadline, sampai graceful shutdown.","language":"id","lastmod":"2026-11-11T23:31:00Z","publishedAt":"2026-09-22T00:00:00Z","readingTime":8,"section":"writing","series":"gps-backend-series","tags":["golang","gps","tcp","networking"],"title":"Membangun TCP Listener untuk GPS Device di Go","type":"writing","url":"https://najib.id/writing/2026/tcp-listener-gps-go/","wordCount":1593}
