08 ਸਤੰ 2025·8 ਮਿੰਟ
FastAPI ਕੀ ਹੈ? APIs ਬਣਾਉਣ ਲਈ ਇੱਕ ਅਮਲੀ ਗਾਈਡ
FastAPI ਇੱਕ ਆਧੁਨਿਕ Python ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਟਾਈਪ ਹਿੰਟ, ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਆਟੋਮੈਟਿਕ OpenAPI ਡੌਕਸ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ APIs ਬਣਾਉਂਦਾ ਹੈ। ਮੁੱਢਲੀ ਗੱਲਾਂ ਅਤੇ ਵਰਤੋਂ ਸਿੱਖੋ।
FastAPI ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ: ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ
FastAPI ਇਕ Python ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਤੇਜ਼ੀ ਨਾਲ ਵੈੱਬ APIs ਬਣਾਉਂਦਾ ਹੈ, ਸਾਫ਼ ਕੋਡ ਅਤੇ ਆਟੋਮੈਟਿਕ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਨਾਲ। ਤੁਸੀਂ ਛੋਟੀਆਂ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ (ਜਿਨ੍ਹਾਂ ਨੂੰ “endpoints” ਕਹਿੰਦੇ ਹਨ) ਜੋ ਘੋਸ਼ਣਾ ਕਰਦੀਆਂ ਹਨ ਕਿ ਤੁਹਾਡੀ API ਕਿਹੜਾ ਡੇਟਾ ਲੈਂਦੀ ਹੈ ਅਤੇ ਕੀ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਅਤੇ FastAPI ਵੈੱਬ ਦੇ ਜੀਵਨ ਚੱਕਰ—ਰੂਟਿੰਗ, ਵੈਲਿਡੇਸ਼ਨ, ਅਤੇ JSON ਜਵਾਬ—ਹੈਂਡਲ ਕਰ ਲੈਂਦਾ ਹੈ।
API ਕੀ ਹੁੰਦਾ ਹੈ? ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ
API URLs ਦਾ ਇਕ ਸੈੱਟ ਹੁੰਦਾ ਹੈ ਜੋ ਇਕ ਸਾਫਟਵੇਅਰ ਨੂੰ ਦੂਜੇ ਨਾਲ ਗੱਲ ਕਰਨ ਦਿੰਦਾ ਹੈ।
ਉਦਾਹਰਣ ਵਜੋਂ, ਤੁਹਾਡੇ ਫ਼ੋਨ ਦੀ ਮੌਸਮ ਐਪ GET /weather?city=Berlin ਵਰਗਾ URL ਕਾਲ ਕਰ ਸਕਦੀ ਹੈ। ਸਰਵਰ ਸੰਰਚਿਤ ਡੇਟਾ (ਅਤਿ ਸ਼ਾਮਿਲ ਤੌਰ 'ਤੇ JSON) ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਤਾਪਮਾਨ ਅਤੇ ਫੋਰਕਾਸਟ। ਫ਼ੋਨ ਐਪ ਨੂੰ ਸਰਵਰ ਦੇ ਡੈਟਾਬੇਸ ਤੱਕ ਸਿੱਧੀ ਪਹੁੰਚ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ—ਉਹ ਸਿਰਫ API ਨੂੰ ਪੁੱਛਦੀ ਹੈ ਅਤੇ ਨਤੀਜਾ ਦਿਖਾਉਂਦੀ ਹੈ।
FastAPI ਤੁਹਾਨੂੰ ਉਹ URLs ਅਤੇ ਜਵਾਬ Python ਵਿੱਚ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
FastAPI ਕੌਣ ਲਈ ਹੈ?
- ਨਵੇਂ ਸ਼ੁਰੂਆਤਕਰਤਾ ਜੋ ਇਕ ਆਧੁਨਿਕ, ਮਾਰਗਦਰਸ਼ਿਤ ਤਰੀਕੇ ਨਾਲ ਬਿਨਾਂ ਬਹੁਤ ਸਾਰੇ ਬਾਇਲਰਪਲੇਟ ਦੇ APIs ਬਣਾਉਣੀ ਚਾਹੁੰਦੇ ਹਨ।
- ਇਕਲ-ਡਿਵੈਲਪਰ ਜੋ ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵਧਣਾ ਚਾਹੁੰਦੇ ਹਨ ਤੇ ਕੋਡ ਨੂੰ ਪਠਨਯੋਗ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹਨ।
- ਟੀਮਾਂ ਜੋ ਪ੍ਰੋਡਕਸ਼ਨ ਸੇਵਾਵਾਂ ਬਣਾਉਂਦੀਆਂ ਹਨ ਅਤੇ ਮਜ਼ਬੂਤ ਵੈਲਿਡੇਸ਼ਨ, ਸਥਿਰ ਸੰਪਰਕ, ਅਤੇ ਚੰਗੀ ਡੌਕ्यूਮੈਂਟੇਸ਼ਨ ਤੋਂ ਫ਼ਾਇਦਾ ਲੈਂਦੀਆਂ ਹਨ।
ਤੁਹਾਨੂੰ async ਦੀ ਪੂਰਨ ਮਹਿਰਤ ਦੀ ਲੋੜ ਨਹੀਂ—ਤੁਸੀਂ ਸਧਾਰਨ endpoints ਲਿਖ ਕੇ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਜਿਵੇਂ-ਜਿਵੇਂ ਆਪ ਵਧਦੇ ਹੋਆਂ, ਅਡਵਾਂਸ ਪੈਟਰਨ ਅਪਣਾ ਸਕਦੇ ਹੋ।
ਇਸ ਗਾਈਡ ਵਿੱਚ ਤੁਸੀਂ ਕੀ ਸਿੱਖੋਗੇ
- FastAPI ਨੂੰ ਹੋਰ Python API ਵਿਕਲਪਾਂ ਤੋਂ ਕੀ ਵੱਖਰਾ ਬਣਾਉਂਦਾ ਹੈ
- ਰਿਕਵੈਸਟ ਅਤੇ ਰਿਸਪਾਂਸ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ (ਅਤੇ “async” ਦਾ ਅਸਲ ਮਤਲਬ)
- Pydantic ਨਾਲ ਡੇਟਾ ਵੈਲਿਡੇਸ਼ਨ ਕਿਵੇਂ ਹੁੰਦੀ ਹੈ
- FastAPI OpenAPI ਡੌਕਸ (Swagger UI ਅਤੇ ReDoc) ਕਿਵੇਂ ਬਣਾਉਂਦਾ ਹੈ
- ਡਿਪੈਂਡੇਨਸੀਜ਼, ਸੁਰੱਖਿਆ, ਟੈਸਟ, ਅਤੇ ਡਿਪਲੌਇਮੈਂਟ ਦੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ
FastAPI ਲੋਕਪ੍ਰਿਯ ਕਿਉਂ ਹੋਇਆ
FastAPI ਤੇਜ਼ੀ ਨਾਲ ਲੋਕਪ੍ਰਿਯ ਹੋਇਆ ਕਿਉਂਕਿ ਇਹ ਉਹਨਾਂ ਆਮ ਰੁਕਾਵਟਾਂ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ ਜੋ ਲੋਕ Python ਵਿੱਚ APIs ਬਣਾਉਂਦੇ ਸਮੇਂ ਮਹਿਲਾਂ ਚੁੱਕਦੇ ਹਨ।
ਇਹ ਆਮ API ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ
ਰਵਾਇਤੀ API ਪ੍ਰੋਜੈਕਟ ਅਕਸਰ ਧੀਮੇ ਸੈਟਅਪ ਅਤੇ ਬਹੁਤ ਸਾਰੇ “ਪਲੰਬਿੰਗ” ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ:
- ਮੈਨੁਅਲ ਤਰੀਕੇ ਨਾਲ ਰਿਕਵੈਸਟ ਪਾਰਸਿੰਗ, ਵੈਲਿਡੇਸ਼ਨ, ਅਤੇ ਐਰਰ ਮੈਸੇਜ ਲਿਖਣਾ (ਤੇ ਸਿੰਕ ਰੱਖਣਾ)
- ਅਸਪਸ਼ਟ API ਕਾਂਟ੍ਰੈਕਟ—ਇਹ endpoint ਠੀਕ-ਠਾਕ ਕੀ ਲੈਂਦਾ ਹੈ ਅਤੇ ਕੀ ਵਾਪਸ ਕਰਦਾ ਹੈ?
- ਡੌਕਸ ਜੋ ਕੋਡ ਦੇ ਨਾਲ ਪਿੱਛੇ ਰਹਿ ਜਾਂਦੀਆਂ ਹਨ, ਖ਼ਾਸ ਕਰਕੇ ਜਦ ਟੀਮ ਵੱਧਦੀ ਹੈ
FastAPI ਦੀਆਂ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਸਿੱਧਾ ਨਿਸ਼ਾਨਾ ਕਰਦੀਆਂ ਹਨ, ਤਾਂ ਜੋ ਟੀਮਜ਼ ਹੋਰ ਸਮਾਂ endpoints ਡਿਜ਼ਾਇਨ ਕਰਨ ਵਿੱਚ ਲੱਗਾ ਸਕਣ ਅਤੇ ਫਰੇਮਵਰਕ ਬਾਇਲਰਪਲੇਟ ਨਾਲ ਨਾ ਲੜਨ।
ਟਾਈਪ ਹਿੰਟ ਕੋਡ ਨੂੰ ਇੱਕ ਕਾਂਟ੍ਰੈਕਟ ਵਾਂਗ ਬਣਾਉਂਦੇ ਹਨ
FastAPI Python ਟਾਈਪ ਹਿੰਟਸ 'ਤੇ ਭਾਰੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜਦ ਤੁਸੀਂ ਘੋਸ਼ਣਾ ਕਰਦੇ ਹੋ ਕਿ ਇੱਕ ਫੀਲਡ int ਹੈ, ਵੈਕਲਪਿਕ ਹੈ, ਜਾਂ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਲਿਸਟ ਹੈ, FastAPI ਉਹ ਜਾਣਕਾਰੀ ਇਨਪੁਟ ਦੀ ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਆਉਟਪੁਟ ਦੇ ਆਕਾਰ ਲਈ ਵਰਤਦਾ ਹੈ।
ਇਸ ਨਾਲ “stringly-typed” ਗਲਤੀਆਂ ਘੱਟ ਹੁੰਦੀਆਂ ਹਨ (ਜਿਵੇਂ ਕਿ ਇੱਕ ID ਨੂੰ ਇਕ ਥਾਂ ਤੇ ਟੈਕਸਟ ਅਤੇ ਦੂਜੇ ਥਾਂ ਤੇ ਨੰਬਰ ਵਜੋਂ ਵਰਤਣਾ) ਅਤੇ ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰਾਂ ਵਿੱਚ ਸਪਸ਼ਟ ਉਮੀਦਾਂ ਸ਼ਾਮਿਲ ਹੋਂਦੀਆਂ ਹਨ।
ਆਟੋਮੈਟਿਕ ਡੌਕਸ ਟੀਮਾਂ ਨੂੰ ਤੇਜ਼ ਤਰੀਕੇ ਨਾਲ ਅੱਗੇ ਵਧਾਉਂਦੀਆਂ ਹਨ
ਕੋਡ ਤੋਂ ਨਿਕਲਣ ਵਾਲੀ API ਸਕੀਮਾ ਕਾਰਨ FastAPI ਇੰਟਰਐਕਟਿਵ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ (OpenAPI + Swagger UI/ReDoc) ਆਟੋਮੈਟਿਕ ਤੌਰ ਤੇ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਸਹਿਯੋਗ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਫਰੰਟਐਂਡ ਡਿਵੈਲਪਰ, QA, ਅਤੇ ਇੰਟੇਗਰੇਟਰ endpoints ਨੂੰ ਐਕਸਪਲੋਰ ਕਰ ਸਕਦੇ ਹਨ, ਰਿਕਵੈਸਟ ਟਰਾਈ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਵਸਤੂਆਂ ਦੀ ਸਹੀ ਢਾਂਚਾ ਦੇਖ ਸਕਦੇ ਹਨ—ਕਿਸੇ ਵੱਖਰੀ ਡੌਕਸ ਦੀ ਉਡੀਕ ਕੀਤੇ ਬਿਨਾਂ।
ਲੋਕਪ੍ਰਿਯ ਹੈ, ਪਰ ਜਾਦੂ ਨਹੀਂ
FastAPI ਬੇਤਰਤੀਬੀ ਨਾਲ ਬਣਾਈ ਗਈ API ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰੇਗਾ। ਅਜੇ ਵੀ ਤੁਹਾਨੂੰ ਚੰਗੇ ਨਾਂਕਰਨ, ਵਰਸਨਿੰਗ, ਐਰਰ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਸੁਰੱਖਿਆ ਫੈਸਲੇ ਕਰਨੇ ਪੈਣਗੇ। ਜੋ ਇਹ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਉਹ ਹੈ “ਵਿਚਾਰ” ਤੋਂ “ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਤ API” ਤੱਕ ਇੱਕ ਸਾਫ਼ ਰਸਤਾ ਬਿਨਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਅਚੰਭਿਆਂ ਦੇ।
ਮੁੱਖ ਧਾਰਣਾਵਾਂ ਜੋ ਤੁਹਾਨੂੰ ਜਾਣਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ
FastAPI ਕੁਝ ਕੋਰ ਆਈਡੀਅਜ਼ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਇਹ ਸਧਾਰਨ ਲੱਗਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਅੰਦਰੂਨੀ ਗਲਤੀਆਂ ਯਾਦ ਰੱਖਣਾਂ ਲਾਜ਼ਮੀ ਨਹੀਂ—ਸਿਰਫ ਉਹ ਚੀਜ਼ਾਂ ਪਛਾਣੋ ਜੋ ਹਰ ਰੋਜ਼ ਤੁਸੀਂ ਵਰਤੋਂਗੇ।
FastAPI ਇੱਕ ਫਰੇਮਵਰਕ ਹੈ
ਇੱਕ ਫਰੇਮਵਰਕ ਉਹ ਟੂਲ ਅਤੇ ਰਿਵਾਜ਼ਾਂ ਦਾ ਸੈੱਟ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਸ਼ੁਰੂ ਤੋਂ ਨਹੀਂ ਬਣਾਉਣਾ ਪੈਂਦਾ। FastAPI ਆਮ API ਕੰਮਾਂ ਲਈ “ਪਲੰਬਿੰਗ” ਮੁਹੱਈਆ ਕਰਦਾ ਹੈ: endpoints ਦੀ ਪਰਿਭਾਸ਼ਾ, ਇਨਪੁਟ ਪੜ੍ਹਨਾ, ਆਉਟਪੁਟ ਵਾਪਸ ਕਰਨਾ, ਐਰਰ ਹੈਂਡਲ ਕਰਨਾ, ਅਤੇ ਕੋਡ ਨੂੰ ਰੱਖ-ਰਖਾਵਯੋਗ ਢੰਗ ਨਾਲ ਅਯੋਜਿਤ ਕਰਨਾ।
routing: endpoints ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਹੁੰਦੇ ਹਨ
Routing URL ਅਤੇ HTTP ਮੈਥਡ ਨੂੰ Python ਕੋਡ ਦੇ ਟੁੱਕੜੇ ਨਾਲ ਜੋੜਣ ਦਾ ਤਰੀਕਾ ਹੈ।
ਉਦਾਹਰਣ ਵਜੋਂ, ਤੁਸੀਂ GET /users ਨੂੰ “ਲਿਸਟ ਯੂਜ਼ਰ” ਅਤੇ POST /users ਨੂੰ “ਯੂਜ਼ਰ ਬਣਾਓ” ਨਾਲ ਰੂਟ ਕਰ ਸਕਦੇ ਹੋ। FastAPI ਵਿੱਚ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ @app.get(...) ਅਤੇ @app.post(...) ਵਰਗੀਆਂ ਡੈਕੋਰੇਟਰਜ਼ ਨਾਲ ਰੂਟ ਡਿਫਾਈਨ ਕਰਦੇ ਹੋ, ਜਿਸ ਨਾਲ ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ ਪਤਾ ਲੱਗ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਡੀ API ਕੀ ਪੇਸ਼ ਕਰਦੀ ਹੈ।
ਰਿਕਵੈਸਟ ਅਤੇ ਰਿਸਪਾਂਸ
ਹਰ API ਕਾਲ ਇੱਕ রিকਵੇਸਟ (ਜੋ ਕੁਲਾਇੰਟ ਭੇਜਦਾ ਹੈ) ਅਤੇ ਇੱਕ ਰਿਸਪਾਂਸ (ਜੋ ਤੁਹਾਡਾ ਸਰਵਰ ਵਾਪਸ ਕਰਦਾ ਹੈ) ਹੁੰਦੀ ਹੈ।
FastAPI ਤੁਹਾਨੂੰ ਮਦਦ ਕਰਦਾ ਹੈ:
- ਪਾਥ (
/users/{id}), query string (?page=2), ਹੈਡਰ, ਅਤੇ ਰਿਕਵੈਸਟ ਬਾਡੀ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹਨ ਵਿੱਚ - ਸਹੀ ਸਟੇਟਸ ਕੋਡਾਂ (ਜਿਵੇਂ
200,201,404) ਨਾਲ ਸੰਰਚਿਤ JSON ਜਵਾਬ ਵਾਪਸ ਕਰਨ ਵਿੱਚ
ASGI (ਉੱਚ ਪੱਧਰ)
FastAPI ASGI 'ਤੇ ਚੱਲਦਾ ਹੈ, ਜੋ Python ਵੈੱਬ ਸਰਵਰਾਂ ਲਈ ਇੱਕ ਆਧੁਨਿਕ ਮਿਆਰ ਹੈ। ਅਮਲੀ ਤੌਰ 'ਤੇ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ FastAPI ਬਹੁਤ ਸਾਰੀਆਂ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਲੰਬੇ ਸਮੇਂ ਵਾਲੀਆਂ ਕਨੈਕਸ਼ਨਾਂ (ਜਿਵੇਂ WebSockets) ਨੂੰ ਸਹਿਯੋਗ ਦੇ ਸਕਦਾ ਹੈ—ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਨੀਵੇਂ ਸਤਰ ਦੇ ਨੈੱਟਵਰਕ ਪ੍ਰਬੰਧਨ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਪਏ।
ਟਾਈਪ ਹਿੰਟ: ਸਿਰਫ਼ "ਚੰਗੀ ਗੱਲ" ਤੋਂ ਵੱਧ
Python ਟਾਈਪ ਹਿੰਟ (ਜਿਵੇਂ str, int, list[Item]) FastAPI ਵਿੱਚ ਸਿਰਫ़ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ—ਇਹ ਮੂਲ ਆਇਨਪੁਟ ਹਨ। FastAPI ਇਹਨਾਂ ਨੂੰ ਸਮਝ ਕੇ ਜਾਣਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਉਮੀਦ ਕਰਦੇ ਹੋ, ਆਉਂਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸਹੀ ਕਿਸਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਵਧੀਆ, ਅਨੁਮਾਨਯੋਗ APIs ਤਿਆਰ ਕਰਦਾ ਹੈ।
Pydantic ਮਾਡਲ ਵੈਲਿਡੇਸ਼ਨ ਲਈ
Pydantic ਮਾਡਲ ਤੁਹਾਨੂੰ ਇੱਕ ਥਾਂ ਤੇ ਡੇਟਾ ਦਾ ਆਕਾਰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੇ ਦਿੰਦੇ ਹਨ (ਫੀਲਡ, ਟਾਈਪਾਂ, ਵਿਕਲਪਿਕ ਮੁੱਲ)। FastAPI ਇਹ ਮਾਡਲ ਵਰਤ ਕੇ ਆਉਂਦੀ JSON ਨੂੰ ਵੈਲਿਡੇਟ ਕਰਦਾ ਹੈ, ਗਲਤ ਇਨਪੁਟ ਨੂੰ ਨਾਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਆਉਟਪੁਟ ਨੂੰ ਸਥਿਰ ਤਰੀਕੇ ਨਾਲ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ—ਤਾਂ ਜੋ ਤੁਹਾਡੀ API ਵਿਅਵਹਾਰਿਕ ਤੌਰ 'ਤੇ ਭਰੋਸੇਯੋਗ ਰਹੇ।
FastAPI ਕਿਵੇਂ ਰਿਕਵੈਸਟ ਅਤੇ ਰਿਸਪਾਂਸ ਹੈਂਡਲ ਕਰਦਾ ਹੈ
Experiment without fear
Save progress with snapshots and roll back safely while you iterate.
FastAPI ਐਪ endpoints ਦੇ ਆਸ-ਪਾਸ ਬਣੇ ਹੁੰਦੇ ਹਨ: ਇੱਕ URL ਪਾਥ ਅਤੇ HTTP ਮੈਥਡ। ਇੱਕ endpoint ਸੋਚੋ ਕਿ “ਕਲਾਇੰਟ ਕੀ ਮੰਗ ਰਿਹਾ ਹੈ” ਅਤੇ “ਉਹ ਕਿਵੇਂ ਮੰਗ ਰਿਹਾ ਹੈ।” ਉਦਾਹਰਣ ਵਜੋਂ, ਕਲਾਇੰਟ GET /users ਕਰ ਸਕਦਾ ਹੈ ਯੂਜ਼ਰ ਲਿਸਟ ਕਰਨ ਲਈ, ਜਾਂ POST /users ਕਰ ਸਕਦਾ ਹੈ ਨਵਾਂ ਯੂਜ਼ਰ ਬਣਾਉਣ ਲਈ।
Endpoints = paths + methods
ਇੱਕ ਪਾਥ ਰੂਟ ਹੈ, ਅਤੇ ਮੈਥਡ ਕਾਰਵਾਈ ਹੈ:
GET /products→ ਡੇਟਾ ਲਿਆਉਣਾPOST /products→ ਕੁਝ ਬਣਾਉਣ ਲਈ ਡੇਟਾ ਭੇਜਣਾPUT /products/123→ ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਬਦਲਣਾ/ਅਪਡੇਟ ਕਰਨਾDELETE /products/123→ ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਹਟਾਉਣਾ
Path parameters vs. query parameters
FastAPI ਪਾਥ ਦਾ ਹਿੱਸਾ ਹੋਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਉਸ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਅਕਸਰ ਵਿਕਲਪਿਕ "ਫਿਲਟਰ" ਹੁੰਦੇ ਹਨ।
- Path parameter: URL ਸਰਚਨਾ ਵਿੱਚ ਸ਼ਾਮਿਲ।
- ਉਦਾਹਰਣ:
GET /users/42→42ਯੂਜ਼ਰ ID ਹੈ।
- ਉਦਾਹਰਣ:
- Query parameter:
?ਦੇ ਬਾਅਦ ਜੁੜਦਾ ਹੈ ਅਤੇ ਆਮਤੌਰ 'ਤੇ ਵਿਕਲਪਿਕ ਹੁੰਦਾ ਹੈ।- ਉਦਾਹਰਣ:
GET /users?limit=10&active=true→limitਅਤੇactiveਨਤੀਜੇ ਕਿਵੇਂ ਵਾਪਸ ਹੋਣ, ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਦੇ ਹਨ।
- ਉਦਾਹਰਣ:
JSON ਪੇਲੋਡ ਲਈ ਰਿਕਵੈਸਟ ਬਾਡੀ
ਜਦੋਂ ਕਲਾਇੰਟ ਸੰਰਚਿਤ ਡੇਟਾ (ਅਮੂਮਨ JSON) ਭੇਜਦਾ ਹੈ, ਉਹ request body ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਅਕਸਰ POST ਜਾਂ PUT ਨਾਲ।
ਉਦਾਹਰਣ: POST /orders ਨਾਲ JSON { "item_id": 3, "quantity": 2 }।
response models ਅਤੇ ਇੱਕਸਾਰ ਆਉਟਪੁਟ
FastAPI ਸਿੱਧੇ Python objects (ਜਿਵੇਂ dicts) ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਸਭ ਤੋਂ ਵਧੀਆ ਓਸ ਸਮੇਂ ਹੁੰਦਾ ਹੈ ਜਦ ਤੁਸੀਂ ਇਕ response model ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ। ਉਹ ਮਾਡਲ ਇੱਕ ਕਾਂਟ੍ਰੈਕਟ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ: ਫੀਲਡ ਇੱਕਸਾਰ ਹੁੰਦੇ ਹਨ, ਅਤਿਰਿਕਤ ਡੇਟਾ ਫਿਲਟਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਟਾਈਪਾਂ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਨਤੀਜਾ ਹੈ ਕਿ API ਸਾਫ਼ ਬਣਦੀ ਹੈ—ਕਲਾਇੰਟਾਂ ਨੂੰ ਪਤਾ ਹੁੰਦਾ ਹੈ ਕਿ ਕੀ ਉਮੀਦ ਰੱਖਣੀ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਅਚਾਨਕ ਜਵਾਬਾਂ ਤੋਂ ਬਚਦੇ ਹੋ ਜੋ ਇੰਟੇਗ੍ਰੇਸ਼ਨਾਂ ਨੂੰ ਤੋੜ ਸਕਦੀਆਂ ਹਨ।
FastAPI ਵਿੱਚ Async: ਇਹ ਕੀ ਹੈ ਅਤੇ ਕਦੋਂ ਮਦਦ ਕਰਦਾ ਹੈ
“Async” (ਅਰਥਾਤ asynchronous) ਇੱਕ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਤੁਹਾਡੀ API ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰ ਸਕਦੀ ਹੈ ਜਦ ਬਹੁਤ ਸਮਾਂ "ਉਡੀਕ" ਵਿੱਚ ਲੰਘਦਾ ਹੈ।
ਹਰ ਰੋਜ਼ ਦੀ ਇਕ ਤુલਨਾ: I/O 'ਤੇ ਉਡੀਕ
ਇਕ ਬੈਰਿਸਟਾ ਦੀ ਸੋਚ ਕਰੋ ਜੋ ਆਰਡਰ ਲੈਂਦਾ ਹੈ। ਜੇ ਉਸਨੂੰ ਕਾਫੀ ਮਸ਼ੀਨ ਚੱਲਣ ਦੌਰਾਨ ਖੜਾ ਰਹਿ ਕੇ ਕੁਛ ਵੀ ਨਹੀਂ ਕਰਨਾ ਪੈਂਦਾ, ਤਾਂ ਉਹ ਘੱਟ ਗ੍ਰਾਹਕਾਂ ਨੂੰ ਸਰਵਿਸ ਦੇ ਸਕੇਗਾ। ਇੱਕ ਚੰਗਾ ਤਰੀਕਾ ਹੈ: ਕਾਫੀ ਬਣਾਉਣ ਦੌਰਾਨ ਅਗਲਾ ਆਰਡਰ ਲੈ ਲੈਣਾ।
Async ਓਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੀ FastAPI ਐਪ ਕਿਸੇ ਓਪਰੇਸ਼ਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀ ਹੈ ਜੋ ਕਿਸੇ ਸਲੇਟ-ਸਮੇਂ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ—ਜਿਵੇਂ ਨੈੱਟਵਰਕ ਰਿਕਵੈਸਟ ਜਾਂ ਡੇਟਾਬੇਸ ਕਾਲ—ਅਤੇ ਜਦ ਉਹ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਹੋਰ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਹੈਂਡਲ ਕਰਨ ਲਈ ਚਲ ਪੈ ਸਕਦੀ ਹੈ।
Async ਸਭ ਤੋਂ ਵਧੇਰੇ ਕਦੋਂ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ
Async ਉਹ ਸਮੇਂ ਚਮਕਦਾ ਹੈ ਜਦ ਤੁਹਾਡੀ API ਬਹੁਤ ਜ਼ਿਆਦਾ I/O ਕੰਮ ਕਰਦੀ ਹੈ—ਉਹ ਕੰਮ ਜੋ ਸੋਚਣ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਮਾਂ ਉਡੀਕ ਵਿੱਚ ਲੈਂਦੇ ਹਨ। ਆਮ ਉਦਾਹਰਣ:
- ਨੈੱਟਵਰਕ ਉੱਤੇ ਡੇਟਾਬੇਸ ਕਾਲ (ਖਾਸ ਕਰਕੇ)
- ਬਾਹਰੀ ਸੇਵਾਵਾਂ ਨੂੰ ਕਾਲ ਕਰਨਾ (ਪੇਮੈਂਟ ਪ੍ਰੋਵਾਈਡਰ, ਨਕਸ਼ੇ, ਈਮੇਲ ਐਪੀਆਈ)
- ਫਾਇਲਾਂ ਪੜ੍ਹਨਾ/ਲਿਖਣਾ ਜਾਂ object storage ਨਾਲ ਗੱਲਬਾਤ
ਜੇਕਰ ਤੁਹਾਡੇ endpoints ਅਕਸਰ ਇਨ੍ਹਾਂ ਓਪਰੇਸ਼ਨਾਂ 'ਤੇ ਉਡੀਕ ਕਰਦੇ ਹਨ, ਤਾਂ async throughput ਬਿਹਤਰ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਲੋਡ ਹੇਠਾਂ ਬੇਨਤੀਆਂ ਦੇ ਢੇਰ ਹੋਣ ਦੇ ਚਾਂਸ ਘੱਟ ਕਰ ਸਕਦਾ ਹੈ।
Async ਹਰ ਚੀਜ਼ ਲਈ ਜਰੂਰੀ ਨਹੀਂ
Async ਹਰ ਚੀਜ਼ ਲਈ ਜਾਦੂਈ ਗਤੀ ਕਾਂਪ ਨਹੀਂ ਹੈ। ਜੇ ਤੁਹਾਡਾ endpoint ਅਕਸਰ CPU-ਭਾਰ ਹੈ—ਜਿਵੇਂ ਵੱਡੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਰੀਸਾਈਜ਼ ਕਰਨਾ, ਡੇਟਾ ਸਾਇੰਸ ਦੀਆਂ ਗਿਣਤੀਆਂ, ਜਾਂ ਵੱਡੇ ਪੇਲੋਡ ਏਨਕ੍ਰਿਪਟ ਕਰਨਾ—ਤਾਂ async ਖੁਦ ਘਣਨਾਤਮਕ ਕੰਮ ਨੂੰ ਤੇਜ਼ ਨਹੀਂ ਕਰੇਗਾ। ਉਹਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਵੱਖਰੇ ਤਰੀਕੇ ਵਰਤਦੇ ਹੋ (ਬੈਕਗ੍ਰਾਊਂਡ ਵਰਕਰ, ਪ੍ਰੋਸੈਸ ਪੂਲ, ਜਾਂ ਸਕੇਲ-ਆਊਟ)।
ਚੰਗੀ ਖ਼ਬਰ: sync ਕੋਡ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ
ਹਰ ਚੀਜ਼ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ। ਤੁਸੀਂ ਰੈਗੂਲਰ (sync) route functions ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ FastAPI ਉਹਨਾਂ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਚਲਾਏਗਾ। ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟ ਦੋਹਾਂ ਸ਼ੈਲੀਆਂ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਨ: ਸਧਾਰਨ endpoints sync ਰੱਖੋ, ਅਤੇ async def ਉਨ੍ਹਾਂ ਜਗ੍ਹਾਂ ਵਰਤੋ ਜਿੱਥੇ ਇਹ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਮਦਦਗਾਰ ਹੋਵੇ (ਅਕਸਰ ਡੇਟਾਬੇਸ ਕਾਲ ਜਾਂ ਬਾਹਰੀ HTTP ਰਿਕਵੈਸਟ ਦੇ ਆਲੇ-ਦੁਆਲੇ)।
Pydantic ਨਾਲ ਡੇਟਾ ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ
ਵੈਲਿਡੇਸ਼ਨ ਬਾਹਰੀ ਦੁਨੀਆ ਅਤੇ ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਵਿਚਕਾਰ ਦਾ ਚੈੱਕਪੌଇਂਟ ਹੈ। ਜਦ API ਇਨਪੁਟ (JSON ਬਾਡੀ, ਕ્વੈਰੀ ਪੈਰਾਮ, ਪਾਥ ਪੈਰਾਮ) ਲੈਂਦੀ ਹੈ, ਤੁਸੀਂ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ ਪੂਰਾ, ਸਹੀ ਕਿਸਮ ਦਾ, ਅਤੇ ਵਾਜਿਬ ਸੀਮਾ ਵਿੱਚ ਹੈ—ਉਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖੋ, ਕਿਸੇ ਹੋਰ ਸੇਵਾ ਨੂੰ ਕਾਲ ਕਰੋ, ਜਾਂ ਬਿਜ਼ਨਸ ਲਾਜਿਕ ਚਲਾਉ।
FastAPI ਇਸ ਲਈ Pydantic ਮਾਡਲਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਵਾਰੀ ਇਹ ਦੱਸਦੇ ਹੋ ਕਿ “ਚੰਗਾ ਡੇਟਾ” ਕਿਵੇਂ ਦਿਖਦਾ ਹੈ, ਅਤੇ FastAPI ਆਟੋਮੈਟਿਕ:
- ਗਲਤ ਇਨਪੁਟ ਨੂੰ ਸ਼ੁਰੂ ਵਿੱਚ ਰੱਦ ਕਰਦਾ ਹੈ
- ਸੰਭਵ ਹੋਣ 'ਤੇ ਟਾਈਪਾਂ ਬਦਲਦਾ ਹੈ (ਉਦਾਹਰਣ ਲਈ, "42" ਨੂੰ integer ਵਿੱਚ)
- ਇੱਕਸਾਰ JSON ਰਿਸਪਾਂਸ ਵਾਪਸ ਕਰਦਾ ਹੈ (ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ)
ਗਲਤ ਇਨਪੁਟ ਨੂੰ ਸਪਸ਼ਟ ਐਰਰ ਨਾਲ ਜਲਦੀ ਫੜਨਾ
ਜੇਕਰ ਕਿਸੇ ਕਲਾਇੰਟ ਨੇ ਗਲਤ ਆਕਾਰ ਦਾ ਡੇਟਾ ਭੇਜਿਆ, FastAPI 422 Unprocessable Entity ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸੰਰਚਿਤ ਐਰਰ ਪੇਲੋਡ ਜੋ ਮੁੱਖ ਫੀਲਡ ਅਤੇ ਕਾਰਨ ਦੱਸਦਾ ਹੈ। ਇਹ ਕਲਾਇੰਟ ਡਿਵੈਲਪਰਾਂ ਲਈ ਅਸਾਨ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਉਹ ਰਿਕਵੈਸਟ ਤੇਜ਼ੀ ਨਾਲ ਠੀਕ ਕਰ ਸਕਣ।
ਆਮ ਵੈਲਿਡੇਸ਼ਨ ਉਦਾਹਰਣ
ਇੱਕ ਛੋਟਾ ਮਾਡਲ ਦਿਖਾਉਂਦਾ ਹੈ ਲੋੜੀਂਦੇ ਫੀਲਡ, ਟਾਈਪਾਂ, min/max ਬੰਧਨ, ਅਤੇ ਫਾਰਮੈਟ:
from pydantic import BaseModel, EmailStr, Field
class UserCreate(BaseModel):
email: EmailStr
age: int = Field(ge=13, le=120)
username: str = Field(min_length=3, max_length=20)
- ਲੋੜੀਂਦੇ ਫੀਲਡ:
emailਹਾਜ਼ਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। - ਟਾਈਪਾਂ:
ageਇੱਕ integer ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। - min/max:
age13–120 ਤੱਕ ਸੀਮਿਤ ਹੈ। - ਫਾਰਮੈਟ:
EmailStrਇੱਕ ਵਿਧੀਬੱਧ ਈਮੇਲ ਆਕਾਰ ਲਾਗੂ ਕਰਦਾ ਹੈ।
ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ: ਸਾਫ਼, ਉਮੀਦਯੋਗ JSON ਵਾਪਸ ਕਰਨਾ
ਇਹੀ ਮਾਡਲ ਆਉਟਪੁਟ ਨੂੰ ਵੀ ਆਕਾਰ ਦੇ ਸਕਦੇ ਹਨ, ਤਾਂ ਜੋ ਤੁਹਾਡੇ API ਜਵਾਬ ਅੰਦਰੂਨੀ ਫੀਲਡਾਂ ਦੀ ਰੋਕਥਾਮ ਨਾ ਕਰਨ। ਤੁਸੀਂ Python objects ਵਾਪਸ ਕਰੋ; FastAPI (Pydantic ਰਾਹੀਂ) ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਫੀਲਡ ਨਾਂ ਅਤੇ ਟਾਈਪਾਂ ਨਾਲ JSON ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ।
ਆਟੋਮੈਟਿਕ API ਡੌਕਸ: OpenAPI, Swagger UI, ReDoc
Prototype on the free tier
Prototype an MVP backend, then upgrade only if you need more capacity.
FastAPI ਦੀ ਸਭ ਤੋਂ ਪ੍ਰਯੋਗਕ feature ਇਹ ਹੈ ਕਿ ਇਹ ਤੁਹਾਡੇ ਲਿਖੇ ਕੋਡ ਦੇ ਆਧਾਰ 'ਤੇ API ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਆਪਣੇ ਆਪ ਤਿਆਰ ਕਰ ਦਿੰਦਾ ਹੈ।
OpenAPI: ਮਸ਼ੀਨ-ਰਿਪੈਂਡੇਬਲ API ਕਾਂਟ੍ਰੈਕਟ
OpenAPI ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਹੈ API ਨੂੰ ਸੰਰਚਿਤ ਫਾਰਮੈਟ (ਆਮ ਤੌਰ 'ਤੇ JSON) ਵਿੱਚ ਵਰਣਨ ਕਰਨ ਦੀ। ਇਸਨੂੰ ਇੱਕ "ਕਾਂਟ੍ਰੈਕਟ" ਸਮਝੋ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ:
- ਕਿਹੜੇ endpoints ਮੌਜੂਦ ਹਨ (ਜਿਵੇਂ
GET /users/{id}) - ਉਹ ਕਿਹੜੇ ਪੈਰਾਮ ਸਵੀਕਾਰਦੇ ਹਨ
- request body ਕਿਵੇਂ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ
- ਉਮੀਦਯੋਗ responses ਅਤੇ ਐਰਰ ਫਾਰਮੈਟ ਕੀ ਹਨ
ਕਿਉਂਕਿ ਇਹ ਮਸ਼ੀਨ-ਪਠਣਯੋਗ ਹੈ, ਟੂਲ ਇਸਨੂੰ ਟੈਸਟ ਕਲਾਇੰਟ ਬਣਾਉਣ, ਰਿਕਵੈਸਟ ਵੈਲਿਡੇਟ ਕਰਨ, ਅਤੇ ਟੀਮਾਂ ਨੂੰ ਸਿੰਗ ਕਰਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹਨ।
Swagger UI ਅਤੇ ReDoc: ਬਿਨਾਂ ਕੰਮ ਦੇ ਇੰਟਰਐਕਟਿਵ ਡੌਕਸ
FastAPI ਦੋ ਮਨੁੱਖ-ਫਰੈਂਡਲੀ ਡੌਕ ਪੇਜ਼ ਆਪਣੇ ਆਪ ਸਰਵ ਕਰਦਾ ਹੈ:
- Swagger UI (ਇੰਟਰਐਕਟਿਵ): ਬਰਾਉਜ਼ਰ ਵਿੱਚ ਸਿੱਧਾ endpoints ਟਰਾਈ ਕਰੋ, ਪੈਰਾਮ ਪਿਰੋ, ਰਿਕਵੈਸਟ ਭੇਜੋ, ਅਤੇ ਜਵਾਬ ਦੇਖੋ।
- ReDoc (ਰੀਡੇਬਲ): ਇੱਕ ਸਾਫ਼, ਰੈਫਰੈਂਸ-ਸਟਾਈਲ ਡੌਕਸ ਪੇਜ਼।
ਆਮ FastAPI ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ /docs ਅਤੇ /redoc 'ਤੇ ਲੱਭ ਸਕਦੇ ਹੋ।
ਡੌਕਸ ਜੋ ਕੋਡ ਨਾਲ ਸਿੰਕ ਵਿੱਚ ਰਹਿਣ
ਜਦ ਤੁਸੀਂ ਆਪਣੀਆਂ ਪਾਥ ਪੈਰਾਮ, request models, response models, ਜਾਂ ਵੈਲਿਡੇਸ਼ਨ ਨਿਯਮ ਬਦਲਦੇ ਹੋ, OpenAPI ਸਕੀਮਾ (ਅਤੇ ਡੌਕਸ ਪੇਜ਼) ਆਟੋਮੈਟਿਕ ਅਪਡੇਟ ਹੋ ਜਾਂਦੇ ਹਨ। ਕੋਈ ਵੱਖਰੀ “ਡੌਕਸ ਸੰਭਾਲਣ” ਕਦਮ ਲੈਣ ਦੀ ਲੋੜ ਨਹੀਂ।
ਇਹ ਫਰੰਟਐਂਡ ਅਤੇ QA ਕੰਮ ਨੂੰ ਤੇਜ਼ ਕਿਉਂ ਬਣਾਉਂਦਾ ਹੈ
- ਫਰੰਟਐਂਡ ਡਿਵੈਲਪਰ ਤੁਰੰਤ endpoints ਐਕਸਪਲੋਰ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਲੋੜੀਂਦੇ ਫੀਲਡ ਬਿਨਾਂ ਕਿਸੇ ਸਪੈਸ਼ਲ ਸਪੈੱਕ ਦੀ ਉਡੀਕ ਦੇ ਦੇਖ ਸਕਦੇ ਹਨ।
- QA ਤੇਜ਼ੀ ਨਾਲ ਐਜ ਕੇਸ ਟੈਸਟ ਕਰ ਸਕਦਾ ਹੈ (ਗਾਇਬ ਫੀਲਡ, ਗਲਤ ਟਾਈਪ) ਅਤੇ ਸਹੀ ਐਰਰ ਜਵਾਬ ਦੇਖ ਸਕਦਾ ਹੈ।
- ਹਰ ਕੋਈ ਇੱਕੋ ਸ੍ਰੋਤ-ਸੱਚਾਈ ਵਰਤਦਾ ਹੈ: ਚੱਲਦੀ API ਅਤੇ ਇਸਦਾ OpenAPI ਕਾਂਟ੍ਰੈਕਟ।
ਤੁਹਾਡੀ ਪਹਿਲੀ FastAPI ਐਪ (ਧਾਰਣਾਤਮਕ ਵਾਕ-ਥਰੂ)
ਇੱਕ FastAPI ਐਪ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ ਫਿਰ ਵੀ “ਅਸਲੀ” ਮਹਿਸੂਸ ਕਰਵਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਇਕ Python object app ਬਣਾਉਂਦੇ ਹੋ, ਕੁਝ ਰੂਟ ਜੋੜਦੇ ਹੋ, ਅਤੇ ਲੋਕਲ ਸਰਵਰ ਚਲਾਕੇ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਟ੍ਰਾਈ ਕਰਦੇ ਹੋ।
1) ਇੱਕ ਨ್ಯೂਨਿਕ “hello” endpoint
ਸਭ ਤੋਂ ਛੋਟਾ ਉਪਯੋਗੀ ਉਦਾਹਰਣ:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI"}
ਇੱਥੇ: ਇੱਕ ਰੂਟ (GET /) ਜੋ JSON ਵਾਪਸ ਕਰਦਾ ਹੈ।
2) ਸਾਦੇ create/read item endpoints (in-memory)
ਇਸਨੂੰ ਇੱਕ API ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਨ ਲਈ, ਆਓ items ਨੂੰ ਇੱਕ ਲਿਸਟ ਵਿੱਚ ਸਟੋਰ ਕਰੀਏ। ਇਹ ਡੇਟਾਬੇਸ ਨਹੀਂ ਹੈ—ਸਰਵਰ ਰੀਸਟਾਰਟ ਹੋਣ 'ਤੇ ਡੇਟਾ ਰੀਸੈਟ ਹੋ ਜਾਵੇਗਾ—ਪਰ ਸਿੱਖਣ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹੈ।
from fastapi import FastAPI
app = FastAPI()
items = []
@app.post("/items")
def create_item(name: str):
item = {"id": len(items) + 1, "name": name}
items.append(item)
return item
@app.get("/items")
def list_items():
return items
ਹੁਣ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ:
POST /items?name=Coffeeਨਾਲ ਇਕ ਆਈਟਮ ਜੋੜੋGET /itemsਨਾਲ ਲਿਸਟ ਪਾਉ
3) ਆਮ ਛੋਟਾ ਪ੍ਰੋਜੈਕਟ ਲੇਆਊਟ
ਆਮ ਸਟਾਰਟਰ ਢਾਂਚਾ:
main.py(ਜਿੱਥੇappਅਤੇ routes ਬਣਦੇ ਹਨ)requirements.txtਜਾਂpyproject.toml(ਨਿਭਰਤਾਵਾਂ)
4) ਲੋਕਲ ਤੌਰ 'ਤੇ ਚਲਾਉਣਾ (ਧਾਰਣਾਤਮਕ)
ਆਮ ਤੌਰ 'ਤੇ ਤੁਸੀਂ:
- ਨਿਭਰਤਾਵਾਂ ਇੰਸਟਾਲ ਕਰੋ (FastAPI + ਇੱਕ ASGI ਸਰਵਰ ਜਿਵੇਂ Uvicorn)
- ਡੈਵ ਸਰਵਰ ਚਲਾਓ (ਉਦਾਹਰਣ:
uvicorn main:app --reload) - ਆਪਣੇ ਬਰਾਊਜ਼ਰ ਵਿੱਚ
http://127.0.0.1:8000ਖੋਲ੍ਹੋ ਅਤੇ endpoints ਟ੍ਰਾਈ ਕਰੋ
Dependencies ਅਤੇ ਦੁਬਾਰਾ ਵਰਤਣ ਯੋਗਬਲਾਕ
FastAPI "dependencies" ਉਹ ਸਾਂਝੇ ਇਨਪੁਟ ਹਨ ਜੋ ਤੁਹਾਡੇ endpoints ਨੂੰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਚਾਹੀਦੇ ਹਨ—ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ, ਮੌਜੂਦਾ ਲੌਗਿਨ ਯੂਜ਼ਰ, ਐਪ ਸੈਟਿੰਗਜ਼, ਜਾਂ ਆਮ query ਪੈਰਾਮ। ਹਰ ਰੂਟ ਵਿੱਚ ਇਹਨਾਂ ਨੂੰ ਹਥਿਆਉਣ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਇਕ ਵਾਰੀ ਐਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਅਤੇ FastAPI ਜਿੱਥੇ ਲੋੜ ਹੋਏ ਉਥੇ ਇਹ ਪੈਸ ਕਰ ਦਿੰਦਾ ਹੈ।
dependency ਕੀ ਹੁੰਦੀ ਹੈ (ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ)
ਇੱਕ dependency ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ (ਜਾਂ ਕਲਾਸ) ਹੁੰਦੀ ਹੈ ਜੋ ਤੁਹਾਡੇ endpoint ਲਈ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ। FastAPI ਇਹਨੂੰ ਤੁਹਾਡੇ ਲਈ ਕਾਲ ਕਰੇਗਾ, ਇਸਦੇ ਪੈਰਾਮ ਦੇ ਆਧਾਰ ਤੇ ਵੀ ਜੋ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਨਤੀਜਾ ਤੁਹਾਡੇ path operation ਫੰਕਸ਼ਨ ਵਿੱਚ inject ਕਰ ਦੇਵੇਗਾ।
ਇਸਨੂੰ dependency injection ਕਹਿੰਦੇ ਹਨ, ਪਰ ਤੁਸੀਂ ਇਸਨੂੰ ਐਸਾ ਸੋਚ ਸਕਦੇ ਹੋ: “ਜੋ ਤੁਸੀਂ ਚਾਹੀਦਾ ਹੈ ਉਸਨੂੰ ਘੋਸ਼ਣਾ ਕਰੋ, ਅਤੇ FastAPI ਉਸਨੂੰ ਜੋੜ ਦੇਵੇਗਾ।”
ਇਹ ਦੁਹਰਾਉ ਨੂੰ ਕਿਵੇਂ ਘਟਾਉਂਦਾ ਹੈ
ਬਿਨਾਂ dependencies ਦੇ, ਤੁਸੀਂ ਸ਼ਾਇਦ:
- ਹਰ endpoint ਵਿੱਚ ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਖੋਲ੍ਹਣ/ਬੰਦ ਕਰਨ
- ਹਰ ਥਾਂ authentication checks ਦੀ ਨਕਲ ਕਰਨੀ
- ਇੱਕੋ ਹੀ pagination ਪੈਰਾਮ ਦੇ ਪਰਸਿੰਗ ਨੂੰ ਕਈ ਰੂਟਾਂ 'ਚ ਦੁਹਰਾਉਣਾ
Dependencies ਨਾਲ, ਤੁਸੀਂ ਉਹ ਲੋジਿਕ ਕੇਂਦਰਿਤ ਕਰ ਲੈਂਦੇ ਹੋ। ਜੇ ਬਾਅਦ ਵਿੱਚ ਤੁਸੀਂ ਡੀਬੀ ਸੈਸ਼ਨ ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ ਬਦਲਦੇ ਹੋ ਜਾਂ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਲੋਡ ਕਰਨ ਦਾ ਤਰੀਕਾ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਥਾਂ 'ਤੇ ਅਪਡੇਟ ਕਰੋ—ਨਾ ਕਿ ਦਰਜਨਾਂ endpoints 'ਚ।
ਆਮ dependency ਉਦਾਹਰਣ
- ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ: ਪ੍ਰਤੀ ਰਿਕਵੈਸਟ ਇੱਕ ਸੈਸ਼ਨ ਬਣਾਉਣਾ ਅਤੇ ਉਸਨੂੰ ਯਕੀਨੀ ਤੌਰ ਅੰਤ ਤੇ ਬੰਦ ਕਰਨਾ।
- ਸੈਟਿੰਗਜ਼/ਕਨਫ਼ਿਗ: environment-ਅਧਾਰਿਤ ਸੈਟਿੰਗਜ਼ ਬਿਨਾਂ ਹੱਥੋਂ-ਹੱਥ ਪਾਸ ਕਰਨ ਦੇ ਉਪਲਬਧ ਕਰਾਉਣਾ।
- ਪੇਜੀਨੇਸ਼ਨ:
page/limitਦੀ parsing ਅਤੇ validation ਦੁਬਾਰਾ ਵਰਤਣਾ। - Auth user: ਟੋਕਨ ਤੋਂ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਲੈਣਾ ਅਤੇ permissions ਲਾਗੂ ਕਰਨਾ।
dependencies endpoints ਵਿੱਚ ਕਿਵੇਂ ਲੱਗਦੀਆਂ ਹਨ
ਇੱਥੇ ਇੱਕ ਧਾਰਣਾਤਮਕ ਪੈਟਰਨ ਹੈ ਜੋ ਬਹੁਤ FastAPI ਐਪਾਂ ਵਿੱਚ ਦਿੱਖਦਾ ਹੈ:
from fastapi import Depends, FastAPI
app = FastAPI()
def get_settings():
return {"items_per_page": 20}
@app.get("/items")
def list_items(settings=Depends(get_settings)):
return {"limit": settings["items_per_page"]}
ਤੁਸੀਂ Depends(...) ਨਾਲ dependency ਘੋਸ਼ਣਾ ਕਰਦੇ ਹੋ, ਅਤੇ FastAPI ਉਸਦਾ ਨਤੀਜਾ ਤੁਹਾਡੇ endpoint parameter ਵਿੱਚ ਪਾਸ ਕਰਦਾ ਹੈ। ਇਹੀ ਤਰੀਕਾ ਹੋਰ ਜਟਿਲ ਬਿਲਡਿੰਗ ਬਲੌਕਾਂ (ਜਿਵੇਂ get_db() ਜਾਂ get_current_user()) ਲਈ ਵੀ ਕੰਮ ਕਰਦੀ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਵੱਧ ਸਾਫ਼ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਜਦ ਤੁਹਾਡੀ API ਵਧਦੀ ਹੈ।
ਸੁਰੱਖਿਆ ਬੁਨਿਆਦੀਆਂ: ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਅਧਿਕਾਰ
FastAPI ਆਪਣੀ ਰੂਪ ਵਿੱਚ ਤੁਹਾਡੀ API ਨੂੰ "ਆਟੋਮੈਟਿਕ ਸੁਰੱਖਿਅਤ" ਨਹੀਂ ਕਰਦਾ—ਤੁਸੀਂ ਸਕੀਮ ਚੁਣਦੇ ਹੋ ਅਤੇ ਉਹਨੂੰ endpoints ਵਿੱਚ ਲਗਾਉਂਦੇ ਹੋ। ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ FastAPI ਡਿਪੈਂਡੇਨਸੀ ਸਰਗਰਮੀ ਰਾਹੀਂ ਆਮ ਸੁਰੱਖਿਆ ਪੈਟਰਨਾਂ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
authentication vs. authorization
Authentication ਸਵਾਲ ਕਰਦਾ ਹੈ: “ਤੁਸੀਂ ਕੌਣ ਹੋ?” Authorization ਸਵਾਲ ਕਰਦਾ ਹੈ: “ਤੁਹਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਆਗਿਆ ਹੈ?”
ਉਦਾਹਰਣ: ਇੱਕ ਯੂਜ਼ਰ authenticated ਹੋ ਸਕਦਾ ਹੈ (ਸਹੀ login/token) ਪਰ ਫਿਰ ਵੀ ਇਕ admin-ਕੇਵਲ route ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੋ ਸਕਦੀ।
ਆਮ authentication ਤਰੀਕੇ (ਉੱਚ-ਸਤਹ)
- API keys: ਸਰਵਿਸ-ਟੂ-ਸਰਵਿਸ ਐਕਸੈੱਸ ਲਈ ਸਧਾਰਨ। ਆਮ ਤੌਰ 'ਤੇ ਹੈਡਰ ਰਾਹੀਂ ਭੇਜੇ ਜਾਂਦੇ ਹਨ (ਜਿਵੇਂ
X-API-Key)। ਰੋਟੇਸ਼ਨ ਅਤੇ ਰਿਵੋਕੇਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧ ਕਰੋ। - OAuth2: delegated access ਲਈ ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ; “Sign in with …” ਜਾਂ auth ਨੂੰ API ਤੋਂ ਅਲੱਗ ਕਰਨ ਲਈ ਆਮ।
- JWT (JSON Web Tokens): ਬੀਅਰਰ ਟੋਕਨ ਵਜੋਂ ਅਕਸਰ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। stateless APIs ਲਈ ਆਸਾਨ, ਪਰ expiry, signing keys, ਅਤੇ ਰਿਵੋਕੇਸ਼ਨ ਰਣਨੀਤੀ ਦਾ ਧਿਆਨ ਰੱਖੋ।
FastAPI ਇਹ ਪੈਟਰਨ fastapi.security ਵਰਗੇ ਯੂਟਿਲਿਟੀਜ਼ ਰਾਹੀਂ ਸਹਿਯੋਗ ਕਰਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ OpenAPI ਵਿੱਚ ਸਾਫ਼ ਦਰਸਾਉਂਦਾ ਹੈ।
ਪਾਸਵਰਡ ਹੈਂਡਲਿੰਗ ਬੁਨਿਆਦੀ ਗੱਲਾਂ
ਜੇ ਤੁਸੀਂ ਯੂਜ਼ਰ ਪਾਸਵਰਡ ਸਟੋਰ ਕਰਦੇ ਹੋ, ਤਾਂ ਕਦੇ ਵੀ plain text ਨਾ ਸਟੋਰ ਕਰੋ। ਇੱਕ salted, slow hash (ਜਿਵੇਂ bcrypt/argon2 ਕਿਸੇ ਮਸ਼ਹੂਰ ਲਾਇਬ੍ਰੇਰੀ ਰਾਹੀਂ) ਸਟੋਰ ਕਰੋ। ਇਸਦੇ ਨਾਲ rate limiting ਅਤੇ account lockout ਨੀਤੀਆਂ ਬਾਰੇ ਵੀ ਸੋਚੋ।
ਧਿਆਨ ਯੋਗ ਨੋਟ
ਸੁਰੱਖਿਆ ਵਿਸਥਾਰਵਾਦੀ ਗੱਲ ਹੈ: token storage, CORS ਸੈਟਿੰਗ, HTTPS, secret management, ਅਤੇ ਹਰ ਸੰਵੇਦਨਸ਼ੀਲ endpoint 'ਤੇ ਸਹੀ authorization checks। ਬਿਲਟ-ਇਨ ਸਹਾਇਕਾਂ ਨੂੰ ਸ਼ੁਰੂਆਤ ਸਮੱਗਰੀ ਵਜੋਂ ਲਓ, ਅਤੇ production 'ਤੇ ਇਨ੍ਹਾਂ ਨੂੰ ਆਖਰੀ ਤੌਰ 'ਤੇ ਸਮੀਖਿਆ ਅਤੇ ਟੈਸਟ ਕਰੋ।
FastAPI ਐਪ ਦੀ ਟੈਸਟਿੰਗ
Get clean API structure fast
Create a backend with clear request and response shapes without writing boilerplate by hand.
ਟੈਸਟਿੰਗ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ FastAPI ਦਾ “ਮੇਰੇ ਮਸ਼ੀਨ ਤੇ ਚੱਲਦਾ ਹੈ” ਵਾਅਦਾ ਤੁਹਾਨੂੰ ਭਰੋਸਾ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ship ਕਰ ਸਕਦੇ ਹੋ। ਚੰਗੀ ਖ਼ਬਰ: FastAPI Starlette 'ਤੇ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਬਹੁਤ ਘੱਟ ਸੈਟਅਪ ਵਿੱਚ ਮਜ਼ਬੂਤ ਟੈਸਟਿੰਗ ਟੂਲ ਮਿਲਦੇ ਹਨ।
ਯੂਨਿਟ ਟੈਸਟ vs. ਇੰਟਿਗਰੇਸ਼ਨ ਟੈਸਟ
Unit tests ਛੋਟੇ ਹਿੱਸਿਆਂ 'ਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹਨ: ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਇੱਕ ਕੀਮਤ ਗਣਨ ਕਰਦਾ ਹੈ, ਇੱਕ dependency ਜੋ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਲੋਡ ਕਰਦਾ ਹੈ, ਜਾਂ ਇੱਕ ਸਰਵਿਸ ਮੈਥਡ ਜੋ ਡੇਟਾਬੇਸ ਨਾਲ ਗੱਲ ਕਰਦਾ ਹੈ (ਅਕਸਰ mocked)।
Integration tests API ਨੂੰ end-to-end ਅੰਜਾਮ ਦਿੰਦੇ ਹਨ: ਤੁਸੀਂ ਇੱਕ endpoint ਕਾਲ ਕਰਦੇ ਹੋ ਅਤੇ ਪੂਰੇ HTTP ਜਵਾਬ 'ਤੇ assert ਕਰਦੇ ਹੋ। ਇਹ ਉਹ ਟੈਸਟ ਹਨ ਜੋ routing ਗਲਤੀਆਂ, dependency wiring ਮੁੱਦਿਆਂ, ਅਤੇ validation ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਫੜਦੇ ਹਨ।
ਇੱਕ ਸਿਹਤਮੰਦ ਟੈਸਟ ਸੂਟ ਆਮ ਤੌਰ 'ਤੇ ਵੱਧ unit tests (ਤੇਜ਼) ਅਤੇ ਘੱਟ integration tests (ਉੱਚ ਭਰੋਸਾ) ਰੱਖਦਾ ਹੈ।
TestClient ਵਿਚਾਰ
FastAPI ਐਪਾਂ ਨੂੰ Starlette ਦੇ TestClient ਨਾਲ “ਇੱਕ ਕਲਾਇੰਟ ਵਾਂਗ” ਟੈਸਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਐਪ ਨੂੰ ਪ੍ਰੋਸੈੱਸ-ਅੰਦਰ ਕੌਲ ਕਰਦਾ ਹੈ—ਕੋਈ ਸਰਵਰ ਲੋੜ ਨਹੀਂ।
from fastapi.testclient import TestClient
from app.main import app
client = TestClient(app)
def test_healthcheck():
r = client.get("/health")
assert r.status_code == 200
ਕੀ ਟੈਸਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਅਮਲੀ ਚੈਕਲਿਸਟ)
ਟੈਸਟ ਉਹ ਚੀਜ਼ਾਂ ਜਿਨ੍ਹਾਂ 'ਤੇ ਯੂਜ਼ਰ ਅਤੇ ਹੋਰ ਸਿਸਟਮ ਨਿਰਭਰ ਹਨ:
- Status codes (200 vs 201 vs 404 vs 422)
- Validation errors (ਗਾਇਬ ਫੀਲਡ, ਗਲਤ ਟਾਈਪ, ਅਤਿਰਿਕਤ ਫੀਲਡ)
- Response shape (ਕੀਹਾਂ ਮੌਜੂਦ ਹਨ, ਟਾਈਪ ਸਹੀ ਹਨ, ਖਾਲੀ ਲਿਸਟ ਸੰਭਾਲੀ ਗਈ)
- Edge cases (ਜ਼ੀਰੋ ਨਤੀਜੇ, ਵੱਡਾ ਇਨਪੁੱਟ, ਬਾਰਡੀਰੀਆਂ ਤਾਰੀਖਾਂ)
- Auth cases (ਟੋਕਨ ਨਹੀਂ, ਮਿਆਦ ਪੂਰੀ ਟੋਕਨ, ਘਟੀਆ ਰੋਲ)
ਟੈਸਟ ਤੇਜ਼ ਅਤੇ ਦੁਹਰਾਏ ਜਾਣਯੋਗ ਰੱਖੋ
ਪੇਸ਼ਗੀ ਡੇਟਾ ਵਰਤੋ, ਬਾਹਰੀ ਸੇਵਾਵਾਂ ਨੂੰ ਅਲੱਗ ਕਰੋ (mock ਜਾਂ ਟੈਸਟ DB), ਅਤੇ ਟੈਸਟਾਂ ਵਿੱਚ ਸਾਂਝੀ ਸਟੇਟ ਤੋਂ ਬਚੋ। ਤੇਜ਼ ਟੈਸਟ ਚਲਦੇ ਹਨ; ਹੌਲੇ ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ ਛੱਡੇ ਜਾਂਦੇ ਹਨ।
FastAPI ਨੂੰ ਡਿਪਲੌਇ ਕਰਨਾ: ਅਮਲੀ ਵਿਕਲਪ ਅਤੇ ਚੇਕਲਿਸਟ
FastAPI ਐਪ ਨੂੰ ਆਨਲਾਈਨ ਲਿਆਉਣਾ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਹੀ “ਰੰਨਰ” ਚੁਣਨ ਅਤੇ ਕੁਝ ਪ੍ਰੋਡਕਸ਼ਨ ਜ਼ਰੂਰੀਆਂ ਸ਼ਾਮਲ ਕਰਨ ਬਾਰੇ ਹੈ।
ਡੈਵ/ਪ੍ਰੋਡ ਸਰਵਰ
ਜਦ ਤੁਸੀਂ ਲੋਕਲ ਤੌਰ 'ਤੇ uvicorn main:app --reload ਚਲਾਉਂਦੇ ਹੋ, ਤਦ ਤੁਸੀਂ ਇੱਕ ਡੈਵ ਸੈਟਅਪ ਵਰਤ ਰਹੇ ਹੁੰਦੇ ਹੋ: auto-reload, ਡਿਬੱਗ ਇੰਫੋ, ਅਤੇ ਸੇਟਿੰਗਜ਼ ਜੋ ਸੁਵਿਧਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ।
ਪ੍ਰੋਡ ਵਿੱਚ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ Uvicorn reload ਬਿਨਾਂ ਚਲਾਉਂਦੇ ਹੋ, ਅਕਸਰ ਇੱਕ process manager (ਜਿਵੇਂ Gunicorn ਨਾਲ Uvicorn workers) ਦੇ ਪਿੱਛੇ ਜਾਂ reverse proxy ਦੇ ਨਾਲ। ਮਕਸਦ ਹੈ ਸਥਿਰਤਾ: ਕੰਟਰੋਲਡ restarts, ਭਰੋਸੇਯੋਗ ਪ੍ਰਦਰਸ਼ਨ, ਅਤੇ ਸੁਰੱਖਿਅਤ defaults।
environment variables ਨਾਲ কਨਫ਼ਿਗ
ਆਮ ਪੈਟਰਨ:
- secrets ਅਤੇ environment-ਨਿਰਧਾਰਿਤ ਮੁੱਲ (ਡੇਟਾਬੇਸ URL, API keys, allowed origins) ਨੂੰ environment variables ਵਿੱਚ ਰੱਖੋ।
- ਲੋਕਲ ਵਰਤੋਂ ਲਈ ਕੋਡ ਵਿੱਚ ਸਮਝਦਾਰ defaults ਰੱਖੋ।
- startup 'ਤੇ settings ਲੋਡ ਅਤੇ ਵੈਲਿਡੇਟ ਕਰੋ (ਅਕਸਰ Pydantic settings ਰਾਹੀਂ)।
ਇਸ ਨਾਲ ਇੱਕੋ ਕੋਡਬੇਸ ਨੂੰ ਬਿਨਾਂ ਫਾਈਲ ਐਡਿਟ ਕੀਤੇ ਕਈ environment ਵਿੱਚ deploy ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਆਮ deployment ਟਾਰਗੇਟ (ਸੰਖੇਪ)
- Containers (Docker/Kubernetes): repeatable builds ਅਤੇ scaling ਲਈ Lokpriya।
- Virtual machines: ਸਧਾਰਨ ਅਤੇ ਲਚਕੀਲੇ; ਜੇ ਤੁਸੀਂ ਆਪਣੇ ਸਰਵਰ ਖੁਦ manage ਕਰਦੇ ਹੋ ਤਾਂ ਚੰਗੇ।
- Serverless: ਛੋਟੀ APIs ਲਈ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ; cold starts ਅਤੇ platform limits 'ਤੇ ਧਿਆਨ ਰੱਖੋ।
ਪ੍ਰਾਇਕਟਿਕ ਡਿਪਲੌਇ ਚੇਕਲਿਸਟ
"ਕਰਨਯੋਗ" ਕਹਿਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਓ:
- Logging: ਸਟ੍ਰਕਚਰਡ ਲੌਗ, request IDs (ਜੇ ਲੋੜ), ਅਤੇ environment-ਅਨੁਸਾਰ log levels।
- Health checks:
/healthਵਰਗੇ endpoints uptime ਮੋਨੀਟਰਿੰਗ ਅਤੇ load balancers ਲਈ। - Error handling: ਇੱਕਸਾਰ JSON ਐਰਰ ਜਵਾਬ; ਉਪਭੋਗਤਿਆਂ ਨੂੰ stack traces ਨਾ ਦਿਖਾਓ।
- Timeouts and limits: request body size, worker timeouts, ਅਤੇ rate limiting ਜਿੱਥੇ ਜਰੂਰੀ।
- Docs policy: ਫੈਸਲਾ ਕਰੋ ਕਿ Swagger UI/ReDoc ਨੂੰ ਜਨਤਕ ਤੌਰ 'ਤੇ ਖੁੱਲ੍ਹਾ ਰੱਖਣਾ ਹੈ ਜਾਂ ਸੀਮਤ ਕਰਨਾ ਹੈ।
ਜੇ ਤੁਸੀਂ "ਲੋਕਲ ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ" ਤੋਂ "ਸ਼ਿੱਪਬਲ" ਵੱਲ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ API contract ਨੂੰ ਜਨਰੇਟ ਅਤੇ ਮੈਨੇਜ ਕਰਨ ਦਾ ਇੱਕ standardized ਤਰੀਕਾ ਰੱਖਣਾ ਵੀ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ। ਕੁਝ ਟੀਮ FastAPI ਦੇ OpenAPI ਆਉਟਪੁਟ ਨੂੰ automated workflows ਨਾਲ ਜੋੜਦੀਆਂ ਹਨ—ਉਦਾਹਰਣ ਵਜੋਂ client ਜਨਰੇਟਰ ਬਣਾਉਣਾ, CI ਵਿੱਚ ਰਿਕਵੈਸਟ ਵੈਲਿਡੇਸ਼ਨ ਕਰਨਾ, ਅਤੇ ਲਗਾਤਾਰ deploy। Koder.ai ਵਰਗੇ ਟੂਲ ਵੀ ਇਸ ਚਰਨ ਨਾਲ ਮੈਚ ਕਰ ਸਕਦੇ ਹਨ: ਤੁਸੀਂ chat ਵਿੱਚ API ਵਰਨਣ ਕਰਕੇ endpoints ਤੇ ਮਾਡਲ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉ, ਫਿਰ generated ਕੋਡ ਨੂੰ ਸਧਾਰਨ review/deploy ਪਾਈਪਲਾਈਨ ਵਿੱਚ export ਕਰੋ।
ਕਦੋਂ FastAPI ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ (ਅਤੇ ਕਦੋਂ ਨਹੀਂ)
FastAPI ਉਹੋ ਸਮਾਂ ਚੰਗਾ ਚੋਣ ਹੈ ਜਦ ਤੁਸੀਂ Python ਵਿੱਚ ਇੱਕ ਸਾਫ਼, ਆਧੁਨਿਕ ਤਰੀਕੇ ਨਾਲ REST APIs ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ—ਖ਼ਾਸ ਕਰਕੇ ਜੇ ਤੁਸੀਂ ਸਪਸ਼ਟ request/response ਮਾਡਲ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵਧਣ 'ਤੇ ਭਰੋਸੇਯੋਗ ਵਿਹਾਰ ਚਾਹੁੰਦੇ ਹੋ।
ਵਧੀਆ ਵਰਤੋਂ ਕੇਸ
FastAPI ਆਮ ਤੌਰ 'ਤੇ ਇਨ੍ਹਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਚਮਕਦਾ ਹੈ:
- ਅੰਦਰੂਨੀ ਸੇਵਾਵਾਂ ਜਿੱਥੇ ਟੀਮਜ਼ ਨੂੰ ਤੇਜ਼ iteration, ਪਠਨਯੋਗ endpoints, ਅਤੇ ਸੇਵਾਵਾਂ ਦਰਮਿਆਨ ਸਾਂਝੇ ਕਾਂਟ੍ਰੈਕਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
- ਪਬਲਿਕ APIs ਜੋ ਕੜੀ ਇਨਪੁਟ ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਇੱਕਸਾਰ ਐਰਰ ਹੈਂਡਲਿੰਗ ਤੋਂ ਫ਼ਾਇਦਾ ਉਠਾਉਂਦੇ ਹਨ।
- Microservices ਜਿੱਥੇ ਛੋਟੀ, ਕੇਂਦਰਿਤ APIs ਨੂੰ ਅਲੱਗ ਤੌਰ 'ਤੇ deploy ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
- ਪ੍ਰੋਟੋਟਾਈਪ ਅਤੇ MVPs ਜਿੱਥੇ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵਧਣਾ ਚਾਹੁੰਦੇ ਹੋ ਬਿਨਾਂ ਸਟ੍ਰਕਚਰ ਖੋਣ ਦੇ (validation + docs)।
ਜਦ ਹੋਰ ਟੂਲ ਵਧੀਆ ਹੋ ਸਕਦਾ ਹੈ
FastAPI ਹਮੇਸ਼ਾਂ ਸਭ ਤੋਂ ਸੌਖਾ ਜਵਾਬ ਨਹੀਂ:
- ਜੇ ਤੁਸੀਂ ਇਕ one-off script ਜਾਂ ਇਕ ਛੋਟਾ webhook handler ਲਿਖ ਰਹੇ ਹੋ, ਤਾਂ ਕੁਝ ਹਲਕਾ ਜਾਂ ਸਿਧਾ Python ਹੀ ਕਾਫ਼ੀ ਹੋ ਸਕਦਾ ਹੈ।
- ਜੇ ਤੁਹਾਨੂੰ ਪੂਰਾ Django “batteries included” stack (ORM conventions, admin, templating, ਬੜੀ matured ecosystem) ਚਾਹੀਦਾ ਹੈ, ਤਾਂ Django ਜਾਂ Django REST Framework ਲੋਕ-ਪਸੰਦ ਵਿਕਲਪ ਹੋ ਸਕਦੇ ਹਨ।
ਪ੍ਰਦਰਸ਼ਨ ਬਾਰੇ ਹਕੀਕਤੀ ਗੱਲ
FastAPI ਅਮਲ ਵਿੱਚ ਬਹੁਤ ਤੇਜ਼ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਤੇਜ਼ੀ ਇਸਤੋਂ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਹੁੰਦੀ ਕਿ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਕਾਲ, ਨੈੱਟਵਰਕ ਲੇਟੈਂਸੀ, ਅਤੇ ਬਿਜ਼ਨਸ ਲਾਜਿਕ ਕਿਵੇਂ ਲਿਖੀਆਂ ਗਈਆਂ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ ਤੁਸੀਂ ਵਧੀਆ throughput ਅਤੇ ਚੰਗੀ latency ਦੀ ਉਮੀਦ ਰੱਖ ਸਕਦੇ ਹੋ—ਸਿਰਫ਼ ਫਰੇਮਵਰਕ ਨੂੰ ਇੱਕੱਲਾ ਜ਼ਿੰਮੇਵਾਰ ਨਾ ਠਹਿਰਾਓ ਕਿ ਉਹ slow I/O ਜਾਂ ਅਣਉਪਯੁਕਤ queries ਨੂੰ ਠੀਕ ਕਰ ਦੇਵੇ।
ਅਗਲੇ ਕਦਮ
ਜੇ FastAPI ਤੁਹਾਡੇ ਲਈ ਢੰਗ ਦਾ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਅਗਲੇ ਕੰਮ routing patterns, Pydantic ਮਾਡਲ, ਡੇਟਾਬੇਸ ਇੰਟੀਗਰੇਸ਼ਨ, ਬੈਕਗ੍ਰਾਊਂਡ ਟਾਸਕ, ਅਤੇ ਬੁਨਿਆਦੀ authentication 'ਤੇ ਧਿਆਨ ਦਿਓ।
ਇੱਕ ਅਮਲੀ ਰਾਹ ਇਹ ਹੈ ਕਿ ਇੱਕ ਛੋਟੇ endpoints ਸੈਟ ਬਣਾਓ, ਫਿਰ dependency ਅਤੇ tests ਦੇ ਨਾਲ ਵਾਪਸ ਵਧਾਓ ਜਿਵੇਂ ਤੁਹਾਡੀ API ਵਧਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਸ਼ੁਰੂਆਤੀ scaffold (routes, models, ਪਹਿਲੀ deploy-ready structure) ਤੇਜ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ planning-mode ਜਾਂ vibe-coding ਵਰਗੇ workflow ਵਰਤੋ—ਤੁਹਾਡੇ endpoints ਨੂੰ ਇੱਕ spec ਤੋਂ ਸ਼ੁਰੂ ਕਰਕੇ ਤੇਜ਼ੀ ਨਾਲ code ਜਨਰੇਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਹੁੰਦੀ ਹੈ। ਇਹੇ ਥਾਂ Koder.ai ਵਰਗੇ ਟੂਲ ਮਦਦਗਾਰ ਹੋ ਸਕਦੇ ਹਨ: chat ਤੋਂ prototype ਬਣਾਓ, generated ਕੋਡ ਨੂੰ ਸੋਧੋ, ਅਤੇ ਫਿਰ ਮਨ ਚਾਹੀ deployment ਰਾਹੀਂ export ਕਰੋ।
ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ
FastAPI ਸਾਦੇ ਸ਼ਬਦਾਂ ਵਿੱਚ ਕੀ ਹੈ?
FastAPI is a Python web framework for building APIs with minimal boilerplate. You write endpoint functions (like @app.get("/users")) and FastAPI handles routing, request parsing, validation, and JSON responses.
A key benefit is that your type hints and Pydantic models act as an explicit contract for what the API accepts and returns.
API ਕੀ ਹੁੰਦਾ ਹੈ, ਤੇ ਇਹ FastAPI ਨਾਲ ਕਿਵੇਂ ਜੁੜਦਾ ਹੈ?
An API is a set of URLs (endpoints) that other software can call to exchange data.
For example, a client might request weather data with GET /weather?city=Berlin, and the server responds with structured JSON. The client doesn’t need direct database access—it just uses the API response.
FastAPI ਵਿੱਚ ਰੂਟਸ ਅਤੇ HTTP ਮੈਥਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?
Routing maps an HTTP method + path to a Python function.
In FastAPI you typically use decorators:
@app.get("/items")for read operations@app.post("/items")for create operations@app.put("/items/{id}")to update/replace- to remove
Path parameters ਅਤੇ query parameters ਵਿੱਚ ਕੀ ਫਰਕ ਹੈ?
Path parameters are part of the URL structure and usually identify a specific resource (required).
- Path:
GET /users/42→42is a path parameter
Query parameters are appended after ? and are usually optional filters or controls.
FastAPI Pydantic ਨਾਲ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਵੈਲਿਡੇਟ ਕਰਦਾ ਹੈ?
Pydantic models define the shape and rules of your data (types, required fields, constraints). FastAPI uses them to:
- Validate incoming requests
- Coerce types when possible (e.g., string to int)
- Return consistent, well-shaped JSON responses
If validation fails, FastAPI typically responds with 422 Unprocessable Entity and details about which field is wrong.
FastAPI ਆਟੋਮੈਟਿਕ API ਦਸਤੀavez ਬਨਾਉਂਦਾ ਹੈ ਕਿਵੇਂ?
FastAPI automatically generates an OpenAPI schema from your endpoints, type hints, and models.
You usually get interactive docs for free:
- Swagger UI at
/docs - ReDoc at
/redoc
Because the schema is derived from code, the docs stay in sync as you change parameters and models.
FastAPI ਵਿੱਚ async endpoints ਕਦੋਂ ਵਰਤਣੇ ਚਾਹੀਦੇ ਹਨ?
Use async def when your endpoint spends time waiting on I/O (database calls, external HTTP requests, file/object storage).
Use regular def when:
- The code is simple and synchronous
- You’re calling libraries that don’t support async
- Work is mostly CPU-bound (async won’t speed up computation)
Mixing sync and async endpoints in the same app is common.
FastAPI ਡਿਪੇਂਡੈਂਸੀਜ਼ ਕੀ ਹਨ ਤੇ ਇਹ ਫਾਇਦੇਮੰਦ ਕਿਉਂ ਹਨ?
Dependencies are reusable “building blocks” that FastAPI injects into endpoints via Depends().
They’re commonly used for:
- Database session per request
- Auth: loading the current user and enforcing permissions
- Shared query parsing (pagination, filters)
- App settings/config
This reduces repetition and centralizes cross-cutting logic so changes happen in one place.
FastAPI API ਬਣਾਉਂਦੇ ਸਮੇਂ ਮੈਂ ਸੁਰੱਖਿਆ ਦੇ ਬੁਨਿਆਦੀ ਨੁਕਤੇ ਕੀ ਜਾਣਨ ਚਾਹੀਦੇ ਹਨ?
FastAPI doesn’t secure your API by default—you choose an approach and apply it consistently.
Common patterns include:
- API keys (often via headers)
- OAuth2 flows
- Bearer tokens (commonly JWT)
Also remember the basics:
ਮੈਂ FastAPI ਐਪ ਦੀ ਟੈਸਟਿੰਗ ਅਤੇ ਡਿਪਲੌਇਮੈਂਟ ਕਿਵੇਂ ਕਰਾਂ?
For testing, you can use FastAPI/Starlette’s TestClient to call your API in-process (no server required).
Practical items to assert:
- Status codes (200/201/404/422)
- Validation behavior (missing fields, wrong types)
- Response shapes (fields present, correct types)
- Auth scenarios (no token, expired token, insufficient role)
For deployment, run an ASGI server (often Uvicorn; sometimes behind Gunicorn or a reverse proxy) and add production essentials like logging, health checks (e.g., ), timeouts, and environment-based configuration.