Flask-RESTful, Jurus Kilat Membangun REST API dengan Python

Flask-RESTful adalah sebuah ekstensi untuk framework Flask yang berfungsi sebagai “jurus kilat” untuk mempercepat dan menyederhanakan proses pembuatan REST API di Python. Ia menyediakan abstraksi dan alat bantu yang secara drastis mengurangi jumlah kode boilerplate (kode berulang) yang harus Anda tulis, memungkinkan Anda untuk fokus pada logika bisnis inti dari API Anda.

Bagi banyak developer Python, Flask adalah pilihan favorit untuk memulai sebuah proyek web karena kesederhanaannya. Namun, ketika proyek tersebut berkembang menjadi sebuah REST API yang kompleks dengan banyak endpoint, kesederhanaan Flask bisa berarti Anda harus menulis banyak kode secara manual. Flask-RESTful hadir untuk mengisi celah ini, memberikan struktur dan kecepatan tanpa mengorbankan fleksibilitas yang menjadi ciri khas Flask.

baca juga : Sanic, Rahasia Web Python Performa Tinggi dan Anti Lemot

Masalahnya: Membangun API di Flask ‘Polosan’

Flask sangat mampu digunakan untuk membangun REST API. Anda bisa membuat endpoint yang menerima permintaan GET, POST, PUT, DELETE dan mengembalikan respons dalam format JSON. Namun, jika Anda melakukannya secara “polosan” atau vanilla, Anda akan segera menyadari beberapa hal yang repetitif.

Bayangkan Anda ingin membuat API untuk mengelola data “Pengguna” (User). Anda akan membutuhkan endpoint untuk:

Mendapatkan semua pengguna (GET /users).
Membuat pengguna baru (POST /users).
Mendapatkan satu pengguna spesifik (GET /users/<id>).
Memperbarui satu pengguna (PUT /users/<id>).
Menghapus satu pengguna (DELETE /users/<id>).

Dengan Flask polosan, Anda mungkin akan menulis kode yang terlihat seperti ini:

Python

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    # ... logika ...

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # ... logika ...

@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    # ... logika ...

Anda akan memiliki setidaknya 3-5 fungsi terpisah hanya untuk mengelola satu jenis data. Logikanya menjadi tersebar, dan Anda harus secara manual menangani validasi input dari JSON dan memformat output ke JSON di setiap fungsi. Ini memakan waktu dan rentan terhadap inkonsistensi.

‘Jurus Kilat’ Dimulai: Pendekatan Berbasis ‘Resource’

Flask-RESTful memperkenalkan sebuah “jurus” yang mengubah cara Anda berpikir. Alih-alih berpikir dalam kerangka endpoint atau URL individual, Anda diajak untuk berpikir dalam kerangka Sumber Daya (Resource).

Dalam terminologi REST, resource adalah representasi dari sebuah entitas, seperti “Pengguna”, “Produk”, atau “Artikel”. Semua operasi (GET, POST, PUT, DELETE) yang berhubungan dengan entitas tersebut seharusnya dikelompokkan bersama.

Flask-RESTful memungkinkan Anda untuk melakukan ini dengan sangat elegan. Anda membuat satu kelas Python untuk setiap resource. Di dalam kelas tersebut, Anda mendefinisikan metode-metode yang sesuai dengan kata kerja HTTP (get, post, put, delete). Kemudian, Flask-RESTful akan secara cerdas menangani routing untuk Anda.

Langkah 1: Mengorganisir Logika dengan ‘Resource Class’

Mari kita lihat bagaimana “jurus” ini diterapkan. Alih-alih memiliki banyak fungsi terpisah, kita sekarang memiliki satu kelas yang rapi.

Python

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

# Data dummy untuk contoh
users = {
    "user_1": {"name": "Budi", "age": 25},
    "user_2": {"name": "Ani", "age": 22},
}

# Satu kelas untuk mengelola semua aksi terkait satu pengguna
class UserResource(Resource):
    def get(self, user_id):
        return users[user_id]

    def put(self, user_id):
        # ... logika untuk memperbarui data pengguna ...
        return {"message": "User updated"}, 200

    def delete(self, user_id):
        # ... logika untuk menghapus pengguna ...
        return '', 204

# Satu baris untuk mendaftarkan semua metode HTTP (GET, PUT, DELETE)
api.add_resource(UserResource, '/users/<string:user_id>')

Perhatikan betapa bersihnya pendekatan ini. Semua logika yang berhubungan dengan satu entitas pengguna kini terbungkus rapi di dalam kelas UserResource. Dan yang terpenting, Anda hanya memerlukan satu baris api.add_resource(...) untuk mendaftarkan semua endpoint yang berhubungan dengan user_id. Ini adalah “jurus kilat” pertama yang secara dramatis merapikan kode Anda.

Langkah 2: Mem-parsing Permintaan dengan ‘RequestParser’

Tugas repetitif lainnya dalam membangun API adalah memvalidasi data yang masuk. Misalnya, saat membuat pengguna baru, Anda ingin memastikan bahwa request body berisi field name dan age, dan keduanya memiliki tipe data yang benar.

Cara manual di Flask polosan melibatkan banyak pengecekan if yang membosankan dan rentan kesalahan. Flask-RESTful menyediakan “jurus” untuk ini: RequestParser.

Python

from flask_restful import reqparse

parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=True, help='Nama tidak boleh kosong')
parser.add_argument('age', type=int, required=True, help='Umur harus berupa angka')

class UserListResource(Resource):
    def post(self):
        args = parser.parse_args() # Validasi otomatis terjadi di sini
        # Jika validasi gagal, Flask-RESTful akan otomatis mengirim respons error 400
        
        user_id = "user_" + str(len(users) + 1)
        users[user_id] = {"name": args['name'], "age": args['age']}
        return users[user_id], 201

api.add_resource(UserListResource, '/users')

RequestParser bertindak sebagai “penjaga gerbang” otomatis untuk endpoint Anda. Ia akan memeriksa setiap permintaan yang masuk, memastikan semua field yang required ada, tipe datanya benar, dan jika tidak, ia akan secara otomatis mengembalikan pesan kesalahan yang jelas. Ini menghemat banyak sekali waktu dari penulisan kode validasi manual.

baca juga : Wujud Cinta Tanah Air: Universitas Teknokrat Indonesia Gelar Sholat Ghaib, Doa, dan Zikir Bersama untuk Kedamaian Bangsa

Langkah 3: Memformat Output dengan ‘fields’

Sama seperti validasi input, memformat output JSON secara konsisten juga bisa menjadi pekerjaan yang membosankan. Anda ingin memastikan bahwa setiap kali API Anda mengembalikan data pengguna, formatnya selalu sama.

Flask-RESTful menyediakan “jurus” untuk ini melalui modul fields dan decorator @marshal_with. Ini memungkinkan Anda untuk mendefinisikan sebuah “cetakan” atau “templat” untuk data output Anda.

Python

from flask_restful import fields, marshal_with

# Mendefinisikan 'cetakan' untuk output data pengguna
user_fields = {
    'name': fields.String,
    'age': fields.Integer,
    'uri': fields.Url('user_resource', absolute=True) # Bonus: otomatis membuat URL
}

class UserResource(Resource):
    @marshal_with(user_fields) # Terapkan cetakan pada output metode ini
    def get(self, user_id):
        # Cukup kembalikan objek data mentah dari database/sumber lain
        # Flask-RESTful akan otomatis memformatnya sesuai 'user_fields'
        return users[user_id]

Dengan menggunakan @marshal_with, Anda tidak perlu lagi membuat dictionary secara manual di setiap metode. Anda cukup mengembalikan objek data Anda, dan Flask-RESTful akan menangani pemformatan sesuai dengan cetakan yang telah Anda definisikan. Ini menjamin bahwa respons API Anda selalu konsisten dan profesional.

penulis : Muhammad Anwar Fuadi