FastAPI adalah kerangka kerja web modern dan berkinerja tinggi untuk membangun API dengan Python 3.7+ berdasarkan petunjuk tipe Python standar. Ia menawarkan beberapa keuntungan:
- Kinerja Tinggi: FastAPI dirancang untuk kecepatan, memanfaatkan pemrograman asinkron untuk menangani ribuan permintaan per detik.
- Dokumentasi Otomatis: Ia secara otomatis menghasilkan dokumentasi API interaktif menggunakan Swagger UI dan ReDoc.
- Pemeriksaan Tipe: FastAPI menggunakan petunjuk tipe Python untuk menyediakan validasi dan serialisasi data otomatis.
Berikut adalah cara membuat aplikasi FastAPI:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
FastAPI dalam Tumpukan Web
Bayangkan menavigasi lanskap web yang ramai dengan FastAPI sebagai panduan tepercaya Anda. Diagram ikhtisar kami (gambar 1) menyajikan tampilan yang jelas dan menarik tentang bagaimana FastAPI terintegrasi dengan mulus ke dalam tumpukan web.
Di bagian atas, Anda memiliki permintaan klien — ini adalah interaksi sehari-hari dari pengguna yang ingin mengakses aplikasi Anda. FastAPI berperan sebagai jembatan dinamis antara permintaan ini dan server Anda. Ia dirancang untuk menangani data masuk dengan cepat dan efisien, memastikan bahwa setiap interaksi berjalan lancar dan responsif.
Di bawah aplikasi FastAPI, Anda akan menemukan proses yang efisien di mana keajaiban terjadi. FastAPI dikenal karena kecepatan dan kinerjanya, memproses permintaan dengan kecepatan dan akurasi kilat. Ini seperti memiliki asisten tingkat atas yang tidak hanya memahami kebutuhan Anda tetapi juga mengantisipasinya, memberikan respons dalam waktu singkat.
Akhirnya, gambar 1 menunjukkan bagaimana respons kembali ke klien. FastAPI memastikan bahwa respons ini tidak hanya cepat tetapi juga sangat andal, meningkatkan pengalaman pengguna secara keseluruhan.
Jadi, jika Anda mencari solusi yang kuat, efisien, dan mudah digunakan untuk meningkatkan aplikasi web Anda, FastAPI adalah pilihan utama Anda. Selami diagram dan lihat bagaimana FastAPI dapat mengubah tumpukan web Anda dengan kemampuan luar biasanya.
Ikhtisar Pemanggilan Endpoint
Pemanggilan endpoint mengacu pada proses pengiriman permintaan ke endpoint API tertentu untuk menjalankan tindakan yang ditentukan. Dalam FastAPI, ini melibatkan pendefinisian rute dan penanganan permintaan masuk.
Membuat Endpoint:
Dalam FastAPI, Anda mendefinisikan endpoint menggunakan dekorator. Setiap dekorator sesuai dengan metode HTTP dan jalur URL.
Begini cara kerjanya: from fastapi import FastAPI
from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
Pengaturan ini memungkinkan pengguna untuk meminta item tertentu berdasarkan ID mereka, dan aplikasi Anda dengan cepat memberikan informasi yang mereka cari dalam format JSON yang rapi;
- @app.get(“/items/{item_id}”) mendefinisikan endpoint GET di mana item_id adalah parameter jalur.
- Fungsi read_item menangani permintaan dan mengembalikan respons JSON.
Bayangkan ini: sebuah permintaan melakukan perjalanan melalui aplikasi Anda, dan diagram endpoint kami (gambar 2) seperti peta yang menunjukkan petualangannya.
Pertama, sebuah permintaan menuju ke endpoint, di mana ia disambut dan memulai perjalanannya. Bayangkan ini sebagai gerbang selamat datang tempat permintaan disiapkan dan siap. Selanjutnya, kita menyelami parameter. Ini seperti instruksi atau detail khusus yang memandu permintaan dalam perjalanannya, memastikan ia sampai tepat ke tempat yang seharusnya.
Setelah permintaan memiliki semua detail yang diurutkan, ia memenuhi tahap penanganan permintaan. Anggap ini sebagai inti dari tindakan, di mana permintaan diproses, dan semua operasi yang diperlukan dilakukan untuk mendapatkan hasil yang benar.
Akhirnya, permintaan mencapai akhir perjalanannya dengan respons. Ini seperti tujuan akhir di mana hasil permintaan dikemas dengan rapi dan dikirim kembali ke tempat semuanya dimulai.
Jadi, gambar 2 bukan hanya diagram alur — ini adalah kisah visual tentang bagaimana setiap permintaan melakukan perjalanan melalui sistem Anda, mendapatkan perlakuan yang tepat dan kembali dengan respons yang sempurna.
Pentingnya Pencatatan Log dalam API
Pencatatan log sangat penting untuk memantau, men-debug, dan memelihara API. Ini membantu pengembang:
- Melacak Permintaan dan Respons: Memahami bagaimana API digunakan dan memecahkan masalah.
- Memantau Kinerja: Mengidentifikasi hambatan kinerja dan mengoptimalkan API.
- Audit dan Keamanan: Menyimpan catatan penggunaan API untuk audit kepatuhan dan keamanan.
Begini cara kerjanya:
Anda dapat menggunakan modul pencatatan log bawaan Python untuk menambahkan pencatatan log ke aplikasi FastAPI Anda:
import logging
from fastapi import FastAPI
app = FastAPI()
# Configure logging
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
logger.info(f"Received request for item_id: {item_id} with query: {q}")
return {"item_id": item_id, "q": q}
Mari selami bagaimana pencatatan log bekerja dengan pengaturan ini.
Pertama, logging.basicConfig seperti menyiapkan aturan tentang bagaimana Anda ingin menangani log Anda. Di sinilah Anda memutuskan hal-hal seperti ke mana log Anda pergi dan bagaimana mereka harus diformat. Anggap ini sebagai menyiapkan toolkit pencatatan log Anda sehingga semuanya ada di tempatnya untuk menangkap informasi penting.
Selanjutnya, kita memiliki logger.info. Di sinilah keajaiban terjadi. Ketika Anda memanggil logger.info, Anda menambahkan pesan informasi ke log Anda. Dalam hal ini, ini semua tentang mencatat detail tentang permintaan. Ini seperti mencatat apa yang terjadi, sehingga Anda memiliki catatan untuk referensi di masa mendatang.
Sekarang, ke Diagram alur pencatatan log (gambar 3). Diagram ini seperti panduan visual yang menunjukkan bagaimana permintaan dicatat dari awal hingga akhir. Ini memetakan perjalanan, dari menyiapkan konfigurasi pencatatan log Anda hingga menangkap dan merekam pesan. Ini adalah cara yang berguna untuk melihat bagaimana semua bagian bersatu untuk melacak aktivitas aplikasi Anda.
Menyiapkan FastAPI untuk Endpoint Versi 2
Selamat datang di dunia FastAPI! Jika Anda ingin memanfaatkan kekuatan salah satu kerangka kerja tercepat untuk membangun API dengan Python, Anda berada di tempat yang tepat. Apakah Anda meningkatkan API yang ada ke versi 2 atau memulai dari awal, panduan ini akan memandu Anda melalui semua yang Anda butuhkan untuk memulai. Mulai dari menginstal FastAPI dan Uvicorn hingga menyiapkan struktur proyek Anda dan membuat aplikasi dasar, kami siap membantu Anda. Mari selami!
1. Menginstal FastAPI dan Uvicorn
Mengapa FastAPI? FastAPI terkenal karena kecepatan, kesederhanaan, dan fitur modernnya. Ini sempurna untuk membangun API yang cepat dan mudah dipelihara.
Mengapa Uvicorn? Uvicorn adalah server ASGI berkinerja tinggi yang ideal untuk menjalankan aplikasi FastAPI. Ia mendukung operasi asinkron, menjadikannya pilihan yang bagus untuk aplikasi yang dapat diskalakan.
Memulai:
Untuk menginstal FastAPI dan Uvicorn, cukup jalankan:pip install fastapi uvicorn
Fitur yang Perlu Disorot:
- FastAPI: Memungkinkan dokumentasi interaktif otomatis, validasi, dan dukungan asinkron.
- Uvicorn: Bertindak sebagai server ASGI berkecepatan tinggi, sempurna untuk lingkungan pengembangan dan produksi.
Bayangkan Anda sedang menyiapkan lingkungan pengembangan Anda, dan Anda ingin melihat bagaimana semuanya cocok. Diagram Alur Instalasi (gambar 4) seperti peta yang menunjukkan dengan tepat bagaimana FastAPI dan Uvicorn bersatu untuk membuat aplikasi web Anda berjalan dengan lancar.
Anggap FastAPI sebagai kerangka kerja API yang kuat yang menangani semua keajaiban di balik permintaan dan respons aplikasi Anda. Ini seperti otak aplikasi Anda, memproses data dan mengelola interaksi.
Sekarang, Uvicorn adalah server yang menghidupkan FastAPI. Ini adalah mesin yang andal yang berjalan di belakang layar, memastikan FastAPI menangani permintaan masuk dan memberikan respons secara efisien.
Diagram ini membantu Anda memvisualisasikan bagaimana FastAPI dan Uvicorn berinteraksi dalam pengaturan pengembangan Anda. Ini menunjukkan hubungan antara mereka dan bagaimana mereka cocok dengan gambaran yang lebih besar dari server dan kerangka kerja aplikasi Anda. Ini adalah cara yang berguna untuk memahami alur dan melihat bagaimana setiap bagian berkontribusi pada keseluruhan.
2. Struktur Proyek dan Dependensi
Mengapa Mengatur Proyek Anda? Proyek yang terstruktur dengan baik tidak hanya membantu dalam memelihara dan menskalakan aplikasi Anda tetapi juga memastikan bahwa kolaborasi dengan orang lain berjalan lancar dan efisien.
Cara Menyiapkan:
1. Buat Direktori Proyek: Atur file proyek Anda ke dalam direktori.
2. Tentukan Dependensi: Gunakan requirements.txt untuk mencantumkan semua paket, sehingga mudah untuk menginstalnya dengan:pip install -r requirements.txt
Anggap Diagram Struktur Proyek (gambar 5) sebagai cetak biru untuk basis kode Anda. Ini seperti peta terperinci yang menunjukkan bagaimana semuanya diatur dalam proyek Anda.
Bayangkan Anda sedang menyiapkan proyek baru dan Anda perlu mencari tahu di mana menempatkan berbagai bagian seperti endpoint, model, dan skema. Diagram ini memudahkan untuk melihat ke mana setiap bagian harus pergi.
Ini seperti memiliki lemari arsip yang terorganisir dengan baik di mana Anda tahu persis laci mana yang harus dibuka untuk endpoint API Anda, di mana menyimpan model data Anda, dan di mana menyimpan skema Anda. Dengan memvisualisasikan struktur, Anda dapat dengan cepat memahami bagaimana semua komponen cocok dan menjaga proyek Anda tetap rapi dan mudah dikelola.
• app/main.py: Jantung dari aplikasi FastAPI Anda.
• app/api/v2/endpoints.py: Tempat Anda akan mendefinisikan endpoint versi 2 Anda.
• requirements.txt: File yang mencantumkan semua dependensi untuk proyek Anda.
3. Membuat Aplikasi FastAPI Dasar
Mengapa Memulai dengan Sederhana? Aplikasi sederhana dan fungsional menetapkan panggung untuk menambahkan fitur yang lebih kompleks. Ini memastikan Anda memahami komponen inti FastAPI sebelum menyelam lebih dalam.
Cara Kerja Aplikasi Dasar:
# app/main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Welcome to FastAPI!"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "query": q}
Menjalankan Aplikasi Anda:
Untuk melihat aplikasi FastAPI Anda beraksi, jalankan:
uvicorn app.main:app --reload
Kunjungi http://127.0.0.1:8000 di browser Anda, dan Anda akan melihat API Anda beraksi. Jangan lupa untuk memeriksa dokumentasi API interaktif di:
Fitur yang Perlu Disorot:
• Dokumentasi Interaktif: Dihasilkan secara otomatis dan dapat diakses melalui /docs dan /redoc.
• Dukungan Asinkron: FastAPI memungkinkan konkurensi tinggi dengan operasi asinkron.
Bayangkan Anda sedang melacak permintaan saat melakukan perjalanan melalui aplikasi FastAPI Anda. Diagram Alur Aplikasi Dasar yang diilustrasikan dalam gambar 6 seperti panduan langkah demi langkah yang menunjukkan perjalanan ini beraksi.
Begini cara kerjanya: sebuah permintaan masuk, dan diagram menunjukkan dengan tepat bagaimana ia diproses. Pertama, aplikasi FastAPI Anda menerima permintaan — anggap ini sebagai titik awal di mana aplikasi Anda menyambut data yang masuk.
Selanjutnya, diagram menguraikan perjalanan permintaan ini saat ditangani. Ini mencakup pemrosesan, interaksi dengan database, atau operasi lain yang dilakukan aplikasi Anda.
Akhirnya, ia menunjukkan bagaimana aplikasi membungkus semuanya dan mengirim respons kembali. Ini seperti melacak paket dari saat tiba di gudang hingga saat dikirimkan ke pelanggan.
Menyiapkan FastAPI untuk endpoint versi 2 sangat mudah dan pasti sepadan. Dengan fitur-fitur canggih FastAPI dan kecepatan Uvicorn, Anda akan membangun API yang efisien dan dapat diskalakan dalam waktu singkat.
Meningkatkan Pencatatan Log dengan Endpoint Versi 2
Dalam hal membangun aplikasi web yang kuat dan dapat diskalakan, pencatatan log bukan hanya fitur; ini adalah komponen penting yang membantu dalam memantau, men-debug, dan memelihara kesehatan aplikasi. Dengan FastAPI, Anda dapat memanfaatkan kemampuan pencatatan log tingkat lanjut untuk memastikan bahwa aplikasi Anda berjalan dengan lancar dan masalah ditangani dengan segera. Dalam panduan ini, kami akan memandu Anda melalui peningkatan pengaturan pencatatan log Anda dengan FastAPI, dengan fokus pada endpoint Versi 2. Mari selami!
Pengantar Fitur Pencatatan Log FastAPI
FastAPI menawarkan dukungan bawaan untuk pencatatan log, yang penting untuk melacak perilaku aplikasi dan mendiagnosis masalah. Pencatatan log menyediakan cara untuk merekam peristiwa, kesalahan, dan kejadian signifikan lainnya dalam aplikasi Anda. Fungsionalitas ini sangat penting untuk memahami kinerja aplikasi dan interaksi pengguna.
Mengapa Pencatatan Log Penting:
• Debugging: Dengan cepat mengidentifikasi dan menyelesaikan masalah dalam kode Anda.
• Pemantauan: Melacak kesehatan dan kinerja aplikasi.
• Audit: Merekam tindakan pengguna dan perubahan sistem untuk keamanan dan kepatuhan.
FastAPI terintegrasi dengan mulus dengan pustaka pencatatan log standar Python, memungkinkan konfigurasi pencatatan log yang fleksibel dan kuat.
Berikut adalah tampilan singkat tentang bagaimana pencatatan log cocok dengan FastAPI:
- Kotak FastAPI: "Aplikasi FastAPI" pusat disorot dengan warna biru, menunjukkannya sebagai jantung dari pengaturan Anda.
- Tingkat Pencatatan Log: INFO (hijau), DEBUG (oranye), dan ERROR (merah) adalah tingkat pencatatan log yang berbeda, masing-masing terhubung ke FastAPI dengan panah.
- Sistem Pencatatan Log Python: Ini berwarna emas di sebelah kanan, menunjukkan bahwa ia menangani semua pesan log dari FastAPI.
Gambar 7 membantu Anda melihat bagaimana FastAPI bekerja dengan pustaka pencatatan log Python, mengilustrasikan bagaimana tingkat log yang berbeda berinteraksi dengan aplikasi Anda.
Menyiapkan Konfigurasi Pencatatan Log
Mengonfigurasi pencatatan log di FastAPI melibatkan pengaturan konfigurasi pencatatan log yang sesuai dengan kebutuhan Anda. Anda dapat menentukan tingkat pencatatan log, memformat pesan, dan menentukan di mana log harus dikeluarkan (konsol, file, dll.).
Langkah-langkah untuk Mengonfigurasi Pencatatan Log:
- Impor Modul Pencatatan Log: Gunakan modul
loggingPython untuk menyiapkan konfigurasi Anda. - Tentukan Konfigurasi Pencatatan Log: Atur tingkat pencatatan log, format, dan handler.
- Inisialisasi Pencatatan Log di FastAPI: Terapkan konfigurasi ke aplikasi FastAPI Anda.
Berikut adalah pengaturan dasar untuk pencatatan log di FastAPI:
import logging
from fastapi import FastAPI
# Configure logging
logging.basicConfig(level=logging.INFO, # Adjust the level as needed
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[logging.StreamHandler()]) # Logs to console
app = FastAPI()
@app.get("/")
def read_root():
logging.info("Root endpoint accessed")
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int):
logging.debug(f"Item requested: {item_id}")
if item_id > 10:
logging.error("Item ID is too high")
return {"item_id": item_id}
Fitur yang Perlu Disorot:
• Tingkat Pencatatan Log: INFO, DEBUG, ERROR — gunakan tingkat yang berbeda untuk mengontrol verbositas log.
• Handler Kustom: Mengarahkan log ke file, server jarak jauh, atau tujuan lain.
• Pemformatan Pesan: Menyesuaikan format pesan log untuk menyertakan stempel waktu, tingkat log, dll.
Berikut adalah ikhtisar singkat tentang bagaimana pencatatan log diatur:
- Konfigurasi Pencatatan Log: Di bagian atas, kotak emas menunjukkan di mana pengaturan pencatatan log terjadi.
- Komponen Aplikasi: Tiga kotak biru mewakili bagian yang berbeda dari aplikasi Anda tempat log dihasilkan.
- Logger: Kotak hijau mengumpulkan log ini dan mengarahkannya ke tempat yang seharusnya.
- Handler: Dua kotak oranye-merah menunjukkan File dan Console Handler yang memproses dan memformat log.
- Tujuan: Kotak ungu di sebelah kanan menunjukkan di mana log berakhir, seperti file log atau konsol.
Diagram alur yang diilustrasikan dalam gambar 8 ini memudahkan untuk melihat bagaimana pesan log melakukan perjalanan dari aplikasi Anda ke tujuan akhir mereka.
Menerapkan Endpoint Versi 2 untuk Pencatatan Log
Dengan FastAPI, endpoint Versi 2 menawarkan kemampuan yang ditingkatkan untuk pencatatan log. Anda dapat membangun di atas pencatatan log standar FastAPI untuk menerapkan strategi pencatatan log yang lebih canggih untuk endpoint Anda.
Pertimbangan Utama:
• Pencatatan Log Terstruktur: Gunakan log terstruktur untuk menangkap informasi terperinci dan dapat ditindaklanjuti.
• Penanganan Kesalahan yang Ditingkatkan: Catat informasi kesalahan terperinci untuk mendiagnosis masalah secara efektif.
• Metrik Kinerja: Lacak metrik kinerja seperti durasi permintaan dan throughput.
Berikut adalah cara Anda dapat menerapkan pencatatan log di endpoint Versi 2:
from fastapi import FastAPI, Request
import logging
app = FastAPI()
# Enhanced logging configuration
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[logging.FileHandler("app.log"), logging.StreamHandler()])
@app.post("/log")
async def log_endpoint(request: Request):
body = await request.json()
logging.info(f"Received request with body: {body}")
return {"status": "logged"}
@app.get("/performance")
def performance_metrics():
# Example of logging performance metrics
start_time = logging.datetime.now()
# Simulate processing
logging.info(f"Performance metrics requested at {start_time}")
return {"metrics": "sample_metrics"}
Fitur yang Perlu Disorot:
• Pencatatan Log Asinkron: Menangani log secara asinkron untuk kinerja yang lebih baik.
• Pencatatan Log File: Menyimpan log ke file untuk penyimpanan persisten.
• Pencatatan Log Kinerja: Menangkap dan menganalisis metrik kinerja.
Berikut adalah ikhtisar sederhana tentang bagaimana pencatatan log bekerja dengan permintaan Anda:
1.Kotak Permintaan: Kotak biru muda ini adalah tempat permintaan masuk dimulai.
2.Jenis Log:
• Log INFO berwarna hijau.
• Log ERROR berwarna merah.
• Log DEBUG berwarna emas.
3.Handler: Log berpindah ke:
• File Handler (biru).
• Console Handler (juga biru).
4.Tujuan: Log berakhir di:
File Log atau Konsol (ungu).
Gambar 9 menunjukkan bagaimana permintaan mengarah ke berbagai jenis log, yang kemudian ditangani dan diarahkan ke tujuan akhir mereka. Menyiapkan ini dengan benar memastikan Anda mendapatkan wawasan yang jelas dan dapat menjaga aplikasi FastAPI Anda berjalan dengan lancar.
Fitur Pencatatan Log Tingkat Lanjut dan Praktik Terbaik
Dalam aplikasi FastAPI apa pun, pencatatan log lebih dari sekadar merekam pesan di konsol. Ini tentang membangun sistem yang kuat yang membantu Anda melacak masalah, memantau kinerja, dan mengelola kesalahan secara efektif. Dengan memanfaatkan fitur pencatatan log tingkat lanjut dan praktik terbaik, Anda dapat mengubah log Anda menjadi alat yang berharga untuk memelihara dan menskalakan aplikasi Anda.
Mari kita jelajahi beberapa fitur pencatatan log yang lebih canggih di FastAPI, dengan fokus pada injeksi dependensi untuk pencatatan log, menyesuaikan pesan log, dan praktik terbaik untuk menangani pengecualian dan kesalahan.
Menggunakan Injeksi Dependensi untuk Pencatatan Log
Injeksi dependensi di FastAPI adalah fitur yang sangat kuat, dan itu meluas ke pencatatan log juga. Alih-alih mengonfigurasi pencatatan log secara terpisah di setiap fungsi, Anda dapat menyuntikkannya ke dalam rute Anda, membuat kode Anda lebih bersih dan lebih dapat diskalakan.
Mengapa Menggunakan Injeksi Dependensi untuk Pencatatan Log?
• Konsistensi: Memastikan konfigurasi pencatatan log yang konsisten di semua endpoint.
• Dapat Digunakan Kembali: Memungkinkan Anda untuk menentukan dan menggunakan konfigurasi pencatatan log secara terpusat, menghindari kode yang berlebihan.
• Fleksibilitas: Memudahkan untuk memodifikasi pengaturan pencatatan log Anda tanpa mengubah kode endpoint individual.
Berikut adalah cara Anda dapat menyuntikkan instance pencatatan log menggunakan fungsi Depends FastAPI:
import logging
from fastapi import FastAPI, Depends
app = FastAPI()
# Logging configuration
def get_logger():
logger = logging.getLogger("app_logger")
logger.setLevel(logging.INFO)
if not logger.handlers:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
logger.addHandler(handler)
return logger
@app.get("/items/")
def read_items(logger=Depends(get_logger)):
logger.info("Items endpoint accessed")
return {"message": "Fetching items"}
Fitur yang Perlu Disorot:
• Konfigurasi Logger Terpusat: Dengan injeksi dependensi, Anda hanya mendefinisikan logger Anda sekali.
• Injeksi Otomatis: FastAPI secara otomatis menyediakan logger ke endpoint mana pun yang membutuhkannya.
Gambar 10 mengilustrasikan Alur Injeksi Dependensi yang menunjukkan bagaimana permintaan berubah menjadi log, bagaimana mereka ditangani, dan di mana mereka berakhir. Ini semua tentang menjaga aplikasi FastAPI Anda berjalan dengan lancar dengan pencatatan log yang jelas.
Aspek Utama dari diagram alur injeksi dependensi:
• Permintaan Klien: Titik awal di mana klien mengirim permintaan ke aplikasi FastAPI.
• Endpoint FastAPI: Mewakili endpoint di FastAPI tempat injeksi dependensi terjadi.
• Logger Disuntikkan melalui DI: Menunjukkan bahwa logger disuntikkan ke dalam endpoint menggunakan mekanisme injeksi dependensi FastAPI.
• Pencatatan Log (Info Permintaan): Mencatat detail permintaan, seperti metode, jalur, dan informasi berguna lainnya.
• Respons FastAPI: Respons yang dikembalikan ke klien setelah mencatat permintaan.
Menyesuaikan Pesan Log
Kemampuan untuk menyesuaikan pesan log sangat penting untuk membuat log Anda informatif dan dapat ditindaklanjuti. Log default mungkin tidak selalu memberikan konteks yang cukup, terutama di lingkungan produksi. Integrasi FastAPI dengan modul pencatatan log Python memudahkan untuk menambahkan detail khusus ke log Anda.
Strategi Utama untuk Menyesuaikan Pesan Log:
• Tambahkan Informasi Permintaan: Sertakan detail permintaan seperti alamat IP, header, dan jalur.
• Tambahkan Informasi Kontekstual: Sesuaikan log untuk menyertakan informasi yang relevan dengan endpoint atau operasi saat ini, seperti tindakan pengguna atau detail sumber daya tertentu.
• Format untuk Keterbacaan: Gunakan log terstruktur atau format JSON untuk keterbacaan yang lebih baik dan integrasi yang lebih mudah dengan alat pencatatan log seperti tumpukan ELK.
Berikut adalah cara menyesuaikan pesan log dengan detail permintaan:
from fastapi import Request
@app.middleware("http")
async def log_requests(request: Request, call_next):
logger = logging.getLogger("custom_logger")
logger.info(f"Incoming request: {request.method} {request.url}")
response = await call_next(request)
logger.info(f"Response status: {response.status_code}")
return response
Fitur yang Perlu Disorot:
• Middleware untuk Pencatatan Log: Middleware ini mencatat baik permintaan masuk maupun respons keluar.
• Informasi Kustom: Anda dapat mencatat detail spesifik seperti metode permintaan, URL, dan status respons.
Bayangkan Alur Log yang Disesuaikan yang diilustrasikan dalam gambar 11 ini sebagai panduan untuk melacak permintaan melalui sistem Anda. Ini dimulai dengan permintaan yang bergerak melalui middleware, di mana ia dicatat dengan detail khusus. Kemudian, saat proses berlanjut, respons juga dicatat. Bagan ini menyoroti tempat-tempat utama di mana pesan log khusus tersebut ditambahkan, memberi Anda tampilan yang jelas tentang bagaimana semuanya dilacak dan direkam.
Menangani Pengecualian dan Kesalahan
Ketika kesalahan terjadi dalam aplikasi Anda, pencatatan log memainkan peran penting dalam melacak penyebab utama. Fitur penanganan pengecualian FastAPI, dikombinasikan dengan pencatatan log, memastikan bahwa Anda menangkap dan mencatat informasi terperinci tentang kesalahan tanpa mengekspos detail sensitif kepada pengguna.
Praktik Terbaik untuk Mencatat Pengecualian:
• Catat Informasi Kesalahan Terperinci: Tangkap jejak tumpukan, pesan kesalahan, dan konteks permintaan.
• Catat Tingkat Kesalahan yang Berbeda: Gunakan tingkat pencatatan log yang sesuai seperti ERROR atau CRITICAL untuk pengecualian untuk membedakannya dari entri log reguler.
• Hindari Pencatatan Log yang Berlebihan: Berhati-hatilah dalam mencatat informasi sensitif atau terlalu banyak detail yang dapat mengacaukan log Anda.
Berikut adalah cara menangani dan mencatat pengecualian di FastAPI:
from fastapi import HTTPException
import logging
@app.get("/items/{item_id}")
def read_item(item_id: int, logger=Depends(get_logger)):
try:
if item_id > 100:
raise HTTPException(status_code=404, detail="Item not found")
logger.info(f"Item {item_id} fetched successfully")
return {"item_id": item_id}
except HTTPException as e:
logger.error(f"Error fetching item {item_id}: {e.detail}")
raise e
Fitur yang Perlu Disorot:
• Pencatatan Log Pengecualian Terstruktur: Catat informasi terperinci saat pengecualian terjadi, termasuk ID item dan detail kesalahan.
• Penanganan Kesalahan yang Anggun: Munculkan pengecualian HTTP sambil mencatat masalah untuk analisis lebih lanjut.
