Indonesian (Bahasa Indonesia) translation by Aditia Dwiperdana (you can also view the original English article)
REpresentational State Transfer (REST) adalah arsitektur desain pengembangan web yang mengacu pada membagi secara logis sumber daya API agar mudah diakses, dimanipulasi, dan dikembangkan. Komponen yang bisa digunakan ulang ditulis sedemikian rupa agar bisa ditangani dengan request HTTP yang sederhana dan mudah dimengerti yang bisa berupa GET, POST, PUT, PATCH, dan DELETE (masih ada lagi, tapi request tersebut adalah yang paling umum digunakan).
Tidak peduli seperti apa kelihatannya, REST tidak memaksakan protokol atau standar tertentu. REST hanya mengatur arsitektur perangkat lunak untuk menulis aplikasi web dan API, dan menghasilkan penyederhanaan antarmuka di dalam dan di luar aplikasi. API web service yang ditulis mengikuti prinsip REST disebut RESTful API.
Dalam seri tutorial tiga bagian ini, saya akan membahas berbagai cara membuat RESTful API menggunakan Flask sebagai framework web. Pada bagian pertama, saya akan membahas bagaimana membuat REST API berbasis kelas yang cocok dibuat sendiri atau DIY (do it yourself), contohnya mengimplementasinya sendiri tanpa menggunakan ekstensi pihak ketiga. Di bagian berikutnya dari seri ini, saya akan membahas bagaimana memanfaatkan berbagai ekstensi Flask untuk membuat REST API yang lebih efektif dengan cara yang lebih mudah.
Saya asumsikan kamu punya pemahaman Flask dasar dan pengaturan lingkungan menggunakan virtualenv saat mengembangkan aplikasi Python.
Instalasi Ketergantungan
Package berikut perlu diinstall untuk aplikasi yang akan kita buat.
$ pip install flask $ pip install flask-sqlalchemy
Perintah di atas akan menginstall semua package yang dibutuhkan untuk menjalankan aplikasi ini.
Aplikasi Flask
Untuk tutorial ini, saya akan membuat aplikasi kecil di mana saya akan buat model sederhana untuk Product. Lalu saya akan mendemonstrasikan bagaimana menulis RESTful API untuk model tersebut. Di bawah ini adalah struktur dari aplikasi kita.
flask_app/
my_app/
- __init__.py
product/
- __init__.py // Empty file
- models.py
- views.py
- run.py
Saya tidak akan membuat front-end untuk aplikasi ini karena RESTful API bisa diuji langsung dengan membuat panggilan HTTP menggunakan berbagai cara.
flask_app/my_app/__init__.py
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' db = SQLAlchemy(app) from my_app.catalog.views import catalog app.register_blueprint(catalog) db.create_all()
Pada file di atas, aplikasi sudah diatur dengan inisialisasi ekstensi dan pembuatan database. Pernyataan terakhir membuat database baru di lokasi yang berdasarkan SQLALCHEMY_DATABASE_URI jika database belum ada di lokasi tersebut, jika tidak, pernyataan tersebut akan membuka aplikasi dengan database yang sama.
flask_app/my_app/catalog/models.py
from my_app import db
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
price = db.Column(db.Float(asdecimal=True))
def __init__(self, name, price):
self.name = name
self.price = price
def __repr__(self):
return '<Product %d>' % self.id
Pada file di atas, saya sudah umembuat model yang sangat sederhana untuk menyimpan nama dan harga Product. Ini akan membuat tabel di SQLite mengikuti detail yang disediakan pada model.
flask_app/my_app/catalog/views.py
import json
from flask import request, jsonify, Blueprint, abort
from flask.views import MethodView
from my_app import db, app
from my_app.catalog.models import Product
catalog = Blueprint('catalog', __name__)
@catalog.route('/')
@catalog.route('/home')
def home():
return "Welcome to the Catalog Home."
class ProductView(MethodView):
def get(self, id=None, page=1):
if not id:
products = Product.query.paginate(page, 10).items
res = {}
for product in products:
res[product.id] = {
'name': product.name,
'price': str(product.price),
}
else:
product = Product.query.filter_by(id=id).first()
if not product:
abort(404)
res = {
'name': product.name,
'price': str(product.price),
}
return jsonify(res)
def post(self):
name = request.form.get('name')
price = request.form.get('price')
product = Product(name, price)
db.session.add(product)
db.session.commit()
return jsonify({product.id: {
'name': product.name,
'price': str(product.price),
}})
def put(self, id):
# Update the record for the provided id
# with the details provided.
return
def delete(self, id):
# Delete the record for the provided id.
return
product_view = ProductView.as_view('product_view')
app.add_url_rule(
'/product/', view_func=product_view, methods=['GET', 'POST']
)
app.add_url_rule(
'/product/<int:id>', view_func=product_view, methods=['GET']
)
Inti dari tutorial ini adalah menangani file di atas. Flask menyediakan kegunaan bernama pluggable view, yang membuat kamu bisa membuat view dalam bentuk kelas dibanding sebagai fungsi. Pengiriman berbasis fungsi (MethodView) adalahaah implementasi pluggable view yang membuat kamu bisa menulis fungsi yang sesuai dengan fungsi HTTP dalam huruf kecil. Pada contoh di atas, saya menulis fungsi get() dan post() mengikuti fungsi HTTP GET dan POST.
Routing juga diimplementasi dengan cara yang berbeda, dalam beberapa baris di file di atas. Kita bisa mendefinisikan fungsi yang akan didukung oleh aturan apa saja. Panggilan HTTP lain akan menghasilkan Error 405 Method not allowed.
Menjalankan Aplikasi
Untuk menjalankan aplikasi, eksekusi skrip run.py. Isi script tersebut adalah:
from my_app import app app.run(debug=True)
Sekarang eksekusi dari command line:
$ python run.py
Untuk memeriksa apakah aplikasinya berjalan dengan benar, buka http://127.0.0.1:5000/ di browser, dan sebuah layar sederhana dengan pesan selamat datang akan menyambutmu.
Menguji RESTful API
Untuk menguji API ini, kita bisa buat panggilan HTTP menggunakan salah satu fungsi yang tersedia. Pemanggilan GET akan bisa dilakukakn langsung menggunakan browser. Panggilan POST bisa dibuat menggunakan ekstensi Chrome seperpti Postman atau dari command line menggunakan curl, atau kita bisa menggunakan library requests untuk melakukannya. Saya akan menggunakan library requests di sini dalam rangka demonstrasi.
Pertama kita buat panggilan GET untuk memastikan kita tidak punya produk yang sudah dibuat. Sesuai desain RESTful API, panggilan get seperti /product/ akan mendaftar semua produk. Lalu saya akan buat beberapa produk dengan membuat panggilan POST terhadap /product/ dengan beberapa data. Lalu panggilan GET pada /product/ akan mendaftar semua produk yang dibuat. Untuk mendapatkan produk tertentu, bisa kita lakukan dengan membuat panggilan GET terhadap /product/<product id>. Di bawah ini adalah contoh dari semua pemanggilan yang bisa digunakan pada contoh ini.
$ pip install requests
$ python
>>> import requests
>>> r = requests.get('http://localhost:5000/product/')
>>> r.json()
{}
>>> r = requests.post('http://localhost:5000/product/', data={'name': 'iPhone 6s', 'price': 699})
>>> r.json()
{u'1': {u'price': u'699.0000000000', u'name': u'iPhone 6s'}}
>>> r = requests.post('http://localhost:5000/product/', data={'name': 'iPad Pro', 'price': 999})
>>> r.json()
{u'2': {u'price': u'999.0000000000', u'name': u'iPad Pro'}}
>>> r = requests.get('http://localhost:5000/product/')
>>> r.json()
{u'1': {u'price': u'699.0000000000', u'name': u'iPhone 6s'}, u'2': {u'price': u'999.0000000000', u'name': u'iPad Pro'}}
>>> r = requests.get('http://localhost:5000/product/1')
>>> r.json()
{u'price': u'699.0000000000', u'name': u'iPhone 6s'}
Kesimpulan
Pada tutorial ini, kamu lihat bagaimana membuat antarmuka RESTful kamu sendiri menggunakan kegunaan pluggable view dari Flask. Ini adalah pendekatan paling fleksibel untuk membuat REST API, tapi membutuhkan banyak kode untuk ditulis.
Ada ekstensi yang memudahkan dan mengotomasi pembuatan RESTful API. Saya akan membahasnya di beberapa bagian berikutnya dari seri tutorial ini.
