Ini Dia Cara Menggunakan Django ORM Dengan FASTAPI

Pendahuluan

ORM yang merupakan kependekan dari object relational manager adalah cara untuk menggunakan database relasional melalui bahasa OOP, Anda dapat membuat tabel, menambah, memperbarui atau menghapus catatan tanpa harus menulis satu baris pun SQL, Anda dapat melakukan semuanya melalui perangkat lunak yang berfungsi sebagai jembatan antara kode SQL dan kode OOP. Anda dapat menganggapnya sebagai layer terpisah yang mengisolasi semua logika operasi basis data dan memaparkannya melalui API yang mudah dan intuitif. Salah satu orm yang paling populer adalah ORM Django, saya pribadi menyukainya karena kesederhanaan dan fleksibilitasnya, jika Anda berasal dari framework Django seperti saya, Anda mungkin akan memiliki perasaan yang sama, dan Anda juga akan tertarik untuk mengetahui caranya untuk menggunakannya dengan FAST API, khususnya Django 4 sekarang mendukung perilaku asinkron dengan ORM, saya tidak akan menggunakan fitur asinkron dalam artikel ini, tetapi silakan jelajahi sendiri. Tanpa basa-basi lagi, mari kita gali.

NB: Tutorial ini adalah bagian ketiga dari seri FastAPI yang sedang saya tulis, Anda mungkin perlu membaca bagian sebelumnya untuk dapat mengikuti yang ini, tetapi jika Anda memiliki latar belakang dengan FastAPI, Anda akan baik-baik saja. Anda dapat menemukan bagian pertama di sini dan bagian kedua di sini.

Project Preparation

Pertama, kita akan membuat folder root kita:

mkdir myproject

Kemudian kami memulai lingkungan kami seperti ini:

poetry init

Seperti biasa saya suka menggunakan poetry sebagai alat my dependency management, jangan ragu untuk menggunakan alat lain yang menurut Anda lebih baik. Berikutnya kita pasang django, karena django-orm adalah bagian dari sistem django:

poetry add django

Setelah django selesai menginstal, kami memulai proyek kami:

poetry run django-admin startproject myproject

Sekarang jika Anda memeriksa struktur proyek Anda, Anda akan melihat yang berikut:

Seperti yang Anda lihat, perintah ini membuat banyak file untuk kami:

manage.py : Ini adalah file yang dapat kita gunakan untuk berinteraksi dengan bagian Django manapun.
myproject : Folder ini adalah apa yang kita sebut aplikasi, yang ini biasanya digunakan untuk keperluan konfigurasi

Selanjutnya kami membuat aplikasi lain untuk memuat kode kami, kami akan menyebutnya todo:

poetry run django-admin startapp todo

Sekarang Anda akan menemukan folder baru ini dibuat, dan strukturnya seperti ini:

Sekarang mari kita instal fastApi:

poetry add “fastapi[all]”

Selanjutnya kita harus menambahkan dua aplikasi yang kita miliki ke pengaturan INSTALLED_APPS di settings.py untuk django untuk mengetahui bahwa itu harus melihat ke dalam aplikasi ini untuk model saat bermigrasi, ini juga berguna untuk hal-hal lain tetapi itulah yang penting bagi kita dalam tutorial ini , kami melakukannya seperti ini:

myproject/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myproject',
    'todo',
]

Kemudian kita membuat entrypoint aplikasi dengan menambahkan kode ini ke myproject/asgi.py:

"""
ASGI config for myproject project.

It exposes the ASGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/4.1/howto/deployment/asgi/
"""

import os

from django.core.asgi import get_asgi_application
from fastapi import FastAPI


os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")

application = get_asgi_application()

def get_application() -> FastAPI:
    app = FastAPI()
    return app


app = get_application()

Now try running the application:

poetry run uvicorn myproject.asgi:app — reload

Uji apakah server berfungsi dengan masuk ke localhost:8000/docs.

Application

Sekarang kita mulai menulis our logic code, menentukan model, menulis tampilan dan pengujian.

Mari terapkan aplikasi todo yang kami terapkan di artikel pertama seri ini, untuk mendemonstrasikan cara menggunakan django ORM dengan fastapi.

kami akan menerapkan 2 titik akhir:

tambahkan item rencana
membaca item

Model

Kami cuma memiliki satu model dalam tutorial sederhana ini, yaitu Item yang mewakili todos kami:

todo/models.py

from django.db import models


class Item(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)

    title = models.CharField(max_length=200)
    description = models.CharField(max_length=300)

Ini adalah definisi sederhana dari model django, saat kita menjalankan migrasi, ini akan membuat tabel di database kita dengan bidang yang sesuai dengan variabel yang kita definisikan di dalam kelas Item kita. Jika Anda tidak terbiasa dengan django orm, Anda dapat membacanya di dokumen mereka, sangat mudah untuk mempelajarinya.

Sekarang kami melakukan migrasi yang membuat banyak skrip yang nantinya ketika dijalankan, membuat atau memperbarui tabel di database kami, Anda dapat menemukan skrip yang dihasilkan di todo/migrasi:

poetry run python manage.py makemigrations

Kemudian kami menjalankan migrasi untuk mengeksekusi skrip yang dihasilkan pada langkah sebelumnya, ini akan membuat database karena ini adalah pertama kalinya kami menjalankan migrasi dan membuat satu-satunya pemetaan tabel yang ditentukan ke model Item:

poetry run python manage.py migrate

Skema

buat file baru todo/schemas.py di mana kita akan mendefinisikan skema kita. Kami akan memiliki dua skema, satu untuk menambahkan operasi item dan satu lagi untuk membaca operasi item.

todo/schemas.py

from pydantic import BaseModel
from datetime import datetime


class AddItem(BaseModel):
    title: str
    description: str


class ReadItem(BaseModel):
    id: int
    title: str
    description: str
    created_at: datetime

Perbedaan antara kedua skema, adalah bidang create_at dihasilkan secara otomatis, jadi kami tidak ingin pengguna mengirimkannya saat membuat item baru, namun kami ingin mengembalikannya saat seseorang meminta item tersebut.

API

Akhirnya kami membuat operasi API, kami menulisnya di file todo/views.py, jika Anda mau, Anda dapat mengganti namanya menjadi api.py, untuk saya, saya akan membiarkannya apa adanya.

Tambahkan titik akhir item

todo/views.py

from fastapi import APIRouter

from todo.models import Item
from todo.schemas import AddItem, ReadItem

router = APIRouter()


@router.post("/items", response_model=ReadItem)
def add_item(item: AddItem):
    item_obj = Item.objects.create(**item.dict())
    return ReadItem(**item_obj.__dict__)

Kami membuat router untuk menyertakan semua titik akhir kami di bagian atas file. Tampilan add_item cukup sederhana, fungsinya mengambil badan permintaan sebagai parameter, memvalidasinya menggunakan AddItem model pydantic, lalu kita membuat item menggunakan data tervalidasi yang disimpan dalam variabel item. Akhirnya kami mengembalikan item itu, tetapi hanya bidang yang kami ingin pengguna lihat, kami membatasi bidang yang dikembalikan menggunakan ReadItem model pydantic.

Sintaks .__dict__, hanyalah variabel yang menyimpan dict yang berisi semua variabel dalam objek model. Kami menggunakannya untuk meneruskan objek sebagai dict, yang diterima oleh model pydantic untuk memvalidasi data apa pun.

Baca titik akhir item

todo/views.py

from fastapi import APIRouter, HTTPException

from todo.models import Item
from todo.schemas import AddItem, ReadItem

router = APIRouter()


@router.post("/items", response_model=ReadItem)
def add_item(item: AddItem):
    item_obj = Item.objects.create(**item.dict())
    return ReadItem(**item_obj.__dict__)


@router.get("/items/{item_id}", response_model=ReadItem)
def read_item(item_id: int):
    try:
        item = Item.objects.get(pk=item_id)
    except Item.DoesNotExist:
        raise HTTPException(status_code=404, detail="Item with such id does not exist")
    return ReadItem(**item.__dict__)

Titik akhir ini mendapatkan item berdasarkan id, dibutuhkan id item sebagai parameter jalur. Ini mengembalikan kesalahan 404 Tidak Ditemukan ketika id yang tidak ada diminta dari titik akhir. Jika tidak, item akan dikembalikan secara normal menggunakan model pydantic yang sama seperti yang kita gunakan di titik akhir sebelumnya.

Anda dapat menunjukkan parameter jalur dengan menambahkan nama parameter di jalur antara kurung kurawal, lalu menambahkannya di tanda tangan fungsi sebagai parameter, dengan cara ini FastAPI akan memahami bahwa ini adalah parameter jalur dan akan mengekstrak nilainya dari url ke parameter fungsi. Anda dapat membaca lebih lanjut tentang parameter jalur di sini.

Include Routers

Hingga saat ini, FastAPI tidak mengetahui apa pun tentang titik akhir atau router yang kami tentukan. Jika Anda pergi ke localhost:8000/docs Anda akan menemukannya kosong. Untuk mengubahnya, kita harus menyertakan router ke aplikasi FastAPI kita.

Ketika aplikasi FastAPI menangani permintaan baru, itu memeriksa url yang diminta, jika aplikasi tidak secara langsung tahu tentang url itu, itu mulai menanyakan setiap router yang termasuk dalam aplikasi, apakah itu memiliki titik akhir yang termasuk di dalamnya, ketika menemukan titik akhir itu memungkinkannya menangani permintaan. Untuk membaca lebih lanjut tentang APIRouter, periksa dokumen di sini.

proyek saya/asgi.py

"""
ASGI config for myproject project.

It exposes the ASGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/4.1/howto/deployment/asgi/
"""

import os

from django.core.asgi import get_asgi_application
from fastapi import FastAPI


os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")


application = get_asgi_application()

from todo.views import router


def get_application() -> FastAPI:
    app = FastAPI()
    app.include_router(router)

    return app


app = get_application()

Seperti yang Anda lihat, kami menambahkan baris app.include_router(router) dan impor router. Sebelum Anda bertanya, ya impor ditempatkan di tempat yang seharusnya, karena aplikasi django asgi harus dimuat sebelum mengimpor apa pun dari aplikasi django mana pun.

Tes

Sekarang jika Anda menjalankan aplikasi dan membuka localhost:8000/docs, Anda akan menemukan titik akhir yang ditentukan didokumentasikan di sana, dan Anda dapat mencobanya menggunakan dokumentasi interaktif. Dan voila, kami mengintegrasikan ORM Django dengan FastAPI.

Jika Anda ingin mempelajari lebih lanjut tentang ORM Django, dan cara menulis model yang lebih kompleks daripada yang kami buat di sini, jangan ragu untuk memeriksa dokumentasi mereka, ini adalah dokumentasi yang sangat kaya, sepadan dengan waktu Anda.

Anda juga harus memeriksa dokumentasi FastAPI untuk info lebih lanjut tentang konsep yang kami gunakan dalam kode tutorial ini, kami tidak menjelaskan secara detail sebagian besar kode di sini, karena ini bukan fokus dari tutorial ini.

Saya harap Anda menikmati mengikuti tutorial ini seperti saya menikmati menulisnya, jika Anda memiliki pertanyaan atau catatan, jangan ragu untuk menghubungi saya di salah satu akun media sosial saya atau di bagian komentar di bawah dan saya akan menghubungi Anda kembali. secepat mungkin,

Kesimpulan

Kami mengintegrasikan ORM Django dengan FastAPI, kami mempelajari cara menggunakan model django dengan operasi FastAPI, dan juga bagaimana dan di mana menyertakan pembuatan aplikasi FastAPI dalam struktur berkas tipikal Django.