ఫాస్ట్‌ఏపీని ఉపయోగించి అధిక పనితీరు API సేవలను ఎలా నిర్మించాలి

ఫాస్ట్‌ఏపీ అనేది ఆధునిక, వేగవంతమైన (సామర్థ్యవంతమైన) వెబ్ ఫ్రేమ్‌వర్క్, APIలను నిర్మించడానికి ప్రత్యేకంగా రూపొందించబడింది. ఇది పాథాన్ టైప్ సూచనలపై ఆధారపడి ఉంది మరియు అసింక్ ప్రోగ్రామింగ్‌ను మద్దతు ఇస్తుంది, అభివృద్ధి దారులకు అధిక పనితీరు, అధిక అందుబాటులో ఉండే తక్కువ ఆలస్యం ఉన్న API సేవలను నిర్మించడానికి అనుమతిస్తుంది. ఈ వ్యాసం ఫాస్ట్‌ఏపీని ఉపయోగించి అధిక పనితీరు API సేవలను ఎలా నిర్మించాలో మీకు వివరంగా తెలియజేస్తుంది, మేము దశల వారీగా వివరణ ఇస్తాము, మీకు వాతావరణం ఏర్పాటు నుండి మోసగించడానికి పూర్తి ప్రక్రియను సాధించడంలో సహాయపడుతుంది.

మొదటి దశ: వాతావరణం సిద్ధం

మీ అభివృద్ధి వాతావరణంలో Python 3.6+ ఇన్‌స్టాల్ చేయబడినట్లు నిర్ధారించుకోండి. ఇంకా ఇన్‌స్టాల్ చేయకపోతే, Python అధికారిక వెబ్‌సైట్ని సందర్శించి డౌన్‌లోడ్ చేసి ఇన్‌స్టాల్ చేయండి.

ఫాస్ట్‌ఏపీ మరియు ఉవికార్న్‌ను ఇన్‌స్టాల్ చేయండి

ఫాస్ట్‌ఏపీ స్వయంగా సేవలను అందించదు, ASGI సర్వర్‌ను మద్దతు ఇవ్వడానికి అవసరం. ఇక్కడ మేము ఉవికార్న్‌ను ఉపయోగిస్తున్నాము, ఇది అధిక పనితీరు ASGI సర్వర్. ఫాస్ట్‌ఏపీ మరియు ఉవికార్న్‌ను ఇన్‌స్టాల్ చేయడానికి క్రింది ఆదేశాలను ఉపయోగించండి:

pip install fastapi uvicorn

రెండవ దశ: ప్రాథమిక APIని నిర్మించండి

మనం ఒక సులభమైన ఫాస్ట్‌ఏపీ అప్లికేషన్‌ను సృష్టిద్దాం.

అప్లికేషన్ ఫైల్ సృష్టించండి

మీ ప్రాజెక్ట్ డైరెక్టరీలో, main.py అనే పాథాన్ ఫైల్‌ను సృష్టించండి, తరువాత అందులో క్రింది కోడ్‌ను రాయండి:

from fastapi import FastAPI

app = FastAPI()

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

ఈ కోడ్‌లో, మేము మొదట ఫాస్ట్‌ఏపీని దిగుమతి చేసుకుని app ఉదాహరణను సృష్టించాము. తరువాత, మేము ఒక GET మార్గాన్ని నిర్వచించాము, ఇది మూల పథం /ను సందర్శించినప్పుడు ఒక సులభమైన JSON ప్రతిస్పందనను తిరిగి ఇస్తుంది.

సర్వర్‌ను ప్రారంభించండి

మీ ఫాస్ట్‌ఏపీ సర్వర్‌ను ప్రారంభించడానికి క్రింది ఆదేశాన్ని ఉపయోగించండి:

uvicorn main:app --reload

• main: ఫైల్ పేరు, .py పొడిగింపు లేకుండా.
• app: ఫాస్ట్‌ఏపీ ఉదాహరణను సూచిస్తుంది.
• --reload: అభివృద్ధి మోడ్‌లో, ఫైల్ మార్పులు జరిగినప్పుడు సర్వర్ ఆటోమేటిక్‌గా పునఃప్రారంభం అవుతుంది.

మూడవ దశ: మార్గాలను మరియు డేటా మోడల్‌ను నిర్వచించండి

జటిలమైన APIని స్థాపించడానికి, మీరు Pydanticను ఉపయోగించి డేటా మోడల్‌ను నిర్వచించాలి.

డేటా మోడల్‌ను సృష్టించండి

main.pyలో క్రింది విషయాలను చేర్చండి:

from pydantic import BaseModel

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

ఈ కోడ్ Pydanticను ఉపయోగించి Item అనే డేటా మోడల్‌ను సృష్టిస్తుంది, ఇది వస్తువు పేరు, ధర మరియు అందుబాటులో ఉన్నదా అనే మూడు లక్షణాలను కలిగి ఉంది.

కొత్త మార్గాన్ని చేర్చండి

తరువాత, మేము Item రకానికి డేటాను స్వీకరించడానికి కొత్త POST మార్గాన్ని నిర్వచించవచ్చు:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

ఈ మార్గంలో, ఫాస్ట్‌ఏపీ స్వయంగా ప్రవేశించిన డేటాను ధృవీకరించి, దాన్ని Item మోడల్‌కు మ్యాప్ చేస్తుంది.

నాల్గవ దశ: డాక్యుమెంటేషన్ ఆటోమేటిక్‌గా రూపొందించడం

ఫాస్ట్‌ఏపీ యొక్క అత్యంత ప్రయోజనాలలో ఒకటి API డాక్యుమెంటేషన్‌ను ఆటోమేటిక్‌గా రూపొందించగలగడం. మీరు క్రింది చిరునామాను సందర్శించడం ద్వారా చూడవచ్చు:

• స్వాగ్గర్ UI: http://127.0.0.1:8000/docs
• రెడాక్: http://127.0.0.1:8000/redoc

ఈ రూపొందించిన డాక్యుమెంట్లలో, మీరు ఇంటరాక్టివ్‌గా APIని పరీక్షించవచ్చు, ప్రతి మార్గానికి అభ్యర్థన మరియు ప్రతిస్పందన ఫార్మాట్‌ను చూడవచ్చు.

ఐదవ దశ: గుర్తింపు చేర్చండి

వాస్తవ అనువర్తనంలో, గుర్తింపు ఒక ముఖ్యమైన దశ. మేము పాత్ర ఆధారిత గుర్తింపును చేర్చుదాం.

భద్రతా ఆధారాలను చేర్చండి

ఫాస్ట్‌ఏపీ యొక్క Depends పద్ధతి మరియు OAuth2PasswordBearerను ఉపయోగించి గుర్తింపును అమలు చేయండి:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
    return user

మార్గాలను రక్షించండి

తరువాత, మీరు రక్షించాల్సిన మార్గాలకు గుర్తింపును చేర్చవచ్చు:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

ఆరవ దశ: ఫాస్ట్‌ఏపీ అప్లికేషన్‌ను మోసగించండి

మీరు అభివృద్ధి పూర్తి చేసిన తర్వాత, మీరు అప్లికేషన్‌ను క్లౌడ్ సర్వర్‌లో మోసగించాల్సి ఉండవచ్చు. డాకర్‌ను ఉపయోగించి మోసగించడానికి ఎంపిక చేసుకోవచ్చు.

డాకర్‌ఫైల్‌ను సృష్టించండి

ప్రాజెక్ట్ డైరెక్టరీలో Dockerfile అనే ఫైల్‌ను సృష్టించి, క్రింది విషయాలను నమోదు చేయండి:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

డాకర్ ఇమేజ్‌ను నిర్మించండి

మీ టెర్మినల్‌లో, డాకర్ ఇమేజ్‌ను నిర్మించడానికి క్రింది ఆదేశాన్ని ఉపయోగించండి:

docker build -t myfastapiapp .

డాకర్ కంటెయినర్‌ను నడపండి

మీ ఫాస్ట్‌ఏపీ అప్లికేషన్‌ను నడపండి:

docker run -d --name fastapi -p 80:80 myfastapiapp

సారాంశం

ఈ వ్యాసంలో, మేము ఫాస్ట్‌ఏపీని ఉపయోగించి అధిక పనితీరు API సేవలను ఎలా నిర్మించాలో, వాతావరణం సిద్ధం చేయడం నుండి ప్రాథమిక API సృష్టించడం, మార్గాలను మరియు డేటా మోడల్‌ను నిర్వచించడం, గుర్తింపును చేర్చడం మరియు మోసగించడానికి పూర్తి ప్రక్రియను వివరంగా చర్చించాము. ఫాస్ట్‌ఏపీ అనేక శక్తివంతమైన ఫీచర్లను అందిస్తుంది, ఇది ఆధునిక APIలను నిర్మించడం సులభం మరియు సమర్థవంతంగా చేస్తుంది, మీరు అధికారిక డాక్యుమెంటేషన్ ద్వారా మరింత ఫీచర్లు మరియు లక్షణాలను అన్వేషించవచ్చు. ఈ వ్యాసం మీకు ఫాస్ట్‌ఏపీని త్వరగా నేర్చుకోవడంలో మరియు మీ ప్రాజెక్ట్ అభివృద్ధి సామర్థ్యాన్ని సమర్థవంతంగా పెంచడంలో సహాయపడుతుందని ఆశిస్తున్నాము!