Panduan Lengkap Pemrograman Socket di Python

Menghubungkan perangkat untuk bertukar informasi adalah esensi dari jaringan. Socket merupakan bagian penting dari komunikasi jaringan yang efektif karena menjadi konsep dasar untuk mengirimkan pesan antarperangkat di jaringan lokal maupun global serta antarproses pada mesin yang sama. Socket menyediakan antarmuka level rendah yang memungkinkan kendali terperinci atas lalu lintas yang akan dikirim atau diterima.

Sifat level rendah ini memungkinkan kita membuat kanal komunikasi yang sangat andal (atau protokol kustom) untuk kasus penggunaan tertentu dengan overhead rendah yang mungkin ada pada protokol tradisional, yang dibangun di atas komunikasi socket.

Inilah yang membuat socket sangat berguna dalam aplikasi klien–server waktu nyata yang bergantung pada pertukaran pesan instan atau beroperasi dengan jumlah data yang sangat besar.

Dalam artikel ini, kita akan membahas dasar-dasar pemrograman socket dan memberikan panduan langkah demi langkah untuk membuat aplikasi klien dan server berbasis socket menggunakan Python. 

Dasar-Dasar Jaringan

Jaringan memungkinkan komunikasi dan berbagi informasi dalam bentuk apa pun. Kumpulan perangkat yang saling terhubung disebut jaringan.

Banyak jaringan dapat kita amati di dunia fisik: jaringan maskapai atau jaringan saluran listrik, atau kota-kota yang saling terhubung melalui jalan raya adalah beberapa contohnya.

Dengan cara yang sama, ada banyak jaringan dalam teknologi informasi; yang paling menonjol dan dikenal luas adalah internet, jaringan global dari berbagai jaringan yang menghubungkan begitu banyak perangkat—dan kemungkinan besar yang Anda gunakan saat ini untuk membaca artikel ini.

Jenis-jenis jaringan

Internet memuat banyak jaringan lain di dalamnya, yang berbeda dalam skala atau sifat lainnya: misalnya, local area network (LAN), yang umumnya menghubungkan komputer yang berdekatan satu sama lain. Mesin-mesin di perusahaan atau institusi (bank, universitas, dll.) atau bahkan perangkat rumah Anda yang terhubung ke router termasuk dalam jaringan seperti ini.

Ada juga jenis jaringan yang lebih besar atau lebih kecil seperti PAN (personal area network) yang bisa sesederhana ponsel pintar Anda terhubung ke laptop melalui Bluetooth, MAN (metropolitan area network) yang dapat menghubungkan perangkat di seluruh kota, dan WAN (wide area network) yang dapat mencakup seluruh negara atau dunia. Dan ya, jaringan WAN terbesar adalah internet itu sendiri.

Tak perlu dikatakan, jaringan komputer bisa sangat kompleks dan terdiri dari banyak elemen. Salah satu primitif yang paling dasar dan krusial adalah protokol komunikasi.

Jenis-jenis protokol komunikasi jaringan

Protokol komunikasi menentukan aturan tentang bagaimana dan dalam format apa informasi harus dikirim dan diterima. Protokol-protokol ini disusun dalam hierarki untuk mengelola berbagai tugas yang terlibat dalam komunikasi jaringan.

Beberapa protokol komunikasi jaringan yang umum digunakan dan terkenal luas antara lain:

Wi‑Fi

Contoh protokol lapisan tautan (link layer), artinya berada sangat dekat dengan perangkat keras dan bertanggung jawab untuk mengirim data secara fisik dari satu perangkat ke perangkat lain di lingkungan nirkabel.

IP (Internet Protocol)

IP adalah protokol lapisan jaringan yang terutama bertanggung jawab atas perutean paket dan pengalamatan IP.

TCP (Transmission Control Protocol)

Protokol andal yang berorientasi koneksi, menyediakan komunikasi full-duplex dan memastikan integritas serta pengantaran data. Ini adalah protokol lapisan transport yang mengelola koneksi, mendeteksi kesalahan, dan mengendalikan aliran informasi.

UDP (User Datagram Protocol)

Protokol dari suite yang sama dengan TCP. Perbedaan utamanya adalah UDP lebih sederhana dan cepat, tetapi tidak andal, bersifat connectionless, tidak melakukan pemeriksaan pengantaran, dan mengikuti paradigma “tembak-dan-lupakan”. Seperti TCP, UDP juga berada pada lapisan transport.

HTTP (Hypertext Transfer Protocol)

Protokol lapisan aplikasi dan yang paling umum digunakan untuk komunikasi browser-ke-server di web, khususnya untuk menyajikan situs web. Tak perlu dikatakan, artikel yang sedang Anda baca ini juga disajikan melalui HTTP. Protokol HTTP dibangun di atas TCP dan mengelola serta mentransfer informasi yang relevan dengan aplikasi web seperti header untuk memindahkan metadata dan cookie, berbagai metode HTTP (GET, POST, DELETE, UPDATE), dan lain-lain.

MQTT (Message Queue Telemetry Transport)

Contoh lain dari protokol tingkat aplikasi yang digunakan untuk perangkat dengan daya pemrosesan dan masa pakai baterai terbatas, beroperasi dalam kondisi jaringan yang tidak andal (misalnya, sensor gas di lokasi tambang atau sekadar lampu pintar di rumah Anda). MQTT adalah protokol perpesanan standar yang digunakan dalam IoT (Internet of Things). Protokol ini ringan dan mudah digunakan, dirancang dengan mekanisme retransmisi bawaan untuk meningkatkan keandalan. Jika Anda tertarik menggunakan protokol ini dengan Python, Anda dapat membaca panduan Python MQTT yang memberikan tinjauan mendalam tentang klien Paho MQTT.

Satu hal penting untuk dicatat adalah semua protokol di atas menggunakan socket di balik layar namun menambahkan logika dan pemrosesan data mereka sendiri di atasnya. Ini karena socket merupakan antarmuka level rendah untuk komunikasi jaringan apa pun pada perangkat modern seperti yang akan kita bahas pada bagian berikutnya.

Konsep dan Istilah Kunci

Tentu saja, ada banyak konsep dan istilah penting lain yang digunakan dalam konteks jaringan. Berikut ringkasan singkat beberapa yang paling menonjol yang mungkin muncul di sisa tutorial:

• Paket: unit standar transmisi data dalam jaringan komputer (secara awam dapat disamakan dengan istilah “pesan”).
• Endpoint: tujuan tempat paket tiba.
• Alamat IP: pengenal numerik yang mengidentifikasi perangkat secara unik di jaringan. Contoh alamat IP: 192.168.0.0
• Port: pengenal numerik yang mengidentifikasi secara unik sebuah proses yang berjalan pada perangkat dan menangani komunikasi jaringan tertentu: misalnya menyajikan situs web Anda melalui HTTP. Jika alamat IP mengidentifikasi perangkat, port mengidentifikasi aplikasi (setiap aplikasi adalah proses atau terdiri dari proses). Beberapa contoh port yang dikenal: port 80, yang lazim digunakan aplikasi server untuk menangani trafik HTTP, dan port 443 untuk HTTPS (HTTP aman).
• Gateway: jenis simpul jaringan (perangkat) khusus yang berfungsi sebagai titik akses dari satu jaringan ke jaringan lain. Jaringan-jaringan ini bahkan dapat menggunakan protokol berbeda, sehingga mungkin diperlukan translasi protokol oleh gateway. Contoh gateway adalah router yang menghubungkan jaringan lokal rumah ke Internet.

Memahami Socket

Apa itu socket?

Socket adalah antarmuka (gerbang) untuk komunikasi antarproses yang berada pada mesin yang sama atau berbeda. Pada kasus kedua, kita menyebutnya network socket.

Network socket mengabstraksi manajemen koneksi. Khususnya di sistem Unix, socket hanyalah berkas yang mendukung operasi tulis-baca yang sama tetapi mengirim semua data melalui jaringan.

Ketika socket berada dalam keadaan mendengarkan atau menyambung, ia selalu terikat pada kombinasi alamat IP plus nomor port yang mengidentifikasi host (mesin/perangkat) dan prosesnya.

Cara kerja koneksi socket

Socket dapat mendengarkan koneksi masuk atau melakukan koneksi keluar sendiri. Ketika koneksi terjalin, socket pendengar (server socket) akan tambahan terikat ke IP dan port pihak yang menyambung.

Atau sebagai alternatif, dibuat socket baru yang kini terikat pada dua pasang alamat IP dan nomor port dari pendengar dan peminta. Dengan cara ini, dua socket yang terhubung pada mesin berbeda dapat mengidentifikasi satu sama lain dan berbagi satu koneksi untuk transmisi data tanpa memblokir socket pendengar yang pada saat bersamaan terus mendengarkan koneksi lain.

Pada kasus socket yang menyambung (client socket), ia secara implisit terikat ke alamat IP perangkat dan nomor port acak yang tersedia saat inisiasi koneksi. Lalu, setelah koneksi terjalin, pengikatan ke IP dan port sisi komunikasi lainnya terjadi dengan cara yang sama seperti pada socket pendengar namun tanpa membuat socket baru.

Pemrograman socket

Saat kita berbicara tentang pemrograman socket, kita membuat objek socket dalam kode dan melakukan operasi terhadapnya (listen, connect, receive, send, dll.). Dalam konteks ini, socket hanyalah objek khusus yang kita buat dalam program dengan metode khusus untuk bekerja dengan koneksi dan lalu lintas jaringan.

Di balik layar, metode-metode tersebut memanggil kernel sistem operasi Anda, atau lebih spesifiknya network stack, yaitu bagian khusus dari kernel yang bertanggung jawab mengelola operasi jaringan.

Socket dan komunikasi klien–server

Socket berkaitan dengan koneksi; mereka adalah pengendali koneksi. Di web, setiap kali Anda ingin mengirim atau menerima data, Anda memulai sebuah koneksi (yang diinisiasi melalui antarmuka bernama socket).

Kini, baik Anda maupun pihak yang ingin Anda hubungi berperan sebagai server dan pihak lainnya sebagai klien. Sementara server menyajikan data ke klien, klien secara proaktif tersambung dan meminta data dari server. Server mendengarkan koneksi baru melalui listening socket, menjalin koneksi, menerima permintaan klien, dan mengirimkan data yang diminta dalam responsnya kepada klien.

Di sisi lain, klien membuat socket menggunakan alamat IP dan port server yang ingin dihubungi, memulai koneksi, menyampaikan permintaannya kepada server, dan menerima data sebagai respons. Pertukaran informasi yang mulus antara socket klien dan server ini menjadi tulang punggung berbagai aplikasi jaringan.

Socket sebagai dasar protokol jaringan

Fakta bahwa socket menjadi tulang punggung juga berarti ada berbagai protokol yang dibangun dan digunakan di atasnya. Yang sangat umum adalah UDP dan TCP, yang sudah kita singgung sebelumnya. Socket yang menggunakan salah satu protokol transport ini disebut socket UDP atau TCP.

Socket IPC

Selain network socket, ada juga jenis lain. Misalnya, socket IPC (Inter Process Communication). Socket IPC dimaksudkan untuk mentransfer data antarproses pada mesin yang sama, sedangkan network socket dapat melakukan hal yang sama melalui jaringan.

Keunggulan socket IPC adalah menghindari banyak overhead dalam membangun paket dan menentukan rute pengiriman data. Karena pada konteks IPC pengirim dan penerima adalah proses lokal, komunikasi melalui socket IPC biasanya memiliki latensi lebih rendah.

Unix-socket

Contoh bagus socket IPC adalah Unix-socket yang, seperti hal lain di Unix, hanyalah berkas pada sistem berkas. Mereka tidak diidentifikasi oleh alamat IP dan port, melainkan oleh path berkas pada sistem berkas.

Network socket sebagai socket IPC

Perlu dicatat bahwa Anda juga dapat menggunakan network socket untuk komunikasi antarproses jika server dan penerima berada di localhost (yaitu memiliki alamat IP 127.0.0.1).

Tentu, di satu sisi ini menambah latensi karena overhead pemrosesan data Anda oleh network stack, namun di sisi lain, ini memungkinkan kita untuk tidak khawatir tentang sistem operasi yang mendasarinya, karena network socket tersedia dan berfungsi di semua sistem, berbeda dengan socket IPC yang spesifik pada suatu OS atau keluarga OS tertentu.

Pustaka Socket Python

Untuk pemrograman socket di Python, kita menggunakan pustaka socket Python bawaan resmi yang terdiri dari fungsi, konstanta, dan kelas yang digunakan untuk membuat, mengelola, dan bekerja dengan socket. Beberapa fungsi yang umum digunakan dari pustaka ini antara lain:

• socket(): Membuat socket baru.
• bind(): Mengaitkan socket ke alamat dan port tertentu.
• listen(): Mulai mendengarkan koneksi masuk pada socket.
• accept(): Menerima koneksi dari klien dan mengembalikan socket baru untuk berkomunikasi.
• connect(): Menjalin koneksi ke server jarak jauh.
• send(): Mengirim data melalui socket.
• recv(): Menerima data dari socket.
• close(): Menutup koneksi socket.

Contoh Socket Python

Mari melihat pemrograman socket dengan contoh praktis yang ditulis dalam Python. Di sini, tujuan kita adalah menghubungkan dua aplikasi dan membuatnya saling berkomunikasi. Kita akan menggunakan pustaka socket Python untuk membuat aplikasi server socket yang akan berkomunikasi dan bertukar informasi dengan klien melalui jaringan.

Pertimbangan dan keterbatasan

Perlu dicatat, demi tujuan pembelajaran, contoh kita disederhanakan, dan aplikasi akan berjalan secara lokal dan tidak berbicara melalui jaringan sebenarnya—kita akan menggunakan alamat loopback localhost untuk menghubungkan klien ke server.

Artinya, klien dan server akan berjalan pada mesin yang sama dan klien akan menginisiasi koneksi ke mesin yang sama tempat ia berjalan, meskipun ke proses berbeda yang merepresentasikan server.

Berjalan pada mesin berbeda

Sebagai alternatif, Anda dapat menempatkan aplikasi pada dua perangkat berbeda dan menghubungkan keduanya ke router Wi‑Fi yang sama, yang akan membentuk jaringan area lokal. Lalu klien yang berjalan pada satu perangkat dapat terhubung ke server yang berjalan pada mesin lain.

Dalam hal ini, Anda perlu mengetahui alamat IP yang ditetapkan router ke perangkat Anda dan menggunakannya alih-alih alamat IP loopback localhost (127.0.0.1) (untuk melihat alamat IP, gunakan perintah terminal ifconfig untuk sistem mirip Unix atau ipconfig untuk Windows). Setelah Anda mendapatkan alamat IP aplikasi, Anda dapat mengubahnya di kode sesuai kebutuhan, dan contoh tetap akan berfungsi.

Membuat server socket di Python

Mari mulai dengan membuat server socket (khususnya server TCP Python, karena akan bekerja dengan socket TCP seperti yang akan kita lihat) yang akan bertukar pesan dengan klien. 

Jadi, ikuti langkah-langkah di bawah ini:

Membuat berkas python dengan boilerplate

• Buat berkas bernama server.py

• Impor modul socket di skrip Python Anda.

import socketDidukung oleh

• Tambahkan fungsi bernama run_server. Kita akan menambahkan sebagian besar kode kita di sana. Saat Anda menambahkan kode ke fungsi tersebut, jangan lupa untuk memberi indentasi dengan benar:

def run_server():
    # your code will go hereDidukung oleh

Menginstansiasi objek socket

Langkah berikutnya, di run_server, buat objek socket menggunakan fungsi socket.socket().

Argumen pertama (socket.AF_INET) menentukan keluarga alamat IP untuk IPv4 (opsi lain termasuk: AF_INET6 untuk keluarga IPv6 dan AF_UNIX untuk Unix-socket)

Argumen kedua (socket.SOCK_STREAM) menunjukkan bahwa kita menggunakan socket TCP.

Jika menggunakan TCP, sistem operasi akan membuat koneksi andal dengan pengantaran data berurutan, deteksi kesalahan dan retransmisi, serta kontrol aliran. Anda tidak perlu memikirkan implementasi detail-detail tersebut.

Ada juga opsi untuk menentukan socket UDP: socket.SOCK_DGRAM. Ini akan membuat socket yang mengimplementasikan semua fitur UDP di balik layar.

Jika Anda ingin pergi lebih rendah lagi dan membangun protokol lapisan transport Anda sendiri di atas protokol lapisan jaringan TCP/IP yang digunakan socket, Anda dapat menggunakan nilai socket.SOCK_RAW untuk argumen kedua. Dalam hal ini, sistem operasi tidak akan menangani fitur protokol tingkat lebih tinggi untuk Anda dan Anda harus mengimplementasikan semua header, konfirmasi koneksi, dan fungsionalitas retransmisi sendiri jika diperlukan. Ada juga nilai lain yang dapat Anda baca di dokumentasi.

# create a socket object
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)Didukung oleh

Mengikat socket server ke alamat IP dan port

Definisikan nama host atau IP server dan port untuk menunjukkan alamat tempat server akan dapat dijangkau dan di mana ia akan mendengarkan koneksi masuk. Dalam contoh ini, server mendengarkan pada mesin lokal—ini didefinisikan oleh variabel server_ip yang diatur ke 127.0.0.1 (juga disebut localhost).

Variabel port diatur ke 8000, yaitu nomor port yang akan digunakan sistem operasi untuk mengidentifikasi aplikasi server (Disarankan menggunakan nilai di atas 1023 untuk nomor port Anda untuk menghindari benturan dengan port yang digunakan proses sistem).

server_ip = "127.0.0.1"
    port = 8000Didukung oleh

Siapkan socket untuk menerima koneksi dengan mengikatnya ke alamat IP dan port yang telah kita tentukan sebelumnya.

# bind the socket to a specific address and port
    server.bind((server_ip, port))Didukung oleh

Mendengarkan koneksi masuk

Masukkan socket server ke keadaan mendengarkan dengan fungsi listen. Argumen backlog-nya mengatur berapa banyak koneksi masuk yang dapat mengantre sebelum diterima.

Dalam contoh kita, kita memberikan 0, yang pada sebagian besar sistem secara efektif membatasi server pada satu klien pada satu waktu—upaya koneksi tambahan ditolak saat sibuk. Nilai yang lebih tinggi (misalnya 1 atau lebih) memungkinkan sejumlah klien menunggu di antrean; setelah accept dipanggil pada seorang klien, ia keluar antrean dan slotnya kosong kembali.

Jika Anda melewatkan argumen, maka akan menggunakan nilai baku sistem (di Unix, dapat dilihat di /proc/sys/net/core/somaxconn).

# listen for incoming connections
    server.listen(0)
    print(f"Listening on {server_ip}:{port}")Didukung oleh

Menerima koneksi masuk

Berikutnya, tunggu dan terima koneksi klien yang masuk. Metode accept menghentikan eksekusi thread hingga klien tersambung. Kemudian ia mengembalikan pasangan tuple (conn, address), di mana address adalah tuple alamat IP dan port klien, dan conn adalah objek socket baru yang berbagi koneksi dengan klien dan dapat digunakan untuk berkomunikasi dengannya.

accept membuat socket baru untuk berkomunikasi dengan klien alih-alih mengikat socket pendengar (disebut server pada contoh kita) ke alamat klien dan menggunakannya untuk komunikasi, karena socket pendengar perlu terus mendengarkan koneksi lain dari klien lain, jika tidak akan terblokir. Tentu, dalam kasus kita, kita hanya menangani satu klien dan menolak koneksi lain saat melakukannya, namun ini akan lebih relevan saat kita sampai pada contoh server multithread.

# accept incoming connections
    client_socket, client_address = server.accept()
    print(f"Accepted connection from {client_address[0]}:{client_address[1]}")Didukung oleh

Membuat loop komunikasi

Segera setelah koneksi dengan klien terjalin (setelah memanggil metode accept), kita memulai loop tak hingga untuk berkomunikasi. Dalam loop ini, kita memanggil metode recv dari objek client_socket. Metode ini menerima jumlah byte yang ditentukan dari klien—dalam kasus kita 1024.

1024 byte hanyalah konvensi umum untuk ukuran payload, karena merupakan pangkat dua yang berpotensi lebih baik untuk tujuan optimasi dibandingkan nilai sewenang-wenang lainnya. Namun Anda bebas mengubah nilai ini sesuai keinginan.

Karena data yang diterima dari klien ke variabel request berupa biner mentah, kita mengubahnya dari deretan byte menjadi string menggunakan fungsi decode.

Lalu kita memiliki pernyataan if yang keluar dari loop komunikasi jika kita menerima pesan ”close”. Artinya, begitu server kita mendapatkan string ”close” dalam request, ia mengirimkan konfirmasi kembali ke klien dan mengakhiri koneksi dengannya. Jika tidak, kita mencetak pesan yang diterima ke konsol. Konfirmasi dalam kasus kita hanyalah mengirim string ”closed” ke klien.

Perhatikan bahwa metode lower yang kita gunakan pada string request dalam pernyataan if, hanya mengubahnya menjadi huruf kecil. Dengan begitu kita tidak peduli apakah string close awalnya ditulis dengan huruf besar atau kecil.

# receive data from the client
    while True:
        request = client_socket.recv(1024)
        request = request.decode("utf-8") # convert bytes to string
        
        # if we receive "close" from the client, then we break
        # out of the loop and close the connection
        if request.lower() == "close":
            # send response to the client which acknowledges that the
            # connection should be closed and break out of the loop
            client_socket.send("closed".encode("utf-8"))
            break

        print(f"Received: {request}")Didukung oleh

Mengirim respons kembali ke klien

Sekarang kita harus menangani respons normal server ke klien (yakni ketika klien tidak ingin menutup koneksi). Di dalam while loop, tepat setelah print(f"Received: {request}"), tambahkan baris berikut, yang akan mengonversi string respons (”accepted” dalam kasus kita) menjadi byte dan mengirimkannya ke klien. Dengan cara ini, kapan pun server menerima pesan dari klien yang bukan ”close”, server akan mengirim string ”accepted” sebagai respons:

response = "accepted".encode("utf-8") # convert string to bytes
# convert and send accept response to the client
client_socket.send(response)
Didukung oleh

Membebaskan sumber daya

Setelah kita keluar dari while loop tak hingga, komunikasi dengan klien selesai, jadi kita menutup socket klien menggunakan metode close untuk melepaskan sumber daya sistem. Kita juga menutup socket server menggunakan metode yang sama, yang secara efektif mematikan server kita. Dalam skenario dunia nyata, tentu kita mungkin ingin server terus mendengarkan klien lain dan tidak mati setelah berkomunikasi dengan satu klien saja, tetapi jangan khawatir, kita akan sampai pada contoh lain lebih lanjut di bawah.

Untuk saat ini, tambahkan baris berikut setelah while loop tak hingga:

# close connection socket with the client
    client_socket.close()
    print("Connection to client closed")
    # close server socket
    server.close()Didukung oleh

Catatan: jangan lupa memanggil fungsi run_server di akhir berkas server.py Anda. Cukup gunakan baris kode berikut:

run_server()Didukung oleh

Contoh kode server socket lengkap

Berikut adalah kode sumber lengkap server.py:

import socket

def run_server():
    # create a socket object
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server_ip = "127.0.0.1"
    port = 8000

    # bind the socket to a specific address and port
    server.bind((server_ip, port))
    # listen for incoming connections
    server.listen(0)
    print(f"Listening on {server_ip}:{port}")

    # accept incoming connections
    client_socket, client_address = server.accept()
    print(f"Accepted connection from {client_address[0]}:{client_address[1]}")

    # receive data from the client
    while True:
        request = client_socket.recv(1024)
        request = request.decode("utf-8") # convert bytes to string
        
        # if we receive "close" from the client, then we break
        # out of the loop and close the conneciton
        if request.lower() == "close":
            # send response to the client which acknowledges that the
            # connection should be closed and break out of the loop
            client_socket.send("closed".encode("utf-8"))
            break

        print(f"Received: {request}")

        response = "accepted".encode("utf-8") # convert string to bytes
        # convert and send accept response to the client
        client_socket.send(response)

    # close connection socket with the client
    client_socket.close()
    print("Connection to client closed")
    # close server socket
    server.close()

run_server()Didukung oleh

Perhatikan bahwa demi tidak memusingkan dan mempersulit contoh dasar ini, kita mengabaikan penanganan error. Tentu Anda ingin menambahkan blok try-except dan memastikan selalu menutup socket di klausa finally. Lanjutkan membaca dan kita akan melihat contoh yang lebih lanjut.

Membuat Client Socket di Python

Setelah menyiapkan server, langkah selanjutnya adalah menyiapkan klien yang akan terhubung dan mengirim permintaan ke server Anda. Jadi, mari mulai dengan langkah-langkah di bawah ini:

Membuat berkas python dengan boilerplate

• Buat berkas baru bernama client.py
• Impor pustaka socket:

import socketDidukung oleh

• Definisikan fungsi run_client tempat kita akan menaruh semua kode kita:

def run_client():
    # your code will go hereDidukung oleh

Menginstansiasi objek socket

Berikutnya, gunakan fungsi socket.socket() untuk membuat objek socket TCP yang menjadi titik kontak klien dengan server.

# create a socket object
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)Didukung oleh

Menyambung ke socket server

Tentukan alamat IP dan port server agar dapat terhubung kepadanya. Nilai ini harus sesuai dengan alamat IP dan port yang Anda tetapkan di server.py sebelumnya.

server_ip = "127.0.0.1"  # replace with the server's IP address
server_port = 8000  # replace with the server's port numberDidukung oleh

Jalin koneksi dengan server menggunakan metode connect pada objek socket klien. Perhatikan bahwa kita tidak mengikat socket klien ke alamat IP atau port mana pun. Ini normal untuk klien, karena connect akan secara otomatis memilih port bebas dan mengambil alamat IP yang memberikan rute terbaik ke server dari antarmuka jaringan sistem (127.0.0.1 dalam kasus kita) dan mengikat socket klien ke alamat tersebut.

# establish connection with server
client.connect((server_ip, server_port))Didukung oleh

Membuat loop komunikasi

Setelah koneksi terjalin, kita memulai loop komunikasi tak hingga untuk mengirim beberapa pesan ke server. Kita mengambil input dari pengguna menggunakan fungsi bawaan Python input, lalu mengenkodenya menjadi byte dan memangkasnya agar maksimal 1024 byte. Setelah itu kita mengirim pesan ke server menggunakan client.send.

while True:
   # input message and send it to the server
   msg = input("Enter message: ")
   client.send(msg.encode("utf-8")[:1024])Didukung oleh

Menangani respons server

Setelah server menerima pesan dari klien, server meresponsnya. Sekarang, dalam kode klien kita, kita ingin menerima respons server. Untuk itu, di dalam loop komunikasi, kita menggunakan metode recv untuk membaca maksimal 1024 byte. Kemudian kita mengonversi respons dari byte ke string menggunakan decode dan lalu memeriksa apakah nilainya sama dengan ”closed”. Jika demikian, kita keluar dari loop yang nantinya akan mengakhiri koneksi klien. Jika tidak, kita mencetak respons server ke konsol.

# receive message from the server
response = client.recv(1024)
response = response.decode("utf-8")

# if server sent us "closed" in the payload, we break out of the loop and close our socket
if response.lower() == "closed":
   break

print(f"Received: {response}")Didukung oleh

Membebaskan sumber daya

Terakhir, setelah while loop, tutup koneksi socket klien menggunakan metode close. Ini memastikan bahwa sumber daya dirilis dengan benar dan koneksi diakhiri (yaitu ketika kita menerima pesan “closed” dan keluar dari while loop).

# close client socket (connection to the server)
client.close()
print("Connection to server closed")Didukung oleh

Catatan: Sekali lagi, jangan lupa memanggil fungsi run_client yang telah kita implementasikan di atas, di akhir berkas sebagai berikut:

run_client()
Didukung oleh

Contoh kode client socket lengkap

Berikut adalah kode lengkap client.py:

import socket

def run_client():
    # create a socket object
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server_ip = "127.0.0.1"  # replace with the server's IP address
    server_port = 8000  # replace with the server's port number
    # establish connection with server
    client.connect((server_ip, server_port))

    while True:
        # input message and send it to the server
        msg = input("Enter message: ")
        client.send(msg.encode("utf-8")[:1024])

        # receive message from the server
        response = client.recv(1024)
        response = response.decode("utf-8")

        # if server sent us "closed" in the payload, we break out of the loop and close our socket
        if response.lower() == "closed":
            break

        print(f"Received: {response}")

    # close client socket (connection to the server)
    client.close()
    print("Connection to server closed")

run_client()
Didukung oleh

Uji klien dan server Anda

Untuk menguji implementasi server dan klien yang kita tulis di atas, lakukan hal berikut:

• Buka dua jendela terminal secara bersamaan.

• Pada salah satu jendela terminal, arahkan ke direktori tempat berkas server.py berada dan jalankan perintah berikut untuk memulai server:

python server.pyDidukung oleh

Ini akan mengikat socket server ke alamat localhost (127.0.0.1) pada port 8000 dan mulai mendengarkan koneksi masuk.

• Pada terminal lainnya, arahkan ke direktori tempat berkas client.py berada dan jalankan perintah berikut untuk memulai klien:

python client.pyDidukung oleh

Ini akan meminta input pengguna. Anda kemudian dapat mengetik pesan dan menekan Enter. Ini akan mentransfer input Anda ke server dan menampilkannya di jendela terminal server. Server akan mengirim responsnya ke klien dan klien akan meminta input lagi. Ini akan berlanjut hingga Anda mengirim string ”close” ke server.

Bekerja dengan Banyak Klien – Multithreading

Kita telah melihat bagaimana server merespons permintaan dari satu klien pada contoh sebelumnya, namun dalam banyak situasi praktis, banyak klien mungkin perlu terhubung ke satu server sekaligus. Di sinilah multithreading berperan. Multithreading digunakan ketika Anda perlu menangani beberapa tugas (misalnya mengeksekusi beberapa fungsi) secara bersamaan (pada waktu yang sama).

Gagasannya adalah membuat thread yang merupakan sekumpulan instruksi mandiri yang dapat ditangani oleh prosesor. Thread jauh lebih ringan daripada proses karena sebenarnya hidup di dalam proses itu sendiri dan Anda tidak perlu mengalokasikan banyak sumber daya untuknya.

Keterbatasan multithreading di Python

Dalam build CPython baku, hanya satu thread yang menjalankan bytecode Python pada satu waktu, karena global interpreter lock (GIL). Untuk pemrograman socket hal ini baik-baik saja—GIL dilepas selama I/O jaringan, sehingga thread benar-benar bisa menunggu koneksi secara paralel. Per Oktober 2024, Python 3.13 (CPython) juga menawarkan build free-threaded (PEP 703) yang menghapus GIL, dan asyncio adalah pilihan modern yang lebih umum untuk kode socket dengan konkruensi tinggi.

Contoh server multithread

Mari lihat contoh di bawah tentang bagaimana multithreading dapat ditambahkan ke server Anda untuk menangani banyak klien. Perhatikan bahwa kali ini kita juga akan menambahkan penanganan error dasar menggunakan blok try-except-finally. Untuk memulai, ikuti langkah-langkah berikut:

Membuat fungsi server yang memunculkan thread

Dalam berkas python Anda, impor modul socket dan threading agar dapat bekerja dengan socket dan thread:

import socket
import threadingDidukung oleh

Definisikan fungsi run_server yang, seperti pada contoh di atas, akan membuat socket server, mengikatnya, dan mendengarkan koneksi masuk. Lalu panggil accept dalam while loop tak hingga. Ini akan selalu terus mendengarkan koneksi baru. Setelah accept menerima koneksi masuk dan kembali, buat thread menggunakan konstruktor threading.Thread. Thread ini akan mengeksekusi fungsi handle_client yang akan kita definisikan nanti, dan meneruskan client_socket dan addr sebagai argumen (addr adalah tuple yang memegang alamat IP dan port klien yang terhubung). Setelah thread dibuat, kita memanggil start untuk memulai eksekusinya.

Ingat bahwa pemanggilan accept bersifat blocking, jadi pada iterasi pertama while loop, saat kita mencapai baris dengan accept, kita berhenti dan menunggu koneksi klien tanpa mengeksekusi apa pun. Begitu klien terhubung, metode accept mengembalikan, dan kita melanjutkan eksekusi: memunculkan thread yang akan menangani klien tersebut dan lanjut ke iterasi berikutnya di mana kita kembali berhenti di pemanggilan accept menunggu klien berikutnya terhubung.

Di akhir fungsi, kita memiliki penanganan error yang memastikan socket server selalu ditutup jika terjadi sesuatu yang tak terduga.

def run_server():
    server_ip = "127.0.0.1"  # server hostname or IP address
    port = 8000  # server port number
    # create a socket object
    try:
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # bind the socket to the host and port
        server.bind((server_ip, port))
        # listen for incoming connections
        server.listen()
        print(f"Listening on {server_ip}:{port}")

        while True:
            # accept a client connection
            client_socket, addr = server.accept()
            print(f"Accepted connection from {addr[0]}:{addr[1]}")
            # start a new thread to handle the client
            thread = threading.Thread(target=handle_client, args=(client_socket, addr,))
            thread.start()
    except Exception as e:
        print(f"Error: {e}")
    finally:
        server.close()Didukung oleh

Perhatikan bahwa server pada contoh kita hanya akan berhenti jika terjadi error tak terduga. Selain itu, server akan mendengarkan klien tanpa batas waktu, dan Anda harus menghentikan terminal jika ingin mematikannya.

Membuat fungsi penanganan klien yang dijalankan di thread terpisah

Sekarang, di atas fungsi run_server, definisikan fungsi lain bernama handle_client. Fungsi ini akan dijalankan dalam thread terpisah untuk setiap koneksi klien. Ia menerima objek socket klien dan tuple addr sebagai argumen.

Di dalam fungsi ini, kita melakukan hal yang sama seperti pada contoh single-thread ditambah penanganan error: kita memulai loop untuk mengambil pesan dari klien menggunakan recv.

Lalu kita periksa apakah kita mendapatkan pesan close. Jika ya, kita merespons dengan string ”closed” dan menutup koneksi dengan keluar dari loop. Jika tidak, kita mencetak string permintaan klien ke konsol dan melanjutkan ke iterasi berikutnya untuk menerima pesan klien berikutnya.

Di akhir fungsi ini, kita memiliki penanganan error untuk kasus tak terduga (klausa except), dan juga klausa finally tempat kita melepaskan client_socket menggunakan close. Klausa finally ini akan selalu dijalankan apa pun yang terjadi, sehingga memastikan socket klien selalu dirilis dengan benar.

def handle_client(client_socket, addr):
    try:
        while True:
            # receive and print client messages
            request = client_socket.recv(1024).decode("utf-8")
            if request.lower() == "close":
                client_socket.send("closed".encode("utf-8"))
                break
            print(f"Received: {request}")
            # convert and send accept response to the client
            response = "accepted"
            client_socket.send(response.encode("utf-8"))
    except Exception as e:
        print(f"Error when handling client: {e}")
    finally:
        client_socket.close()
        print(f"Connection to client ({addr[0]}:{addr[1]}) closed")Didukung oleh

Saat handle_client selesai, thread yang mengeksekusinya juga akan dirilis secara otomatis.

Catatan: Jangan lupa memanggil fungsi run_server di akhir berkas Anda.

Contoh kode server multithread lengkap

Sekarang, mari satukan seluruh kode server multithreading:

import socket
import threading

def handle_client(client_socket, addr):
    try:
        while True:
            # receive and print client messages
            request = client_socket.recv(1024).decode("utf-8")
            if request.lower() == "close":
                client_socket.send("closed".encode("utf-8"))
                break
            print(f"Received: {request}")
            # convert and send accept response to the client
            response = "accepted"
            client_socket.send(response.encode("utf-8"))
    except Exception as e:
        print(f"Error when hanlding client: {e}")
    finally:
        client_socket.close()
        print(f"Connection to client ({addr[0]}:{addr[1]}) closed")

def run_server():
    server_ip = "127.0.0.1"  # server hostname or IP address
    port = 8000  # server port number
    # create a socket object
    try:
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # bind the socket to the host and port
        server.bind((server_ip, port))
        # listen for incoming connections
        server.listen()
        print(f"Listening on {server_ip}:{port}")

        while True:
            # accept a client connection
            client_socket, addr = server.accept()
            print(f"Accepted connection from {addr[0]}:{addr[1]}")
            # start a new thread to handle the client
            thread = threading.Thread(target=handle_client, args=(client_socket, addr,))
            thread.start()
    except Exception as e:
        print(f"Error: {e}")
    finally:
        server.close()

run_server()Didukung oleh

Catatan: Dalam kode dunia nyata, untuk mencegah kemungkinan masalah seperti kondisi balapan atau inkonsistensi data saat menangani server multithread, sangat penting mempertimbangkan keselamatan thread dan teknik sinkronisasi. Dalam contoh sederhana kita, ini bukan masalah.

Contoh klien dengan penanganan error dasar

Sekarang kita memiliki implementasi server yang mampu menangani banyak klien secara bersamaan, kita bisa menggunakan implementasi klien yang sama seperti pada contoh dasar pertama untuk memulai koneksi, atau kita bisa memperbaruinya sedikit dan menambahkan penanganan error. Di bawah ini Anda dapat menemukan kode yang identik dengan contoh klien sebelumnya dengan tambahan blok try-except:

import socket

def run_client():
    # create a socket object
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    server_ip = "127.0.0.1"  # replace with the server's IP address
    server_port = 8000  # replace with the server's port number
    # establish connection with server
    client.connect((server_ip, server_port))

    try:
        while True:
            # get input message from user and send it to the server
            msg = input("Enter message: ")
            client.send(msg.encode("utf-8")[:1024])

            # receive message from the server
            response = client.recv(1024)
            response = response.decode("utf-8")

            # if server sent us "closed" in the payload, we break out of
            # the loop and close our socket
            if response.lower() == "closed":
                break

            print(f"Received: {response}")
    except Exception as e:
        print(f"Error: {e}")
    finally:
        # close client socket (connection to the server)
        client.close()
        print("Connection to server closed")

run_client()Didukung oleh

Menguji contoh multithreading

Jika Anda ingin menguji implementasi multi-klien, buka beberapa jendela terminal untuk klien dan satu untuk server. Pertama mulai server dengan python server.py. Setelah itu mulai beberapa klien menggunakan python client.py. Di jendela terminal server Anda akan melihat bagaimana klien baru terhubung ke server. Kini Anda dapat mengirim pesan dari klien yang berbeda dengan memasukkan teks ke terminal masing-masing dan semuanya akan ditangani dan dicetak ke konsol di sisi server.

Aplikasi Pemrograman Socket dalam Data Science

Meskipun setiap aplikasi jaringan menggunakan socket yang dibuat oleh OS di balik layar, ada banyak sistem yang sangat bergantung pada pemrograman socket secara spesifik, baik untuk kasus penggunaan tertentu maupun untuk meningkatkan kinerja. Namun bagaimana tepatnya pemrograman socket berguna dalam konteks data science? Jawabannya, ini memainkan peran penting setiap kali ada kebutuhan untuk menerima atau mengirim data dalam jumlah besar dengan cepat. Oleh karena itu, pemrograman socket terutama digunakan untuk pengumpulan data dan pemrosesan waktu nyata, komputasi terdistribusi, serta komunikasi antarproses. Mari lihat lebih dekat beberapa aplikasi khusus di bidang data science.

Pengumpulan data waktu nyata

Socket banyak digunakan untuk mengumpulkan data waktu nyata dari berbagai sumber untuk diproses lebih lanjut, diteruskan ke basis data atau pipeline analitik, dan sebagainya. Misalnya, socket dapat digunakan untuk segera menerima data dari sistem keuangan atau API media sosial untuk kemudian diproses oleh data scientist.

Komputasi terdistribusi

Data scientist dapat menggunakan konektivitas socket untuk mendistribusikan pemrosesan dan komputasi kumpulan data besar ke banyak mesin. Pemrograman socket umum digunakan pada Apache Spark dan kerangka kerja komputasi terdistribusi lainnya untuk komunikasi antar node.

Penyebaran model

Pemrograman socket dapat digunakan saat menyajikan model machine learning kepada pengguna, memungkinkan penyampaian prediksi dan saran secara instan. Untuk memfasilitasi pengambilan keputusan waktu nyata, data scientist dapat menggunakan aplikasi server berbasis socket yang andal yang menerima data dalam jumlah besar, memprosesnya menggunakan model yang dilatih untuk memberikan prediksi, lalu dengan cepat mengembalikan hasilnya ke klien.

Inter-Process Communication (IPC)

Socket dapat digunakan untuk IPC, yang memungkinkan proses berbeda yang berjalan pada mesin yang sama saling berkomunikasi dan bertukar data. Ini berguna dalam data science untuk mendistribusikan komputasi yang kompleks dan intensif sumber daya ke banyak proses. Faktanya, pustaka subprocessing Python sering digunakan untuk tujuan ini: ia memunculkan beberapa proses untuk memanfaatkan banyak inti prosesor dan meningkatkan performa aplikasi saat melakukan perhitungan berat. Komunikasi antarproses semacam itu dapat diimplementasikan melalui socket IPC.

Kolaborasi dan komunikasi

Pemrograman socket memungkinkan komunikasi dan kolaborasi waktu nyata di antara data scientist. Untuk memfasilitasi kolaborasi efektif dan berbagi pengetahuan, digunakan aplikasi chat berbasis socket atau platform analisis data kolaboratif.

Perlu dikatakan bahwa dalam banyak aplikasi di atas, data scientist mungkin tidak terlibat langsung bekerja dengan socket. Mereka biasanya menggunakan pustaka, kerangka kerja, dan sistem yang mengabstraksi semua detail level rendah dari pemrograman socket. Namun, di balik layar semua solusi tersebut berbasis komunikasi socket dan memanfaatkan pemrograman socket.

Tantangan dan Praktik Terbaik Pemrograman Socket

Karena socket adalah konsep level rendah untuk mengelola koneksi, pengembang yang bekerja dengannya harus mengimplementasikan seluruh infrastruktur yang dibutuhkan untuk membuat aplikasi yang tangguh dan andal. Ini tentu menghadirkan banyak tantangan. Namun, ada beberapa praktik terbaik dan pedoman umum yang dapat diikuti untuk mengatasi masalah ini. Di bawah ini adalah beberapa masalah yang paling sering ditemui dalam pemrograman socket, beserta beberapa kiat umum:

Manajemen koneksi

Bekerja dengan banyak koneksi sekaligus; mengelola banyak klien, dan memastikan penanganan permintaan konkuren yang efisien bisa jadi menantang dan tidak sepele. Ini memerlukan manajemen sumber daya dan koordinasi yang cermat untuk menghindari bottleneck.

Praktik terbaik

• Lacak koneksi aktif menggunakan struktur data seperti list atau dictionary. Atau gunakan teknik lanjutan seperti connection pooling yang juga membantu skalabilitas.
• Gunakan teknik threading atau pemrograman asinkron untuk menangani banyak koneksi klien pada saat yang sama.
• Tutup koneksi dengan benar untuk melepaskan sumber daya dan menghindari kebocoran memori.

Penanganan error

Menangani error seperti kegagalan koneksi, timeout, dan masalah transmisi data sangat penting. Menangani error ini dan memberikan umpan balik yang tepat kepada klien bisa menjadi tantangan, terutama saat melakukan pemrograman socket level rendah.

Praktik terbaik

• Gunakan blok try-except-finally untuk menangkap dan menangani jenis error tertentu.
• Berikan pesan error yang informatif dan pertimbangkan menggunakan logging untuk membantu pemecahan masalah.

Skalabilitas dan performa

Memastikan performa optimal dan meminimalkan latensi adalah perhatian utama saat menangani aliran data ber-volume tinggi atau aplikasi waktu nyata.

Praktik terbaik

• Optimalkan kode Anda untuk performa dengan meminimalkan pemrosesan data yang tidak perlu dan overhead jaringan.
• Terapkan teknik buffering untuk menangani transfer data besar secara efisien.
• Pertimbangkan teknik load balancing untuk mendistribusikan permintaan klien di beberapa instance server.

Keamanan dan autentikasi

Mengamankan komunikasi berbasis socket dan menerapkan mekanisme autentikasi yang tepat bisa jadi sulit. Memastikan privasi data, mencegah akses tidak sah, dan melindungi dari aktivitas berbahaya memerlukan pertimbangan yang cermat dan penerapan protokol yang aman.

Praktik terbaik

• Gunakan protokol keamanan SSL/TLS untuk memastikan transmisi data yang aman dengan mengenkripsi informasi.
• Pastikan identitas klien dengan menerapkan metode autentikasi aman seperti autentikasi berbasis token, kriptografi kunci publik, atau nama pengguna/kata sandi.
• Pastikan data rahasia, seperti kata sandi atau kunci API, dijaga dan dienkripsi atau idealnya tidak disimpan sama sekali (hanya hash-nya jika diperlukan).

Keandalan dan ketahanan jaringan

Menghadapi gangguan jaringan, bandwidth yang berfluktuasi, dan koneksi yang tidak andal dapat menimbulkan tantangan. Menjaga koneksi tetap stabil, menangani pemutusan dengan baik, dan menerapkan mekanisme penyambungan ulang sangat penting untuk aplikasi jaringan yang tangguh.

Praktik terbaik

• Gunakan pesan keep‑alive untuk mendeteksi koneksi yang tidak aktif atau terputus.
• Terapkan timeout untuk menghindari blocking tanpa batas dan memastikan penanganan respons tepat waktu.
• Terapkan logika penyambungan ulang dengan exponential backoff untuk menjalin koneksi kembali jika terputus.

Keterpeliharaan kode

Terakhir namun tidak kalah penting adalah keterpeliharaan kode. Karena sifat level rendah pemrograman socket, pengembang cenderung menulis lebih banyak kode. Ini dapat dengan cepat berubah menjadi kode spaghetti yang sulit dirawat, jadi penting untuk mengorganisasi dan menstrukturkannya sedini mungkin serta mengeluarkan upaya ekstra dalam merencanakan arsitektur kode Anda.

Praktik terbaik

• Pecah kode Anda ke dalam kelas atau fungsi yang idealnya tidak terlalu panjang.
• Tulis unit test sejak awal dengan memalsukan (mock) implementasi klien dan server Anda.
• Pertimbangkan menggunakan pustaka yang lebih tingkat tinggi untuk menangani koneksi kecuali Anda benar-benar harus menggunakan pemrograman socket.

Ringkasan: Pemrograman socket di Python

Socket merupakan bagian integral dari semua aplikasi jaringan. Dalam artikel ini, kita telah melihat pemrograman socket di Python. Berikut poin-poin kunci yang perlu diingat:

• Socket adalah antarmuka yang mengabstraksi manajemen koneksi.
• Socket memungkinkan komunikasi antarproses yang berbeda (biasanya klien dan server) secara lokal atau melalui jaringan.
• Di Python, bekerja dengan socket dilakukan melalui pustaka socket, yang antara lain menyediakan objek socket dengan berbagai metode seperti recv, send, listen, close.
• Pemrograman socket memiliki berbagai aplikasi yang berguna dalam data science, termasuk pengumpulan data, komunikasi antarproses, dan komputasi terdistribusi.
• Tantangan dalam pemrograman socket mencakup manajemen koneksi, integritas data, skalabilitas, penanganan error, keamanan, dan keterpeliharaan kode.

Dengan keterampilan pemrograman socket, pengembang dapat membuat aplikasi jaringan waktu nyata yang efisien. Dengan menguasai konsep dan praktik terbaiknya, mereka dapat memanfaatkan potensi penuh pemrograman socket untuk mengembangkan solusi yang andal dan dapat diskalakan.

Namun, pemrograman socket adalah teknik level sangat rendah, yang sulit digunakan karena engineer aplikasi harus memperhitungkan setiap detail kecil dari komunikasi aplikasi.

Saat ini, kita sangat sering tidak perlu bekerja langsung dengan socket karena biasanya ditangani oleh pustaka dan kerangka kerja tingkat lebih tinggi, kecuali jika ada kebutuhan untuk benar-benar memeras performa aplikasi atau meningkatkannya skalanya.

Namun, memahami socket dan memiliki wawasan tentang cara kerja hal-hal di balik layar mengarah pada kesadaran keseluruhan yang lebih baik sebagai pengembang atau data scientist dan selalu merupakan ide yang baik.

Untuk mempelajari lebih lanjut tentang peran Python dalam analisis jaringan, lihat kursus Intermediate Network Analysis in Python kami. Anda juga dapat mengikuti jalur keterampilan Python Programming kami untuk meningkatkan keterampilan pemrograman Python Anda.