Menguasai API Python: Panduan Komprehensif untuk Membangun dan Menggunakan API di Python

API, atau application programming interface, benar-benar menjadi pahlawan dalam pengembangan perangkat lunak modern. API memungkinkan sistem perangkat lunak yang berbeda berkomunikasi satu sama lain, sehingga layanan dapat diintegrasikan dan aplikasi dapat dibangun. Menguasai API adalah keterampilan penting bagi siapa pun yang ingin bekerja dengan data di Python, terutama jika Anda seorang developer. Anda mungkin akan terkejut dengan peluang yang terbuka karena ketika Anda mempelajari keterampilan ini, Anda dapat membangun aplikasi web, terhubung ke layanan eksternal, atau bahkan menggunakan data real-time dalam proyek machine learning.

Dalam panduan ini, kita akan mengeksplorasi dunia API, mempelajari cara menggunakannya di Python, cara membangun API sendiri dengan FastAPI, dan cara menangani tantangan umum yang pasti akan muncul. Di akhir tutorial ini, Anda akan memiliki pemahaman yang solid tentang cara menggunakan API dalam proyek Anda, sehingga proses pengembangan menjadi lebih efisien dan aplikasi Anda lebih bertenaga. Jika Anda merasa kewalahan dengan semua informasi ini, cobalah kursus Introduction to APIs in Python kami, yang membahas setiap bagian secara mendetail.

Apa itu API?

API ibarat jembatan antara aplikasi perangkat lunak yang berbeda. API memungkinkan aplikasi-aplikasi ini berkomunikasi dan saling berbagi informasi.

Bayangkan API sebagai pelayan di restoran. Anda memberi tahu pelayan apa yang Anda inginkan (pesanan Anda), dan mereka menyampaikan permintaan Anda ke dapur. Dapur menyiapkan makanan Anda, dan pelayan mengantarkannya kembali kepada Anda. Demikian pula, Anda mengirim permintaan ke API, dan API memproses permintaan Anda lalu mengembalikan hasilnya.

Agar lebih konkret, mari pertimbangkan beberapa penggunaan nyata: Anda mungkin, misalnya, menggunakan API publik untuk mengambil data keuangan untuk analisis pasar saham atau mengakses data cuaca real-time untuk model prediksi iklim. Seperti yang mungkin Anda perhatikan, API sangat penting untuk bekerja dengan dataset besar dan/atau saat Anda membutuhkan data real-time; jika tidak, Anda mungkin tidak akan kesulitan dengan integrasi.

Cara kerja API Python. Gambar oleh Napkin.AI

Menggunakan API di Python

Menggunakan API di Python adalah cara yang ampuh untuk berinteraksi dengan layanan eksternal, mengambil data, dan mengintegrasikan berbagai fungsionalitas ke dalam aplikasi Anda. Python memudahkan pekerjaan dengan API, terutama melalui pustaka requests, yang memungkinkan Anda mengirim permintaan HTTP untuk berinteraksi dengan API.

Pengantar API di Python

Di Python, berinteraksi dengan API adalah proses yang mudah berkat pustaka requests. Pustaka ini menyederhanakan proses pengiriman permintaan HTTP, memungkinkan Anda berkomunikasi dengan API dan mengambil atau mengirim data.

Membuat permintaan API di Python

Sebelum mulai membuat permintaan API di Python, Anda memerlukan pustaka requests. Anda dapat memasangnya dengan perintah berikut:

pip install requests

Dasar-dasar permintaan API

Mari kita padankan contoh konseptual tentang restoran dengan apa yang sebenarnya terjadi di Python. Berikut uraian sederhananya:

1. Temukan Tempat yang Tepat: Identifikasi endpoint API, yaitu alamat web spesifik tempat Anda akan mengirim permintaan.

2. Lakukan Pesanan Anda: Gunakan pustaka requests di Python untuk mengirim permintaan ke API. Anda akan menentukan jenis tindakan yang ingin dilakukan (seperti mengambil data atau mengirim data).

3. Dapatkan Makanan Anda: API akan mengirimkan respons kembali, yang bisa Anda proses untuk mengekstrak informasi yang dibutuhkan.

Permintaan GET

Permintaan GET adalah jenis permintaan HTTP yang paling umum digunakan untuk mengambil data dari server, mirip dengan meminta informasi; saat Anda mengetik URL di browser dan menekan enter, pada dasarnya Anda mengirimkan permintaan GET ke server tersebut, menentukan sumber daya yang diinginkan, yang kemudian diproses server untuk menemukan dan menyiapkan data yang diminta sebelum mengirimkannya kembali dalam format seperti JSON atau XML.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

Pada contoh ini, kita mengirim permintaan GET ke API fiktif dan mencetak respons JSON. Permintaan GET biasanya digunakan untuk mengambil data tanpa mengubahnya.

Permintaan POST

Sementara permintaan GET mengambil data, permintaan POST mengirimkan instruksi ke server. Ini sering digunakan untuk membuat resource baru (seperti menambahkan pengguna) atau memperbarui yang sudah ada (seperti mengedit profil).

Bayangkan Anda mengisi formulir online untuk mendaftar layanan. Saat Anda mengeklik kirim, pada dasarnya Anda mengirimkan permintaan POST dengan informasi Anda. Berikut contoh sederhananya:

# Data to send (like user information)data = {'name': 'John Doe', 'email': 'john.doe@example.com'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Contoh ini mengirimkan dictionary berisi informasi pengguna sebagai data JSON ke API. Lalu kita memeriksa kode status respons untuk melihat apakah pengguna berhasil dibuat.

Menangani respons

Saat Anda membuat permintaan API, server mengirimkan respons yang mencakup dua informasi kunci:

• Status Code: Angka yang menunjukkan keberhasilan atau kegagalan permintaan. Misalnya, 200 biasanya berarti sukses, sementara 404 berarti sumber daya tidak ditemukan.
• Data: Informasi yang Anda minta, sering kali dalam format JSON. Di sinilah konten yang berharga berada.

Berikut contoh Python:

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

Memahami Kode Status API Python

Kode status API adalah respons standar yang dikirim server untuk menunjukkan hasil dari permintaan klien. Kode-kode ini membantu developer memahami apakah permintaan berhasil, terjadi kesalahan, atau tindakan lebih lanjut diperlukan.

Kode status umum

• 200 OK: Kode status ini menunjukkan bahwa permintaan berhasil. Misalnya, ketika Anda membuat permintaan GET untuk mengambil data dari API, respons 200 OK berarti data berhasil diambil.  

• 404 Not Found: Kode ini dikembalikan saat server tidak dapat menemukan sumber daya yang diminta. Contohnya, jika Anda mencoba mengakses endpoint yang tidak ada, Anda akan menerima error 404 Not Found.

• 500 Internal Server Error: Kode ini menandakan ada sesuatu yang salah di sisi server. Ini adalah pesan kesalahan umum yang dapat terjadi karena berbagai masalah, seperti bug pada kode server atau masalah dengan basis data.

Menangani berbagai kode status

Menangani kode status API secara efektif dalam aplikasi Python Anda memastikan kode berperilaku prediktif dan dapat menangani error dengan baik. Jika respons 200, lanjutkan memproses data yang dikembalikan. Saat menghadapi error 404, periksa apakah URL endpoint sudah benar, dan bila perlu, terapkan logika fallback atau informasikan kepada pengguna bahwa sumber daya tidak tersedia. Untuk error 500, pertimbangkan untuk mencoba kembali permintaan setelah jeda singkat atau mencatat error untuk investigasi lebih lanjut. Namun, hindari terlalu banyak percobaan ulang agar tidak membebani server.

Membangun API Python

Membangun API dengan Python memungkinkan Anda membuat antarmuka aplikasi yang kuat dan efisien. Kesederhanaan Python dan pustaka yang andal menjadikannya pilihan yang sangat baik untuk pengembangan API.

Pengantar FastAPI

Sekarang setelah Anda tahu cara menggunakan API, mari kita lihat bagaimana kita dapat membangunnya sendiri. FastAPI adalah framework web modern dan cepat (berperforma tinggi) untuk membangun API dengan Python. Sesuai namanya, FastAPI dirancang agar mudah digunakan. Salah satu hal yang saya sukai dari FastAPI adalah ia juga secara otomatis menghasilkan dokumentasi interaktif.

Menyiapkan FastAPI

Untuk mulai, Anda memerlukan Python dan pengelola paketnya, pip, yang sudah terpasang. Selanjutnya, pasang FastAPI dan Uvicorn, server ASGI berperforma tinggi:

pip install fastapi uvicorn

Catatan samping: Jika Anda mengalami masalah dengan penyiapan Python atau pip, lihat tutorial kami: How to Upgrade Python and Pip in Windows, MacOS, and Linux.

Membuat API sederhana

Mari membangun API sederhana yang mengembalikan salam singkat:

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Untuk meluncurkan API ini, jalankan perintah berikut:

uvicorn main:app --reload

Perintah ini memulai server Uvicorn, menyajikan API Anda di http://127.0.0.1:8000. Mengakses URL ini di browser akan menghasilkan respons {"Hello": "World"}.

Fitur Lanjutan FastAPI

FastAPI bukan hanya tentang membuat API sederhana dengan cepat; FastAPI juga menawarkan berbagai fitur lanjutan yang membuatnya cocok untuk aplikasi yang kompleks dan berperforma tinggi. Berikut beberapa kemampuan utamanya: 

Parameter kueri

Di FastAPI, menambahkan dan menangani parameter kueri sangat mudah, berkat pemanfaatan type hints Python. Parameter kueri adalah bagian dari URL dan digunakan untuk mengirim data opsional ke endpoint API, sering kali untuk memfilter atau memodifikasi data yang dikembalikan.

Menambahkan parameter kueri

Untuk menambahkan parameter kueri di FastAPI, Anda cukup mendefinisikannya sebagai argumen fungsi pada fungsi operasi path Anda. Jika parameter bersifat opsional, Anda dapat memberinya nilai default, seperti None. Sebagai contoh, misalkan Anda memiliki endpoint yang mengambil item dari database. Anda ingin memungkinkan pengguna memfilter item berdasarkan kueri pencarian:

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

Pada contoh ini, q adalah parameter kueri opsional. Jika kita memberikan nilai untuk q, hasilnya difilter berdasarkan kueri tersebut. Jika q tidak disediakan, endpoint mengembalikan semua item.

Menangani parameter kueri

FastAPI secara otomatis menangani parameter kueri, termasuk validasi dan konversi tipe. Misalnya, jika Anda menentukan parameter kueri sebagai integer, FastAPI akan memvalidasi bahwa input memang integer. Jika input tidak sesuai tipe yang diharapkan, FastAPI mengembalikan pesan kesalahan yang jelas.

Berikut contoh dengan parameter kueri wajib dan validasi tipe:

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

Dalam kasus ini, item_id adalah parameter path, dan q adalah parameter kueri opsional. FastAPI akan memastikan bahwa item_id adalah integer dan akan memproses parameter kueri q jika disediakan.

Menangani berbagai metode HTTP

Mengimplementasikan berbagai metode HTTP seperti GET, POST, PUT, dan DELETE itu mudah dan mirip dengan cara Anda mendefinisikan rute di framework lain. Setiap metode terkait dengan jenis operasi tertentu, seperti mengambil data (GET), membuat data baru (POST), memperbarui data yang ada (PUT), atau menghapus data (DELETE).

Metode GET

Metode GET digunakan untuk mengambil data dari server. Di FastAPI, Anda mendefinisikan endpoint GET seperti ini:

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

Metode POST

Metode POST digunakan untuk membuat data baru. Anda dapat mendefinisikan endpoint POST dan menerima data di body permintaan:

@app.post("/items/")def create_item(item: dict):    return {"item": item}

Metode PUT

Metode PUT digunakan untuk memperbarui data yang ada. Biasanya memerlukan pengenal dan data baru:

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

Metode DELETE

Metode DELETE digunakan untuk menghapus data. Di FastAPI, endpoint DELETE didefinisikan sebagai berikut:

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Autentikasi dan keamanan

FastAPI menawarkan beberapa mekanisme untuk menerapkan autentikasi dan keamanan:

• HTTP Basic Auth: Metode yang sederhana, tetapi umumnya tidak direkomendasikan untuk lingkungan produksi karena masalah keamanan.
• API Keys: Opsi yang lebih aman dengan menghasilkan kunci unik untuk klien.
• OAuth 2.0: Standar otorisasi yang kompleks namun tangguh, umum digunakan untuk integrasi pihak ketiga.
• JSON Web Tokens (JWT): Pendekatan populer untuk merepresentasikan klaim secara aman antara dua pihak.