Pembaca seperti Anda membantu mendukung MUO. Saat Anda melakukan pembelian menggunakan tautan di situs kami, kami dapat memperoleh komisi afiliasi. Baca selengkapnya.

Membangun REST API seringkali merupakan tugas mekanis, yang melibatkan banyak desain boilerplate dan pemrograman hafalan. Untungnya, alat seperti FastAPI dapat menghilangkan banyak detail yang membosankan.

Menggunakan FastAPI, Anda dapat dengan cepat membuat REST API yang efisien dan lengkap untuk aplikasi CRUD Anda. Dengan MongoDB sebagai sumber data, tutorial ini akan memandu Anda menyiapkan API Anda sendiri dalam waktu singkat.

Apa itu FastAPI?

FastAPI adalah kerangka web Python sumber terbuka dan cepat untuk membangun API. Ini memberikan dukungan bawaan untuk permintaan asinkron, validasi data otomatis, dan dokumentasi otomatis titik akhir API.

Keunggulan FastAPI Dibandingkan Framework Python Lainnya

  • FastAPI relatif lebih cepat daripada kerangka kerja lain seperti Django dan Flask. Ini karena FastAPI dibangun di atas asyncio, pustaka I/O asinkron untuk Python yang dapat memproses permintaan bersamaan dengan lebih cepat.
    instagram viewer
  • FastAPI menyediakan cara yang bersih dan sederhana untuk membangun API dengan sedikit usaha karena membutuhkan lebih sedikit kode daripada Flask atau Django.
  • Terakhir, FastAPI mempermudah pembuatan dokumentasi untuk titik akhir. Ini menggunakan Swagger untuk menghasilkan dokumentasi yang dapat Anda gunakan untuk menguji titik akhir dengan menjalankan permintaan dan melihat respons.

Siapkan Database MongoDB

Untuk memulai, Anda harus melakukannya mengatur Database MongoDB secara lokal. Atau, Anda dapat memilih opsi yang lebih mudah menyiapkan klaster MongoDB di Cloud.

Selanjutnya, dengan menggunakan alat antarmuka pengguna grafis MongoDB, Kompas, buat koneksi database. Klik Koneksi Baru tombol dan berikan URI koneksi untuk membuat koneksi dengan server MongoDB yang berjalan secara lokal.

Terakhir, buat database dan koleksi baru untuk menyimpan data API pengujian Anda.

Menyiapkan Server FastAPI

Menggunakan terminal, buat folder proyek, dan masuk ke direktori baru itu.

Anda dapat menemukan kode proyek ini di dalamnya repositori GitHub.

Selanjutnya, periksa apakah Anda menjalankan Python versi 3.6+. Jika tidak, instal yang terbaru Piton Versi: kapan.

python --versi

Setelah itu, instal Virtualenv untuk membuat lingkungan pengembangan virtual yang terisolasi. Ini sangat disarankan karena memungkinkan Anda menghindari konflik, terutama jika Anda menggunakan versi paket yang berbeda untuk proyek yang berbeda.

pip instal virtualenv

Selanjutnya, buat lingkungan virtual yang disebut "venv" di dalam direktori Anda saat ini:

virtualenv venv

Terakhir, aktifkan lingkungan virtual.

# Di Unix atau MacOS: 
sumber venv/bin/aktifkan
# Di Windows:
 .\venv\Scripts\aktifkan

Setelah Anda mengonfigurasi lingkungan virtual, instal paket FastAPI, PyMongo, dan Uvicorn.

pip instal fastapi pymongo uvicorn

PyMongo adalah pustaka berbasis Python untuk bekerja dengan database MongoDB. Ini menyediakan API yang mendukung semua fitur MongoDB dan memungkinkan Anda berinteraksi dengan MongoDB tanpa harus menulis kueri MongoDB mentah.

Uvicorn, di sisi lain, adalah server web asinkron berdasarkan modul Python asyncio. Fitur utamanya adalah hot reload server FastAPI Anda saat bepergian. Menggunakan Uvicorn, mirip dengan bekerja dengan Nodemon.

Buat Server FastAPI

Terakhir, buat server FastAPI sederhana yang mendengarkan untuk mendapatkan permintaan yang datang dari rute asal. Di direktori root folder proyek Anda, buat file server.py dan tambahkan kode di bawah ini.

dari fastapi impor FastAPI
aplikasi = FastAPI()
@aplikasi.dapatkan("/")
asinkrondefrumah():
kembali {"pesan": "Halo Dunia"}

Terakhir, jalankan perintah di bawah ini untuk mengaktifkan server pengembangan. Uvicorn akan melayani aplikasi Anda di port 8000.

server uvicon: aplikasi --reload

Lanjutkan dan lihat respons server di browser Anda di http://localhost: 8000.

Buat REST API Dengan Operasi CRUD

Sekarang bangun REST API yang mengimplementasikan metode CRUD (buat, baca, perbarui, dan hapus). Di direktori root folder proyek Anda, buat empat folder: config, model, rute, dan skema.

├── konfigurasi
├── model
├── rute
├── skema
└── server.py

1. Konfigurasi Koneksi Database

Di direktori config, buat file baru, db.py, dan tambahkan kode di bawah ini.

dari pymongo impor Klien Mongo
db_koneksi = MongoClient("mongodb://localhost: 27017")
db = db_connection.database_name
koleksi = db["nama_koleksi"]
  • Gunakan metode MongoClient() untuk membuat koneksi ke database MongoDB. Dibutuhkan koneksi string URI sebagai argumen yang menentukan host dan port dari server MongoDB.
  • Kedua variabel tersebut menentukan database dan koleksi mana di server MongoDB Anda yang harus diakses oleh server.

2. Tentukan Model Data

Model ini akan menentukan struktur data Anda dalam database termasuk bidang dan tipe data.

Di direktori model, buat file baru, user_model.py, dan tambahkan kode di bawah ini.

dari pydantic impor BaseModel 
kelasPengguna(Model Dasar):
 nama: str
 peran: str
  • Kode di atas membuat kelas bernama User, yang merupakan subkelas dari kelas BaseModel dari pustaka Pydantic. Kelas Pengguna memiliki dua bidang, nama, dan peran dengan tipe datanya diatur ke string.
  • Anda dapat menggunakan pustaka Pydantic dengan FastAPI untuk membuat model data. Anda juga dapat menggunakannya untuk memvalidasi data, membuat serial (JSON ke Python), dan menghapus serialnya (Python ke JSON).

3. Tentukan Skema Data

Dari model data yang dibuat, Anda dapat menentukan skema untuk data Anda. Di direktori schemas, buat file baru: user_schema.py, dan tambahkan kode di bawah ini.

defuser_serializer(pengguna) -> dik:
kembali {
'pengenal':str (pengguna["_pengenal"]),
'nama':pengguna["nama"],
'peran':pengguna["peran"]
 }
defusers_serializer(pengguna) -> daftar:
kembali [user_serializer (pengguna) untuk pengguna di dalam pengguna]

4. Tentukan Rute API

Terakhir, tentukan rute untuk operasi CRUD yang berbeda.

Di direktori rute, buat file baru: user_routes.py, dan tambahkan kode di bawah ini.

Tambahkan Data Dengan Metode Posting

Buat rute pos untuk menambahkan data.

dari fastapi impor APIRouter
dari model.user_model impor Pengguna
dari schemas.user_schema impor users_serializer
dari bson impor ObjectId
dari config.db impor koleksi
pengguna = APIRouter()
@pengguna.posting("/")
asinkrondefbuat pengguna(pengguna: Pengguna):
 _id = collection.insert_one (dict (pengguna))
 pengguna = users_serializer (collection.find({"_pengenal": _id.inserted_id}))
kembali {"status": "Oke","data": pengguna}
  • FastAPI menyediakan metode APIRouter() yang mendefinisikan objek router yang menyediakan antarmuka untuk membuat permintaan API ke server.
  • Tentukan rute pos yang membuat objek pengguna baru di database dengan memasukkan data ke dalam koleksi setelah membuat serial. Selanjutnya, simpan dan berikan insert_id untuk menemukan data asosiasi dalam koleksi, dan terakhir, kembalikan status "Ok" dengan data dalam respons, jika permintaan postingan berhasil.
  • Metode insert_one dan find ditentukan oleh klien PyMongo.

Sekarang, tambahkan kode di bawah ini ke server.py untuk menginisialisasi rute.

dari rute.pengguna_rute impor pengguna
app.include_router (pengguna)

Silakan dan uji rute posting di browser Anda menggunakan alat Swagger UI API yang disediakan oleh FastAPI.

Membaca Data Dengan Metode Get

Setelah menentukan rute pos dan menginisialisasi rute, tentukan sisa rute lainnya.

@pengguna.dapatkan("/")
asinkrondeftemukan_semua_pengguna():
 pengguna = users_serializer (collection.find())
kembali {"status": "Oke","data": pengguna}

@pengguna.dapatkan("/{id}")
asinkrondefget_one_user(id: str):
 pengguna = users_serializer (collection.find({"_pengenal": ObjectId (id)}))
kembali {"status": "Oke","data": pengguna}

Tetapkan dua rute dapatkan yang mengambil semua data dalam koleksi dan mengambil data tertentu dari koleksi berdasarkan ID.

Perbarui Data Dengan Metode Put

Buat rute put untuk memperbarui data yang disimpan dalam database.

@pengguna.put("/{id}")
asinkrondefperbarui_pengguna(id: str, pengguna: Pengguna):
 koleksi.temukan_satu_dan_perbarui(
 {
"_pengenal": ObjectId (id)
 }, 
 {
"$set": dict (pengguna)
 })
 pengguna = users_serializer (collection.find({"_pengenal": ObjectId (id)}))
kembali {"status": "Oke","data": pengguna}

Metode put menggunakan ID untuk menemukan data spesifik dalam kumpulan dan memperbarui nilai bidang dalam dokumen dengan data baru yang diteruskan dari API. Anda kemudian dapat mencari data yang diperbarui berdasarkan ID dan mengembalikannya dalam respons API.

Hapus Data Dengan Metode Hapus

Buat rute hapus untuk menghapus data yang tersimpan di database.

@pengguna.hapus("/{id}")
asinkrondefHapus pengguna(id: str):
 koleksi.temukan_satu_dan_hapus({"_pengenal": ObjectId (id)})
 pengguna = users_serializer (collection.find())
kembali {"status": "Oke","data": []}

Rute hapus mengambil ID dari dokumen tertentu yang ingin Anda hapus dari koleksi.

Buat REST API Dengan FastAPI

FastAPI menyediakan cara yang bagus untuk membangun API web backend Python dengan nyaman. Alat bawaannya untuk integrasi basis data dan produksi API otomatis menjadikan prosesnya sederhana.

Anda bahkan dapat melangkah lebih jauh dan membangun aplikasi yang lengkap. Coba integrasikan klien front-end menggunakan teknologi populer seperti React, Angular, atau Vue.