FastAPI அறிமுக வழிகாட்டி: உயர் செயல்திறன் API உருவாக்குவதற்கான சிறந்த நடைமுறைகள்

மாடர்ன் பின்புற மேம்பாட்டில், FastAPI மெதுவாக முன்னணி இடத்தைப் பிடித்து, உயர் செயல்திறன் API உருவாக்குவதற்கான பிரபலமான தேர்வாக மாறுகிறது. இந்த வழிகாட்டி, FastAPI இன் அம்சங்கள், நன்மைகள் மற்றும் குறிப்பிட்ட படிகள் மூலம் விரைவில் எப்படி தொடங்குவது என்பதைக் கொண்டு, நீங்கள் உங்கள் நடைமுறை திட்டங்களில் API களை மேலும் திறமையாக உருவாக்க மற்றும் வெளியிட உதவுகிறது.

FastAPI என்ன?

FastAPI என்பது ஒரு நவீன, விரைவான (உயர் செயல்திறன்) வலை கட்டமைப்பு ஆகும், இது தரநிலையான Python வகை குறிப்பு அடிப்படையில் உள்ளது. இது மேம்பாட்டாளர்களுக்கு எளிமையான முறையில் விரைவான API களை உருவாக்க அனுமதிக்கிறது, அதே சமயம் திறமையான இயக்க வேகம் மற்றும் நல்ல பராமரிப்பு உறுதி செய்கிறது. இதன் முக்கிய அம்சங்கள்:

• உயர் செயல்திறன்: Starlette (வலை பகுதி) மற்றும் Pydantic (தரவியல் பகுதி) அடிப்படையில், செயல்திறன் Node.js மற்றும் Go க்கு அருகில் உள்ளது.
• தானாக ஆவண உருவாக்கம்: OpenAPI மற்றும் JSON Schema மூலம், FastAPI தானாகவே தொடர்புடைய API ஆவணங்களை உருவாக்குகிறது.
• எளிதாக பயன்படுத்துவது: Python வகை குறிப்பு பயன்படுத்துவதால், பொதுவான பிழைகளை குறைக்கிறது மற்றும் மேம்பாட்டாளர்களின் உற்பத்தி திறனை அதிகரிக்கிறது.
• செயற்கை நிரலாக்கத்தை ஆதரிக்கிறது: async மற்றும் await ஐ ஆதரிக்கிறது, இது அதிகமான கோரிக்கைகளை கையாளும் போது செயல்திறன் நன்மைகளை வழங்குகிறது.

FastAPI இன் நன்மைகள்

FastAPI பாரம்பரிய கட்டமைப்புகளுக்கு (Django மற்றும் Flask போன்றவை) ஒப்பிடும்போது குறிப்பிடத்தக்க நன்மைகள் உள்ளன:

1. விரைவான மேம்பாடு: தானாக உருவாக்கப்படும் ஆவணங்கள் மற்றும் வகை சோதனை காரணமாக, மேம்பாட்டு வேகம் குறிப்பிடத்தக்க அளவுக்கு அதிகரிக்கிறது.
2. செயல்திறனில் திறமையானது: அதிக கூட்டத்தை கையாள்வதற்கான பயன்பாடுகளுக்கு ஏற்றது, குறிப்பாக அதிக சுமையில் சிறந்த செயல்திறனை வழங்குகிறது.
3. வலுவான வகை ஆதரவு: வகை குறிப்பு மூலம் இயக்க நேர பிழைகளை குறைக்கிறது.
4. நல்ல சோதனை ஆதரவு: சார்பு ஊட்டம் மற்றும் அதன் கோரிக்கை மாதிரிகள் சோதனை மற்றும் பிழைகளை எளிதாக்குகிறது.

FastAPI ஐ விரைவில் தொடங்குவது

1. சூழல் தயாரிப்பு

முதலில், நீங்கள் Python 3.7 அல்லது அதற்கு மேற்பட்ட பதிப்பை நிறுவியிருக்க வேண்டும். அதன் பிறகு, கீழ்காணும் கட்டளையைப் பயன்படுத்தி FastAPI மற்றும் ASGI சேவையகமான Uvicorn ஐ நிறுவலாம்:

pip install fastapi uvicorn

2. அடிப்படையான FastAPI பயன்பாட்டை உருவாக்குதல்

அடுத்ததாக, ஒரு எளிய FastAPI பயன்பாட்டை உருவாக்குங்கள். உங்கள் வேலை அடைவில், புதிய main.py கோப்பை உருவாக்கி, உள்ளடக்கம் கீழ்வருமாறு இருக்க வேண்டும்:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "query": q}

3. பயன்பாட்டை இயக்குதல்

Uvicorn ஐப் பயன்படுத்தி FastAPI பயன்பாட்டை இயக்குங்கள்:

uvicorn main:app --reload

உங்கள் உலாவியில் http://127.0.0.1:8000 ஐ அணுகினால், நீங்கள் {"Hello": "World"} என்ற பதிலைப் பார்க்கலாம். அதே சமயம், http://127.0.0.1:8000/items/1?q=test ஐ அணுகினால் {"item_id": 1, "query": "test"} என்ற பதிலைப் பெறுவீர்கள்.

4. தானாக ஆவண உருவாக்குதல்

FastAPI ஒவ்வொரு பாதைக்கும் தானாகவே ஆவணங்களை உருவாக்குகிறது, நீங்கள் கீழ்காணும் URL ஐ அணுகி தொடர்புடைய ஆவணங்களைப் பார்க்கலாம்:

• Swagger UI: http://127.0.0.1:8000/docs
• ReDoc: http://127.0.0.1:8000/redoc

5. தரவுத்தொகுப்புகள் மற்றும் சோதனை

FastAPI Pydantic மூலம் தரவுத்தொகுப்புகளை உருவாக்குவதையும், கோரிக்கையின் உடல்களை சோதிக்கவும் ஆதரிக்கிறது. எடுத்துக்காட்டாக:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

@app.post("/items/")
async def create_item(item: Item):
    return item

மேலே உள்ள குறியீட்டு துண்டம் Item என்ற தரவுத்தொகுப்பை வரையறுக்கிறது, FastAPI அனுப்பப்படும் JSON தரவுகளை தானாகவே சோதிக்கிறது.

6. செயற்கை மற்றும் ஒத்திசைவு நிரலாக்கம்

FastAPI செயற்கை நிரலாக்கத்தை ஆதரிக்கிறது, நீங்கள் async def ஐப் பயன்படுத்தி செயற்கை பாதை செயல்பாட்டு செயல்களை வரையறுக்கலாம். எடுத்துக்காட்டாக:

import asyncio

@app.get("/wait/")
async def wait_for_response():
    await asyncio.sleep(1)
    return {"message": "Waited for 1 second!"}

7. FastAPI பயன்பாட்டை வெளியிடுதல்

FastAPI பயன்பாடுகளை பல சூழல்களில் வெளியிடலாம், Docker, Kubernetes, மேக சேவைகள் போன்றவை. Docker ஐப் பயன்படுத்தி FastAPI ஐ வெளியிடுவதற்கான எளிய எடுத்துக்காட்டு:

# Dockerfile
FROM python:3.9

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

பிறகு Docker படத்தை உருவாக்கி இயக்குங்கள்:

docker build -t myfastapiapp .
docker run -d -p 8000:8000 myfastapiapp

நீங்கள் http://localhost:8000 ஐ அணுகி உங்கள் பயன்பாட்டைப் பார்க்கலாம்.

சிறந்த நடைமுறைகள்

1. வகை குறிப்பு பயன்படுத்தவும்: எப்போதும் Python வகை குறிப்பு பயன்படுத்தி குறியீட்டு வாசிக்கability மற்றும் பராமரிப்பு மேம்படுத்தவும்.
2. அளவீட்டு சோதனை: வணிக தேவைகளைப் பொறுத்து சரியான அளவீட்டு சோதனைகளை அமைக்கவும், API க்கு அனுப்பப்படும் தரவுகள் செல்லுபடியாக இருப்பதை உறுதி செய்யவும்.
3. மொத்தமாக பிழைகளை கையாளவும்: உலகளாவிய பிழை கையாளலை வரையறுக்கவும், API சரியாக பிழைகளை கையாள முடியும் என்பதை உறுதி செய்யவும்.
4. ஆவணங்கள் மற்றும் குறிப்பு: API ஆவணங்களை புதுப்பித்து வைத்திருக்கவும், குறிப்பு மற்றும் ஆவணங்கள் மூலம் குறியீட்டை அணுகக்கூடியதாக வைத்திருக்கவும்.
5. மத்திய இடங்களைப் பயன்படுத்தவும்: CORS, அடையாளம் உறுதிப்படுத்துதல் போன்ற செயல்பாடுகளுக்காக மத்திய இடங்களைப் பயன்படுத்தவும்.

முடிவு

FastAPI என்பது நவீன உயர் செயல்திறன் API களை உருவாக்குவதற்கான சக்திவாய்ந்த கருவியாகும், அதன் செயல்திறன் மற்றும் எளிதான பயன்பாட்டால் மேம்பாட்டாளர்களிடையே பரவலாக வரவேற்கப்படுகிறது. தொடக்கத்திற்கானவர்கள் அல்லது அனுபவமிக்க மேம்பாட்டாளர்கள், இருவரும் இதிலிருந்து பயன் பெறலாம். நடைமுறை மேம்பாட்டில், சிறந்த நடைமுறைகளை இணைத்தால், நீங்கள் திட்டங்களை மேலும் திறமையாக உருவாக்க மற்றும் பராமரிக்க முடியும். இந்த வழிகாட்டி உங்கள் FastAPI கற்றல் பயணத்திற்கு வழிகாட்டியாகவும் உதவியாகவும் இருக்கும் என்று நம்புகிறேன்!