Belajar Python - Networking Dasar & HTTP Clients

#Pendahuluan

Hampir semua aplikasi modern berkomunikasi lewat HTTP — memanggil API, mengirim data, dan berintegrasi dengan layanan lain. Episode 12 membekali kalian dengan keterampilan networking: cara Python menjadi klien HTTP yang andal.

Kita akan membandingkan requests dan httpx, belajar mengatur retries, timeouts, dan connection pooling, lalu memahami server WSGI dan ASGI yang menjadi fondasi web framework di episode 13.

#Menggunakan requests Secara Modern

#Request Dasar

requests adalah library HTTP paling populer untuk Python:

pip install requests

GET request dengan requests

import requests
 
resp = requests.get("https://httpbin.org/json", timeout=10)
print(resp.status_code)
print(resp.json())

requests.get("https://httpbin.org/json", timeout=10) mengirim request GET dan resp.json() menguraikan body JSON. Selalu set timeout agar request tidak menggantung selamanya — salah satu penyebab aplikasi terasa lambat.

#httpx: Sync dan Async

#Mengapa Beralih ke httpx

httpx adalah penerus modern requests dengan dukungan HTTP/2 dan async. API-nya hampir identik, jadi peralihan mudah:

pip install httpx

httpx sync

import httpx
 
resp = httpx.get("https://httpbin.org/json", timeout=10.0)
print(resp.status_code)
print(resp.json()["slideshow"]["title"])

httpx.get(url, timeout=10.0) berperilaku seperti requests. Perbedaan utama ada di dukungan async yang bisa menjalankan banyak request bersamaan.

#httpx Async dengan await

Mode async memakai event loop dan kata kunci await:

httpx async

import asyncio
import httpx
 
async def ambil():
    async with httpx.AsyncClient(timeout=10.0) as klien:
        resp = await klien.get("https://httpbin.org/json")
        return resp.json()
 
hasil = asyncio.run(ambil())
print(hasil["slideshow"]["title"])

async with httpx.AsyncClient(timeout=10.0) as klien: membuka klien async. await klien.get(...) menunggu response tanpa memblokir thread lain. Pola ini sangat efisien untuk banyak request bersamaan dan cocok dengan FastAPI di episode 13.

#Retries, Timeouts, dan Connection Pooling

#Mengatur Timeout

Timeout mencegah aplikasi menggantung saat layanan lambat:

Timeout terpisah

import httpx
 
klien = httpx.Client(
    timeout=httpx.Timeout(connect=5.0, read=30.0, write=10.0, pool=5.0)
)
print(klien.timeout.read)

httpx.Timeout(connect=5.0, read=30.0, ...) memisahkan batas waktu untuk koneksi, baca, tulis, dan pool. Waktu baca yang panjang mengakomodasi API lambat, sementara koneksi tetap cepat gagal jika target tidak terjangkau.

#Retry Otomatis

Retry menangani kegagalan sementara. httpx mendukungnya lewat transport:

Retry dengan httpx

import httpx
 
transport = httpx.HTTPTransport(retries=3)
klien = httpx.Client(transport=transport, timeout=10.0)
 
resp = klien.get("https://httpbin.org/status/500")
print(resp.status_code)

httpx.HTTPTransport(retries=3) membuat transport yang mencoba ulang koneksi yang gagal hingga tiga kali. Untuk retry yang lebih cerdas — misalnya memakai exponential backoff — pertimbangkan library tenacity atau backoff.

#Connection Pooling

Pooling memakai ulang koneksi TCP untuk request berikutnya, menghemat overhead handshake:

Connection pooling dengan httpx

import httpx
 
klien = httpx.Client(
    limits=httpx.Limits(max_connections=20, max_keepalive_connections=10)
)
 
for _ in range(5):
    resp = klien.get("https://httpbin.org/json")
    print(resp.status_code)
 
klien.close()

httpx.Limits(max_connections=20, max_keepalive_connections=10) membatasi jumlah koneksi yang dibuka. Memakai satu klien untuk banyak request menghindari membuat koneksi baru setiap kali — pola penting untuk layanan ber-traffic tinggi.

#WSGI dan ASGI

#Memahami Dua Spesifikasi

Server web Python mengikuti dua spesifikasi berbeda:

• WSGI: sinkron, standar untuk framework seperti Flask dan Django.
• ASGI: asinkron, mendukung WebSocket dan HTTP/2 untuk FastAPI dan Starlette.

Perbedaan inti ada di model eksekusi: WSGI satu request satu thread, ASGI satu event loop menangani banyak request.

#Gunicorn untuk WSGI

Gunicorn adalah server WSGI production yang populer:

pip install gunicorn

gunicorn --workers 4 --bind 0.0.0.0:8000 app:app

gunicorn --workers 4 --bind 0.0.0.0:8000 app:app menjalankan aplikasi WSGI dengan empat worker. Gunicorn mengelola process dan thread untuk menangani banyak request — menjadi tulang punggung deployment Flask dan Django.

#Uvicorn untuk ASGI

Uvicorn adalah server ASGI untuk aplikasi async:

pip install "uvicorn[standard]"

uvicorn --workers 4 --host 0.0.0.0 --port 8000 app:app

uvicorn --workers 4 --host 0.0.0.0 --port 8000 app:app menjalankan aplikasi ASGI. Uvicorn memakai event loop untuk menangani ribuan koneksi bersamaan — fondasi performa FastAPI yang akan kita bangun di episode berikutnya.

#Penutup

Inti yang harus dibawa pulang:

• requests adalah klien HTTP klasik dengan API sederhana.
• httpx mendukung sync dan async dengan dukungan HTTP/2.
• Timeout mencegah request menggantung selamanya.
• Retry dan connection pooling menjaga keandalan dan efisiensi.
• WSGI sinkron dengan Gunicorn untuk Flask dan Django.
• ASGI asinkron dengan Uvicorn untuk FastAPI modern.

Di episode 13 selanjutnya kita akan membahas web frameworks dan API design — perbandingan Flask, Django, dan FastAPI, cara memilih framework yang tepat, merancang RESTful dan GraphQL API, serta versioning, pagination, dan validasi input. Inilah saatnya membangun API sungguhan!