Apakah Socket itu?

Socket adalah penghubung antara dua aplikasi yang dapat berkomunikasi satu sama lain (baik
secara lokal pada satu mesin atau secara jarak jauh antara dua mesin di lokasi terpisah).

Pada dasarnya, socket berfungsi sebagai tautan komunikasi antara dua entitas, yaitu server
dan klien. Server akan memberikan informasi yang diminta oleh klien. Misalnya, ketika Anda
mengunjungi halaman ini, browser membuat socket dan terhubung ke server.

Modul Socket

Untuk membuat socket, Anda menggunakan fungsi socket.socket(), dan sintaksnya

sesederhana:

import socket
s= socket.socket (socket_family, socket_type, protocol=0)

Berikut uraian argumennya:

• socket_family: Mewakili keluarga alamat (dan protokol). Ini bisa berupa AF_UNIX atau
AF_INET.
• socket_type: Mewakili jenis soket, dan dapat berupa SOCK_STREAM atau SOCK_DGRAM.
• protocol: Ini adalah argumen opsional, dan biasanya default ke 0.

Setelah mendapatkan objek socket Anda, Anda kemudian dapat membuat server atau klien
sesuai keinginan menggunakan metode yang tersedia di modul socket.

Buat Klien Sederhana

Sebelum memulai, mari kita lihat metode socket klien yang tersedia dengan Python.

• s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
• s.connect(): Memulai koneksi server TCP.

Untuk membuat socket baru, Anda harus mengimpor metode socket kelas socket terlebih
dahulu.

import socket

Selanjutnya, kita akan membuat soket aliran (TCP) sebagai berikut:

stream_socket = socket.socket( socket.AF_INET, socket.SOCK_STREAM )

Argumen AF_INET menunjukkan bahwa Anda meminta socket Internet Protocol (IP),
khususnya IPv4. Argumen kedua adalah jenis protokol transport SOCK_STREAM untuk soket
TCP. Selain itu, Anda juga dapat membuat socket IPv6 dengan menentukan argumen socket
AF_INET6.
Tentukan server.

server = "localhost"

Tentukan port yang ingin kita komunikasikan.

port =80

Hubungkan soket ke port tempat server mendengarkan.

server_address = ((host, port))

stream_socket.connect(server_address)

Penting untuk dicatat bahwa host dan port harus berupa tuple.

Kirim permintaan data ke server:

message = 'message'
stream_socket.sendall(message.encode(‘utf-8’))

Dapatkan respon dari server:

data = sock.recv(10)
print data

Untuk menutup soket yang terhubung, Anda menggunakan metode tutup:

stream_socket.close()

Di bawah ini adalah kode lengkap untuk Klien / Server.

import socket
import sys

# Create a TCP/IP socket

stream_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Define host

host = 'localhost'

# define the communication port

port = 8080
# Connect the socket to the port where the server is listening

server_address = ((host, port))

print "connecting"

stream_socket.connect(server_address)

# Send data

message = 'message'
stream_socket.sendall(message.encode(‘utf-8’))

# response

data = stream_socket.recv(10)
print data

print 'socket closed'

stream_socket.close()

Bangun Server Sederhana

Sekarang mari kita lihat server Python sederhana. Berikut ini adalah metode server socket
yang tersedia dengan Python.

• s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
• s.bind(): Mengikat alamat (nama host, nomor port) ke soket.
• s.listen(): Mengatur dan memulai pendengar TCP.
• s.accept(): Menerima koneksi klien TCP.

Kami akan mengikuti langkah-langkah berikut:

• Buat socket.
• Ikat soket ke port.
• Mulai menerima koneksi pada soket.

Di sini adalah program server.

import socket
import sys

# Create a TCP/IP socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Define host
host = 'localhost'

# define the communication port

port = 8080

# Bind the socket to the port

sock.bind((host, port))
# Listen for incoming connections

sock.listen(1)

# Wait for a connection

print 'waiting for a connection'

connection, client = sock.accept()

print client, 'connected'

# Receive the data in small chunks and retransmit it

data = connection.recv(16)
print 'received "%s"' % data
if data:

connection.sendall(data)
else:
print 'no data from', client

# Close the connection

connection.close()

Server sekarang siap untuk koneksi masuk.

Sekarang jalankan program klien dan server di jendela terminal terpisah, sehingga mereka
dapat berkomunikasi satu sama lain.

Keluaran Server
$ python server.py
waiting for a connection
('127.0.0.1', 47050) connected
received "message"
Keluaran Klien
$ python client.py
connecting
message
socket closed

Menulis aplikasi klien/server echo TCP

sederhana
Setelah pengujian dengan API soket dasar di Python, mari kita buat server soket TCP dan klien sekarang.
Di sini, Anda akan memiliki kesempatan untuk memanfaatkan pengetahuan dasar Anda yang diperoleh
dalam resep sebelumnya.

Bagaimana melakukannya ...

Dalam contoh ini, server akan menggemakan apa pun yang diterimanya dari klien. Kita akan
menggunakan modul Python argparse untuk menentukan port TCP dari baris perintah. Baik server dan
skrip klien akan mengambil argumen ini.
Pertama, kita membuat server. Kita mulai dengan membuat objek soket TCP. Kemudian, kita mengatur
alamat penggunaan kembali sehingga kita dapat menjalankan server sebanyak yang kita butuhkan. Kami
mengikat soket ke port yang diberikan pada mesin lokal kami. Pada tahap mendengarkan, kita
memastikan bahwa kita mendengarkan beberapa klien dalam antrean menggunakan argumen backlog ke
metode listen( ). Akhirnya, kita menunggu klien terhubung dan mengirim beberapa data ke server. Ketika
data diterima, server menggemakan kembali data ke klien.
Listing ini menunjukkan cara menulis aplikasi klien /server echo TCP sederhana sebagai berikut:

import socket
import sys
import argparse

host = 'localhost'
data_payload = 2048
backlog = 5

def echo_server(port):
""" A simple echo server """
# Create a TCP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Enable reuse address/port
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Bind the socket to the port
server_address = (host, port)
print ("Starting up echo server on %s port %s" % server_address)
sock.bind(server_address)
# Listen to clients, backlog argument specifies the max no. of queued connections
sock.listen(backlog)
while True:
print ("Waiting to receive message from client")
client, address = sock.accept()
data = client.recv(data_payload)
if data:
print ("Data: %s" %data)
 client.send(data)
print ("sent %s bytes back to %s" % (data, address))
# end connection
client.close()

if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Socket Server Example')
parser.add_argument('--port', action="store", dest="port", type=int, required=True)
given_args = parser.parse_args()
port = given_args.port
echo_server(port)

Pada kode sisi klien, kita membuat soket klien menggunakan argumen port dan terhubung ke
server. Kemudian, klien mengirim pesan, Pesan uji. Ini akan digaungkan ke server, dan klien
segera menerima pesan kembali dalam beberapa segmen. Di sini, dua blok try-except
dibangun untuk menangkap pengecualian selama sesi interaktif ini.

Daftar ini menunjukkan klien echo TCP sebagai berikut:

import socket
import sys

import argparse

host = 'localhost'

def echo_client(port):
""" A simple echo client """
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect the socket to the server
server_address = (host, port)
print ("Connecting to %s port %s" % server_address)
sock.connect(server_address)

# Send data
try:
# Send data
message = "Test message. This will be echoed"
print ("Sending %s" % message)
sock.sendall(message.encode('utf-8'))
except socket.error as e:
print ("Socket error: %s" %str(e))
except Exception as e:
print ("Other exception: %s" %str(e))
finally:
print ("Closing connection to the server")
sock.close()

if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Socket Server Example')
parser.add_argument('--port', action="store", dest="port", type=int, required=True)
given_args = parser.parse_args()
port = given_args.port
echo_client(port)

Cara kerjanya...
Untuk melihat interaksi klien/server, luncurkan skrip server berikut di satu konsol:
$ python echo_server.py --port=9900
Starting up echo server on localhost port 9900
Waiting to receive message from client
Sekarang, jalankan klien dari Terminal lain sebagai berikut:
$ python echo_client.py --port=9900
Connecting to localhost port 9900
Sending Test message. This will be echoed
Received: Test message. Th
Received: is will be echoe
Received: d
Closing connection to the server

Setelah menerima pesan dari klien, server juga akan mencetak sesuatu yang mirip dengan pesan berikut:
Data: Test message. This will be echoed sent
Test message. This will be echoed bytes back
to ('127.0.0.1', 42961) Waiting to receive
message from client

Menulis aplikasi klien/server echo UDP

sederhana
Karena kita telah mengembangkan server dan klien TCP sederhana dalam resep sebelumnya, kita
sekarang akan melihat cara mengembangkan hal yang sama dengan UDP.

Bagaimana melakukannya ...

Resep ini mirip dengan yang sebelumnya, kecuali yang ini dengan UDP. Metode recvfrom() membaca
pesan dari soket dan mengembalikan data dan alamat klien.
Daftar ini menunjukkan cara menulis aplikasi klien /server gema UDP sederhana sebagai berikut:
import socket
import sys
import argparse

host = 'localhost'
data_payload = 2048

def echo_server(port):
""" A simple echo server """
# Create a UDP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# Bind the socket to the port

server_address = (host, port)
print ("Starting up echo server on %s port %s" % server_address)
sock.bind(server_address)
while True:
print ("Waiting to receive message from client")
data, address = sock.recvfrom(data_payload)
print ("received %s bytes from %s" % (len(data), address))
print ("Data: %s" %data)
if data:
sent = sock.sendto(data, address)
print ("sent %s bytes back to %s" % (sent, address))

if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Socket Server Example')
parser.add_argument('--port', action="store", dest="port", type=int,
required=True)
given_args = parser.parse_args()
 port = given_args.port
echo_server(port)
Pada kode sisi klien, kita membuat soket klien menggunakan argumen port dan terhubung ke server,
seperti yang kita lakukan pada resep sebelumnya. Kemudian, klien mengirim pesan, Pesan uji. Ini akan
digaungkan, dan klien segera menerima pesan kembali dalam beberapa segmen.

Listing berikut menunjukkan klien echo sebagai berikut:

import socket
import sys
import argparse

host = 'localhost'
data_payload = 2048

def echo_client(port):
""" A simple echo client """
# Create a UDP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind the socket to the port
server_address = (host, port)
print ("Connecting to %s port %s" % server_address)
message = 'This is the message. It will be repeated.'

try:
# Send data
message = "Test message. This will be echoed"
print ("Sending %s" % message)
sent = sock.sendto(message.encode('utf-8'), server_address)
# Receive response
data, server = sock.recvfrom(data_payload)
print ("received %s" % data)
finally:
print ("Closing connection to the server")
sock.close()

if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Socket Server Example')
parser.add_argument('--port', action="store", dest="port", type=int,
required=True)
given_args = parser.parse_args()
port = given_args.port
echo_client(port)

Cara kerjanya...
Untuk melihat interaksi klien/server, luncurkan skrip server berikut di satu konsol:
$ python echo_server_udp.py --port=9900
Starting up echo server on localhost port 9900
Waiting to receive message from client

Sekarang, jalankan klien dari terminal lain sebagai berikut:

$ python echo_client_udp.py --port=9900
Connecting to localhost port 9900
Sending Test message. This will be echoed received
Test message. This will be echoed Closing connection
to the server

Setelah menerima pesan dari klien, server juga akan mencetak sesuatu yang mirip dengan pesan berikut:
received 33 bytes from ('127.0.0.1', 43542)
Data: Test message. This will be echoed sent 33
bytes back to ('127.0.0.1', 43542)
Waiting to receive message from client