Baik Anda seorang pengembang berpengalaman atau baru memulai, memastikan bahwa API Anda aman adalah hal yang sangat penting. FastAPI, sebuah kerangka kerja web modern, cepat (berkinerja tinggi), untuk membangun API dengan Python 3.7+, menawarkan solusi yang sangat baik. Hari ini, kita akan menyelami seluk beluk autentikasi FastAPI, menjelajahi cara mengimplementasikannya, dan mengapa ini menjadi pengubah permainan untuk proyek Anda. Selain itu, kita akan membahas bagaimana alat seperti Apidog dapat membuat hidup Anda lebih mudah.
Mengapa FastAPI untuk API Anda?
Sebelum kita membahas detail autentikasi, mari kita bicara tentang mengapa Anda mungkin memilih FastAPI sejak awal. FastAPI dirancang agar cepat dan sederhana, memungkinkan Anda membangun dan menerapkan API berkinerja tinggi dengan cepat. Ini dibangun di atas Starlette untuk bagian web dan Pydantic untuk bagian data, yang berarti Anda mendapatkan kecepatan dan keandalan.

Manfaat Utama FastAPI
- Kinerja: FastAPI adalah salah satu kerangka kerja Python tercepat yang tersedia.
- Kemudahan Penggunaan: Sintaksnya intuitif dan lugas, membuatnya dapat diakses bahkan untuk pemula.
- Dokumentasi API Interaktif Otomatis: FastAPI secara otomatis menghasilkan dokumentasi API interaktif dengan Swagger UI dan ReDoc.
- Keamanan Tipe: Memanfaatkan petunjuk tipe Python, FastAPI memastikan kode yang kuat dan bebas kesalahan.
Pentingnya Autentikasi
Saat membangun API, mengamankannya dengan mekanisme autentikasi sangat penting untuk melindungi data sensitif dan memastikan bahwa hanya pengguna yang berwenang yang dapat mengakses titik akhir tertentu. Autentikasi membantu memverifikasi identitas pengguna atau sistem yang berinteraksi dengan API Anda, memberikan lapisan keamanan dan kepercayaan.
Jenis Autentikasi
FastAPI mendukung beberapa jenis autentikasi, termasuk:
- Autentikasi Dasar: Metode langsung menggunakan nama pengguna dan kata sandi.
- OAuth2: Metode yang lebih aman dan fleksibel, sering digunakan untuk autentikasi pihak ketiga.
- JWT (JSON Web Tokens): Cara ringkas dan mandiri untuk mengirimkan informasi secara aman.
Menyiapkan Autentikasi FastAPI
Sekarang, mari kita masuk ke inti masalah—menyiapkan autentikasi di FastAPI. Kita akan membahas implementasi dasar OAuth2 dengan Kata Sandi (dan hashing), salah satu cara paling umum dan aman untuk menangani autentikasi.
Langkah 1: Instal FastAPI dan Dependensi
Pertama, pastikan Anda telah menginstal FastAPI dan dependensi yang diperlukan. Anda dapat melakukan ini menggunakan pip:
pip install fastapi[all] uvicorn
[all]
menginstal semua dependensi yang diperlukan untuk autentikasi, termasuk pydantic
dan python-jose
untuk JWT.
Langkah 2: Buat Aplikasi FastAPI Dasar
Mari kita mulai dengan aplikasi FastAPI sederhana. Buat file bernama main.py
:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Anda dapat menjalankan aplikasi ini menggunakan Uvicorn:
uvicorn main:app --reload
Langkah 3: Mengimplementasikan OAuth2 dengan Kata Sandi
OAuth2 adalah kerangka kerja otorisasi yang banyak digunakan yang menyediakan alur otorisasi khusus untuk berbagai jenis aplikasi. Kita akan menggunakan OAuth2 dengan Kata Sandi (dan hashing) untuk mengelola autentikasi.
Membuat Model Pengguna
Pertama, definisikan model pengguna Anda. Buat file bernama models.py
:
from pydantic import BaseModel
class User(BaseModel):
username: str
email: str
full_name: str
disabled: bool = False
class UserInDB(User):
hashed_password: str
Utilitas Hashing Kata Sandi
Selanjutnya, Anda memerlukan utilitas untuk melakukan hash dan memverifikasi kata sandi. Buat file bernama security.py
:
from passlib.context import CryptContext
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
def verify_password(plain_password, hashed_password):
return pwd_context.verify(plain_password, hashed_password)
def get_password_hash(password):
return pwd_context.hash(password)
Alur Kata Sandi OAuth2
Sekarang, konfigurasikan Alur Kata Sandi OAuth2. Perbarui main.py
Anda untuk menyertakan yang berikut:
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from pydantic import BaseModel
from typing import Optional
import time
# Secret key to encode JWT
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
# User database simulation
fake_users_db = {
"johndoe": {
"username": "johndoe",
"full_name": "John Doe",
"email": "johndoe@example.com",
"hashed_password": "$2b$12$...",
"disabled": False,
}
}
class Token(BaseModel):
access_token: str
token_type: str
class TokenData(BaseModel):
username: Optional[str] = None
def authenticate_user(fake_db, username: str, password: str):
user = fake_db.get(username)
if not user:
return False
if not verify_password(password, user["hashed_password"]):
return False
return user
def create_access_token(data: dict, expires_delta: Optional[int] = None):
to_encode = data.copy()
if expires_delta:
expire = time.time() + expires_delta
else:
expire = time.time() + ACCESS_TOKEN_EXPIRE_MINUTES * 60
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
@app.post("/token", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
user = authenticate_user(fake_users_db, form_data.username, form_data.password)
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Bearer"},
)
access_token = create_access_token(data={"sub": user["username"]})
return {"access_token": access_token, "token_type": "bearer"}
@app.get("/users/me", response_model=User)
async def read_users_me(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
except JWTError:
raise credentials_exception
user = fake_users_db.get(username, None)
if user is None:
raise credentials_exception
return user
Kode ini menyiapkan alur kata sandi OAuth2 sederhana. Pengguna dapat memperoleh token dengan memberikan nama pengguna dan kata sandi mereka ke titik akhir /token
, dan mereka dapat menggunakan token ini untuk mengautentikasi diri mereka sendiri pada titik akhir yang dilindungi seperti /users/me
.
Langkah 4: Menguji Autentikasi Anda
Untuk menguji autentikasi Anda, Anda dapat menggunakan alat pengujian API seperti Postman atau Apidog. Berikut cara melakukannya dengan Apidog:
Buat permintaan Baru: Buka Apidog dan buat permintaan baru.





Meningkatkan Autentikasi FastAPI Anda dengan Apidog
Meskipun FastAPI membuat pengaturan autentikasi menjadi mudah, alat seperti Apidog dapat lebih merampingkan proses dengan menyediakan platform untuk mendesain, mendokumentasikan, dan menguji API Anda. Apidog menawarkan antarmuka yang ramah pengguna untuk mengelola titik akhir API Anda, mensimulasikan respons, dan berkolaborasi dengan tim Anda.

Manfaat Menggunakan Apidog
- Manajemen API Komprehensif: Desain, uji, dan dokumentasikan API Anda di satu tempat.
- Kolaborasi: Bekerja dengan tim Anda secara real-time, bagikan titik akhir, dan tinjau perubahan.
- Respons Mock: Simulasikan respons API untuk pengujian tanpa mencapai titik akhir yang sebenarnya.
Kesimpulan
FastAPI menyederhanakan proses membangun dan mengamankan API, menjadikannya pilihan utama bagi pengembang yang mencari kinerja dan kemudahan penggunaan. Dengan menerapkan autentikasi dengan FastAPI, Anda memastikan API Anda aman dan hanya dapat diakses oleh pengguna yang berwenang. Selain itu, memanfaatkan alat seperti Apidog dapat meningkatkan pengalaman pengembangan API Anda dengan menyediakan kemampuan manajemen dan pengujian yang kuat.
Sekarang Anda tahu cara menerapkan autentikasi FastAPI, Anda dapat dengan percaya diri mengamankan API Anda dan melindungi data Anda. Selamat membuat kode!