08 ਸਤੰ 2025·8 ਮਿੰਟ
FastAPI ਕੀ ਹੈ? APIs ਬਣਾਉਣ ਲਈ ਇੱਕ ਅਮਲੀ ਗਾਈਡ
FastAPI ਇੱਕ ਆਧੁਨਿਕ Python ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਟਾਈਪ ਹਿੰਟ, ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਆਟੋਮੈਟਿਕ OpenAPI ਡੌਕਸ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ APIs ਬਣਾਉਂਦਾ ਹੈ। ਮੁੱਢਲੀ ਗੱਲਾਂ ਅਤੇ ਵਰਤੋਂ ਸਿੱਖੋ।
FastAPI ਇੱਕ ਆਧੁਨਿਕ Python ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਟਾਈਪ ਹਿੰਟ, ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਆਟੋਮੈਟਿਕ OpenAPI ਡੌਕਸ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ APIs ਬਣਾਉਂਦਾ ਹੈ। ਮੁੱਢਲੀ ਗੱਲਾਂ ਅਤੇ ਵਰਤੋਂ ਸਿੱਖੋ।
FastAPI ਇਕ Python ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਤੇਜ਼ੀ ਨਾਲ ਵੈੱਬ APIs ਬਣਾਉਂਦਾ ਹੈ, ਸਾਫ਼ ਕੋਡ ਅਤੇ ਆਟੋਮੈਟਿਕ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਨਾਲ। ਤੁਸੀਂ ਛੋਟੀਆਂ ਫੰਕਸ਼ਨ ਲਿਖਦੇ ਹੋ (ਜਿਨ੍ਹਾਂ ਨੂੰ “endpoints” ਕਹਿੰਦੇ ਹਨ) ਜੋ ਘੋਸ਼ਣਾ ਕਰਦੀਆਂ ਹਨ ਕਿ ਤੁਹਾਡੀ API ਕਿਹੜਾ ਡੇਟਾ ਲੈਂਦੀ ਹੈ ਅਤੇ ਕੀ ਵਾਪਸ ਕਰਦੀ ਹੈ, ਅਤੇ FastAPI ਵੈੱਬ ਦੇ ਜੀਵਨ ਚੱਕਰ—ਰੂਟਿੰਗ, ਵੈਲਿਡੇਸ਼ਨ, ਅਤੇ JSON ਜਵਾਬ—ਹੈਂਡਲ ਕਰ ਲੈਂਦਾ ਹੈ।
API URLs ਦਾ ਇਕ ਸੈੱਟ ਹੁੰਦਾ ਹੈ ਜੋ ਇਕ ਸਾਫਟਵੇਅਰ ਨੂੰ ਦੂਜੇ ਨਾਲ ਗੱਲ ਕਰਨ ਦਿੰਦਾ ਹੈ।
ਉਦਾਹਰਣ ਵਜੋਂ, ਤੁਹਾਡੇ ਫ਼ੋਨ ਦੀ ਮੌਸਮ ਐਪ GET /weather?city=Berlin ਵਰਗਾ URL ਕਾਲ ਕਰ ਸਕਦੀ ਹੈ। ਸਰਵਰ ਸੰਰਚਿਤ ਡੇਟਾ (ਅਤਿ ਸ਼ਾਮਿਲ ਤੌਰ 'ਤੇ JSON) ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਤਾਪਮਾਨ ਅਤੇ ਫੋਰਕਾਸਟ। ਫ਼ੋਨ ਐਪ ਨੂੰ ਸਰਵਰ ਦੇ ਡੈਟਾਬੇਸ ਤੱਕ ਸਿੱਧੀ ਪਹੁੰਚ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ—ਉਹ ਸਿਰਫ API ਨੂੰ ਪੁੱਛਦੀ ਹੈ ਅਤੇ ਨਤੀਜਾ ਦਿਖਾਉਂਦੀ ਹੈ।
FastAPI ਤੁਹਾਨੂੰ ਉਹ URLs ਅਤੇ ਜਵਾਬ Python ਵਿੱਚ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
ਤੁਹਾਨੂੰ async ਦੀ ਪੂਰਨ ਮਹਿਰਤ ਦੀ ਲੋੜ ਨਹੀਂ—ਤੁਸੀਂ ਸਧਾਰਨ endpoints ਲਿਖ ਕੇ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਜਿਵੇਂ-ਜਿਵੇਂ ਆਪ ਵਧਦੇ ਹੋਆਂ, ਅਡਵਾਂਸ ਪੈਟਰਨ ਅਪਣਾ ਸਕਦੇ ਹੋ।
FastAPI ਤੇਜ਼ੀ ਨਾਲ ਲੋਕਪ੍ਰਿਯ ਹੋਇਆ ਕਿਉਂਕਿ ਇਹ ਉਹਨਾਂ ਆਮ ਰੁਕਾਵਟਾਂ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ ਜੋ ਲੋਕ Python ਵਿੱਚ APIs ਬਣਾਉਂਦੇ ਸਮੇਂ ਮਹਿਲਾਂ ਚੁੱਕਦੇ ਹਨ।
ਰਵਾਇਤੀ API ਪ੍ਰੋਜੈਕਟ ਅਕਸਰ ਧੀਮੇ ਸੈਟਅਪ ਅਤੇ ਬਹੁਤ ਸਾਰੇ “ਪਲੰਬਿੰਗ” ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ:
FastAPI ਦੀਆਂ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਨ੍ਹਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਸਿੱਧਾ ਨਿਸ਼ਾਨਾ ਕਰਦੀਆਂ ਹਨ, ਤਾਂ ਜੋ ਟੀਮਜ਼ ਹੋਰ ਸਮਾਂ endpoints ਡਿਜ਼ਾਇਨ ਕਰਨ ਵਿੱਚ ਲੱਗਾ ਸਕਣ ਅਤੇ ਫਰੇਮਵਰਕ ਬਾਇਲਰਪਲੇਟ ਨਾਲ ਨਾ ਲੜਨ।
FastAPI Python ਟਾਈਪ ਹਿੰਟਸ 'ਤੇ ਭਾਰੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜਦ ਤੁਸੀਂ ਘੋਸ਼ਣਾ ਕਰਦੇ ਹੋ ਕਿ ਇੱਕ ਫੀਲਡ int ਹੈ, ਵੈਕਲਪਿਕ ਹੈ, ਜਾਂ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਲਿਸਟ ਹੈ, FastAPI ਉਹ ਜਾਣਕਾਰੀ ਇਨਪੁਟ ਦੀ ਵੈਲਿਡੇਸ਼ਨ ਅਤੇ ਆਉਟਪੁਟ ਦੇ ਆਕਾਰ ਲਈ ਵਰਤਦਾ ਹੈ।
ਇਸ ਨਾਲ “stringly-typed” ਗਲਤੀਆਂ ਘੱਟ ਹੁੰਦੀਆਂ ਹਨ (ਜਿਵੇਂ ਕਿ ਇੱਕ ID ਨੂੰ ਇਕ ਥਾਂ ਤੇ ਟੈਕਸਟ ਅਤੇ ਦੂਜੇ ਥਾਂ ਤੇ ਨੰਬਰ ਵਜੋਂ ਵਰਤਣਾ) ਅਤੇ ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰਾਂ ਵਿੱਚ ਸਪਸ਼ਟ ਉਮੀਦਾਂ ਸ਼ਾਮਿਲ ਹੋਂਦੀਆਂ ਹਨ।
ਕੋਡ ਤੋਂ ਨਿਕਲਣ ਵਾਲੀ API ਸਕੀਮਾ ਕਾਰਨ FastAPI ਇੰਟਰਐਕਟਿਵ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ (OpenAPI + Swagger UI/ReDoc) ਆਟੋਮੈਟਿਕ ਤੌਰ ਤੇ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਸਹਿਯੋਗ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਫਰੰਟਐਂਡ ਡਿਵੈਲਪਰ, QA, ਅਤੇ ਇੰਟੇਗਰੇਟਰ endpoints ਨੂੰ ਐਕਸਪਲੋਰ ਕਰ ਸਕਦੇ ਹਨ, ਰਿਕਵੈਸਟ ਟਰਾਈ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਵਸਤੂਆਂ ਦੀ ਸਹੀ ਢਾਂਚਾ ਦੇਖ ਸਕਦੇ ਹਨ—ਕਿਸੇ ਵੱਖਰੀ ਡੌਕਸ ਦੀ ਉਡੀਕ ਕੀਤੇ ਬਿਨਾਂ।
FastAPI ਬੇਤਰਤੀਬੀ ਨਾਲ ਬਣਾਈ ਗਈ API ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰੇਗਾ। ਅਜੇ ਵੀ ਤੁਹਾਨੂੰ ਚੰਗੇ ਨਾਂਕਰਨ, ਵਰਸਨਿੰਗ, ਐਰਰ ਹੈਂਡਲਿੰਗ, ਅਤੇ ਸੁਰੱਖਿਆ ਫੈਸਲੇ ਕਰਨੇ ਪੈਣਗੇ। ਜੋ ਇਹ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਉਹ ਹੈ “ਵਿਚਾਰ” ਤੋਂ “ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਤ API” ਤੱਕ ਇੱਕ ਸਾਫ਼ ਰਸਤਾ ਬਿਨਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਅਚੰਭਿਆਂ ਦੇ।
FastAPI ਕੁਝ ਕੋਰ ਆਈਡੀਅਜ਼ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਇਹ ਸਧਾਰਨ ਲੱਗਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਅੰਦਰੂਨੀ ਗਲਤੀਆਂ ਯਾਦ ਰੱਖਣਾਂ ਲਾਜ਼ਮੀ ਨਹੀਂ—ਸਿਰਫ ਉਹ ਚੀਜ਼ਾਂ ਪਛਾਣੋ ਜੋ ਹਰ ਰੋਜ਼ ਤੁਸੀਂ ਵਰਤੋਂਗੇ।
ਇੱਕ ਫਰੇਮਵਰਕ ਉਹ ਟੂਲ ਅਤੇ ਰਿਵਾਜ਼ਾਂ ਦਾ ਸੈੱਟ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਸ਼ੁਰੂ ਤੋਂ ਨਹੀਂ ਬਣਾਉਣਾ ਪੈਂਦਾ। FastAPI ਆਮ API ਕੰਮਾਂ ਲਈ “ਪਲੰਬਿੰਗ” ਮੁਹੱਈਆ ਕਰਦਾ ਹੈ: 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 ਜਵਾਬ ਵਾਪਸ ਕਰਨ ਵਿੱਚFastAPI ASGI 'ਤੇ ਚੱਲਦਾ ਹੈ, ਜੋ Python ਵੈੱਬ ਸਰਵਰਾਂ ਲਈ ਇੱਕ ਆਧੁਨਿਕ ਮਿਆਰ ਹੈ। ਅਮਲੀ ਤੌਰ 'ਤੇ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ FastAPI ਬਹੁਤ ਸਾਰੀਆਂ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਲੰਬੇ ਸਮੇਂ ਵਾਲੀਆਂ ਕਨੈਕਸ਼ਨਾਂ (ਜਿਵੇਂ WebSockets) ਨੂੰ ਸਹਿਯੋਗ ਦੇ ਸਕਦਾ ਹੈ—ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਨੀਵੇਂ ਸਤਰ ਦੇ ਨੈੱਟਵਰਕ ਪ੍ਰਬੰਧਨ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਪਏ।
Python ਟਾਈਪ ਹਿੰਟ (ਜਿਵੇਂ str, int, list[Item]) FastAPI ਵਿੱਚ ਸਿਰਫ़ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ—ਇਹ ਮੂਲ ਆਇਨਪੁਟ ਹਨ। FastAPI ਇਹਨਾਂ ਨੂੰ ਸਮਝ ਕੇ ਜਾਣਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਉਮੀਦ ਕਰਦੇ ਹੋ, ਆਉਂਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸਹੀ ਕਿਸਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਵਧੀਆ, ਅਨੁਮਾਨਯੋਗ APIs ਤਿਆਰ ਕਰਦਾ ਹੈ।
Pydantic ਮਾਡਲ ਤੁਹਾਨੂੰ ਇੱਕ ਥਾਂ ਤੇ ਡੇਟਾ ਦਾ ਆਕਾਰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੇ ਦਿੰਦੇ ਹਨ (ਫੀਲਡ, ਟਾਈਪਾਂ, ਵਿਕਲਪਿਕ ਮੁੱਲ)। FastAPI ਇਹ ਮਾਡਲ ਵਰਤ ਕੇ ਆਉਂਦੀ JSON ਨੂੰ ਵੈਲਿਡੇਟ ਕਰਦਾ ਹੈ, ਗਲਤ ਇਨਪੁਟ ਨੂੰ ਨਾਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਆਉਟਪੁਟ ਨੂੰ ਸਥਿਰ ਤਰੀਕੇ ਨਾਲ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ—ਤਾਂ ਜੋ ਤੁਹਾਡੀ API ਵਿਅਵਹਾਰਿਕ ਤੌਰ 'ਤੇ ਭਰੋਸੇਯੋਗ ਰਹੇ।
FastAPI ਐਪ endpoints ਦੇ ਆਸ-ਪਾਸ ਬਣੇ ਹੁੰਦੇ ਹਨ: ਇੱਕ URL ਪਾਥ ਅਤੇ HTTP ਮੈਥਡ। ਇੱਕ endpoint ਸੋਚੋ ਕਿ “ਕਲਾਇੰਟ ਕੀ ਮੰਗ ਰਿਹਾ ਹੈ” ਅਤੇ “ਉਹ ਕਿਵੇਂ ਮੰਗ ਰਿਹਾ ਹੈ।” ਉਦਾਹਰਣ ਵਜੋਂ, ਕਲਾਇੰਟ GET /users ਕਰ ਸਕਦਾ ਹੈ ਯੂਜ਼ਰ ਲਿਸਟ ਕਰਨ ਲਈ, ਜਾਂ POST /users ਕਰ ਸਕਦਾ ਹੈ ਨਵਾਂ ਯੂਜ਼ਰ ਬਣਾਉਣ ਲਈ।
ਇੱਕ ਪਾਥ ਰੂਟ ਹੈ, ਅਤੇ ਮੈਥਡ ਕਾਰਵਾਈ ਹੈ:
GET /products → ਡੇਟਾ ਲਿਆਉਣਾPOST /products → ਕੁਝ ਬਣਾਉਣ ਲਈ ਡੇਟਾ ਭੇਜਣਾPUT /products/123 → ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਬਦਲਣਾ/ਅਪਡੇਟ ਕਰਨਾDELETE /products/123 → ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਹਟਾਉਣਾFastAPI ਪਾਥ ਦਾ ਹਿੱਸਾ ਹੋਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਉਸ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਅਕਸਰ ਵਿਕਲਪਿਕ "ਫਿਲਟਰ" ਹੁੰਦੇ ਹਨ।
GET /users/42 → 42 ਯੂਜ਼ਰ ID ਹੈ।? ਦੇ ਬਾਅਦ ਜੁੜਦਾ ਹੈ ਅਤੇ ਆਮਤੌਰ 'ਤੇ ਵਿਕਲਪਿਕ ਹੁੰਦਾ ਹੈ।
GET /users?limit=10&active=true → limit ਅਤੇ active ਨਤੀਜੇ ਕਿਵੇਂ ਵਾਪਸ ਹੋਣ, ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਦੇ ਹਨ।ਜਦੋਂ ਕਲਾਇੰਟ ਸੰਰਚਿਤ ਡੇਟਾ (ਅਮੂਮਨ JSON) ਭੇਜਦਾ ਹੈ, ਉਹ request body ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਅਕਸਰ POST ਜਾਂ PUT ਨਾਲ।
ਉਦਾਹਰਣ: POST /orders ਨਾਲ JSON { "item_id": 3, "quantity": 2 }।
FastAPI ਸਿੱਧੇ Python objects (ਜਿਵੇਂ dicts) ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਸਭ ਤੋਂ ਵਧੀਆ ਓਸ ਸਮੇਂ ਹੁੰਦਾ ਹੈ ਜਦ ਤੁਸੀਂ ਇਕ response model ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ। ਉਹ ਮਾਡਲ ਇੱਕ ਕਾਂਟ੍ਰੈਕਟ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ: ਫੀਲਡ ਇੱਕਸਾਰ ਹੁੰਦੇ ਹਨ, ਅਤਿਰਿਕਤ ਡੇਟਾ ਫਿਲਟਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਟਾਈਪਾਂ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਨਤੀਜਾ ਹੈ ਕਿ API ਸਾਫ਼ ਬਣਦੀ ਹੈ—ਕਲਾਇੰਟਾਂ ਨੂੰ ਪਤਾ ਹੁੰਦਾ ਹੈ ਕਿ ਕੀ ਉਮੀਦ ਰੱਖਣੀ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਅਚਾਨਕ ਜਵਾਬਾਂ ਤੋਂ ਬਚਦੇ ਹੋ ਜੋ ਇੰਟੇਗ੍ਰੇਸ਼ਨਾਂ ਨੂੰ ਤੋੜ ਸਕਦੀਆਂ ਹਨ।
“Async” (ਅਰਥਾਤ asynchronous) ਇੱਕ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਤੁਹਾਡੀ API ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰ ਸਕਦੀ ਹੈ ਜਦ ਬਹੁਤ ਸਮਾਂ "ਉਡੀਕ" ਵਿੱਚ ਲੰਘਦਾ ਹੈ।
ਇਕ ਬੈਰਿਸਟਾ ਦੀ ਸੋਚ ਕਰੋ ਜੋ ਆਰਡਰ ਲੈਂਦਾ ਹੈ। ਜੇ ਉਸਨੂੰ ਕਾਫੀ ਮਸ਼ੀਨ ਚੱਲਣ ਦੌਰਾਨ ਖੜਾ ਰਹਿ ਕੇ ਕੁਛ ਵੀ ਨਹੀਂ ਕਰਨਾ ਪੈਂਦਾ, ਤਾਂ ਉਹ ਘੱਟ ਗ੍ਰਾਹਕਾਂ ਨੂੰ ਸਰਵਿਸ ਦੇ ਸਕੇਗਾ। ਇੱਕ ਚੰਗਾ ਤਰੀਕਾ ਹੈ: ਕਾਫੀ ਬਣਾਉਣ ਦੌਰਾਨ ਅਗਲਾ ਆਰਡਰ ਲੈ ਲੈਣਾ।
Async ਓਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੀ FastAPI ਐਪ ਕਿਸੇ ਓਪਰੇਸ਼ਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀ ਹੈ ਜੋ ਕਿਸੇ ਸਲੇਟ-ਸਮੇਂ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ—ਜਿਵੇਂ ਨੈੱਟਵਰਕ ਰਿਕਵੈਸਟ ਜਾਂ ਡੇਟਾਬੇਸ ਕਾਲ—ਅਤੇ ਜਦ ਉਹ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਹੋਰ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਹੈਂਡਲ ਕਰਨ ਲਈ ਚਲ ਪੈ ਸਕਦੀ ਹੈ।
Async ਉਹ ਸਮੇਂ ਚਮਕਦਾ ਹੈ ਜਦ ਤੁਹਾਡੀ API ਬਹੁਤ ਜ਼ਿਆਦਾ I/O ਕੰਮ ਕਰਦੀ ਹੈ—ਉਹ ਕੰਮ ਜੋ ਸੋਚਣ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਮਾਂ ਉਡੀਕ ਵਿੱਚ ਲੈਂਦੇ ਹਨ। ਆਮ ਉਦਾਹਰਣ:
ਜੇਕਰ ਤੁਹਾਡੇ endpoints ਅਕਸਰ ਇਨ੍ਹਾਂ ਓਪਰੇਸ਼ਨਾਂ 'ਤੇ ਉਡੀਕ ਕਰਦੇ ਹਨ, ਤਾਂ async throughput ਬਿਹਤਰ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਲੋਡ ਹੇਠਾਂ ਬੇਨਤੀਆਂ ਦੇ ਢੇਰ ਹੋਣ ਦੇ ਚਾਂਸ ਘੱਟ ਕਰ ਸਕਦਾ ਹੈ।
Async ਹਰ ਚੀਜ਼ ਲਈ ਜਾਦੂਈ ਗਤੀ ਕਾਂਪ ਨਹੀਂ ਹੈ। ਜੇ ਤੁਹਾਡਾ endpoint ਅਕਸਰ CPU-ਭਾਰ ਹੈ—ਜਿਵੇਂ ਵੱਡੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਰੀਸਾਈਜ਼ ਕਰਨਾ, ਡੇਟਾ ਸਾਇੰਸ ਦੀਆਂ ਗਿਣਤੀਆਂ, ਜਾਂ ਵੱਡੇ ਪੇਲੋਡ ਏਨਕ੍ਰਿਪਟ ਕਰਨਾ—ਤਾਂ async ਖੁਦ ਘਣਨਾਤਮਕ ਕੰਮ ਨੂੰ ਤੇਜ਼ ਨਹੀਂ ਕਰੇਗਾ। ਉਹਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਵੱਖਰੇ ਤਰੀਕੇ ਵਰਤਦੇ ਹੋ (ਬੈਕਗ੍ਰਾਊਂਡ ਵਰਕਰ, ਪ੍ਰੋਸੈਸ ਪੂਲ, ਜਾਂ ਸਕੇਲ-ਆਊਟ)।
ਹਰ ਚੀਜ਼ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ। ਤੁਸੀਂ ਰੈਗੂਲਰ (sync) route functions ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ FastAPI ਉਹਨਾਂ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਚਲਾਏਗਾ। ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟ ਦੋਹਾਂ ਸ਼ੈਲੀਆਂ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਨ: ਸਧਾਰਨ endpoints sync ਰੱਖੋ, ਅਤੇ async def ਉਨ੍ਹਾਂ ਜਗ੍ਹਾਂ ਵਰਤੋ ਜਿੱਥੇ ਇਹ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਮਦਦਗਾਰ ਹੋਵੇ (ਅਕਸਰ ਡੇਟਾਬੇਸ ਕਾਲ ਜਾਂ ਬਾਹਰੀ HTTP ਰਿਕਵੈਸਟ ਦੇ ਆਲੇ-ਦੁਆਲੇ)।
ਵੈਲਿਡੇਸ਼ਨ ਬਾਹਰੀ ਦੁਨੀਆ ਅਤੇ ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਵਿਚਕਾਰ ਦਾ ਚੈੱਕਪੌଇਂਟ ਹੈ। ਜਦ API ਇਨਪੁਟ (JSON ਬਾਡੀ, ਕ્વੈਰੀ ਪੈਰਾਮ, ਪਾਥ ਪੈਰਾਮ) ਲੈਂਦੀ ਹੈ, ਤੁਸੀਂ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ ਪੂਰਾ, ਸਹੀ ਕਿਸਮ ਦਾ, ਅਤੇ ਵਾਜਿਬ ਸੀਮਾ ਵਿੱਚ ਹੈ—ਉਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖੋ, ਕਿਸੇ ਹੋਰ ਸੇਵਾ ਨੂੰ ਕਾਲ ਕਰੋ, ਜਾਂ ਬਿਜ਼ਨਸ ਲਾਜਿਕ ਚਲਾਉ।
FastAPI ਇਸ ਲਈ Pydantic ਮਾਡਲਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਵਾਰੀ ਇਹ ਦੱਸਦੇ ਹੋ ਕਿ “ਚੰਗਾ ਡੇਟਾ” ਕਿਵੇਂ ਦਿਖਦਾ ਹੈ, ਅਤੇ FastAPI ਆਟੋਮੈਟਿਕ:
ਜੇਕਰ ਕਿਸੇ ਕਲਾਇੰਟ ਨੇ ਗਲਤ ਆਕਾਰ ਦਾ ਡੇਟਾ ਭੇਜਿਆ, 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 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।age 13–120 ਤੱਕ ਸੀਮਿਤ ਹੈ।EmailStr ਇੱਕ ਵਿਧੀਬੱਧ ਈਮੇਲ ਆਕਾਰ ਲਾਗੂ ਕਰਦਾ ਹੈ।ਇਹੀ ਮਾਡਲ ਆਉਟਪੁਟ ਨੂੰ ਵੀ ਆਕਾਰ ਦੇ ਸਕਦੇ ਹਨ, ਤਾਂ ਜੋ ਤੁਹਾਡੇ API ਜਵਾਬ ਅੰਦਰੂਨੀ ਫੀਲਡਾਂ ਦੀ ਰੋਕਥਾਮ ਨਾ ਕਰਨ। ਤੁਸੀਂ Python objects ਵਾਪਸ ਕਰੋ; FastAPI (Pydantic ਰਾਹੀਂ) ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਫੀਲਡ ਨਾਂ ਅਤੇ ਟਾਈਪਾਂ ਨਾਲ JSON ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ।
FastAPI ਦੀ ਸਭ ਤੋਂ ਪ੍ਰਯੋਗਕ feature ਇਹ ਹੈ ਕਿ ਇਹ ਤੁਹਾਡੇ ਲਿਖੇ ਕੋਡ ਦੇ ਆਧਾਰ 'ਤੇ API ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਆਪਣੇ ਆਪ ਤਿਆਰ ਕਰ ਦਿੰਦਾ ਹੈ।
OpenAPI ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਹੈ API ਨੂੰ ਸੰਰਚਿਤ ਫਾਰਮੈਟ (ਆਮ ਤੌਰ 'ਤੇ JSON) ਵਿੱਚ ਵਰਣਨ ਕਰਨ ਦੀ। ਇਸਨੂੰ ਇੱਕ "ਕਾਂਟ੍ਰੈਕਟ" ਸਮਝੋ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ:
GET /users/{id})ਕਿਉਂਕਿ ਇਹ ਮਸ਼ੀਨ-ਪਠਣਯੋਗ ਹੈ, ਟੂਲ ਇਸਨੂੰ ਟੈਸਟ ਕਲਾਇੰਟ ਬਣਾਉਣ, ਰਿਕਵੈਸਟ ਵੈਲਿਡੇਟ ਕਰਨ, ਅਤੇ ਟੀਮਾਂ ਨੂੰ ਸਿੰਗ ਕਰਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹਨ।
FastAPI ਦੋ ਮਨੁੱਖ-ਫਰੈਂਡਲੀ ਡੌਕ ਪੇਜ਼ ਆਪਣੇ ਆਪ ਸਰਵ ਕਰਦਾ ਹੈ:
ਆਮ FastAPI ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ /docs ਅਤੇ /redoc 'ਤੇ ਲੱਭ ਸਕਦੇ ਹੋ।
ਜਦ ਤੁਸੀਂ ਆਪਣੀਆਂ ਪਾਥ ਪੈਰਾਮ, request models, response models, ਜਾਂ ਵੈਲਿਡੇਸ਼ਨ ਨਿਯਮ ਬਦਲਦੇ ਹੋ, OpenAPI ਸਕੀਮਾ (ਅਤੇ ਡੌਕਸ ਪੇਜ਼) ਆਟੋਮੈਟਿਕ ਅਪਡੇਟ ਹੋ ਜਾਂਦੇ ਹਨ। ਕੋਈ ਵੱਖਰੀ “ਡੌਕਸ ਸੰਭਾਲਣ” ਕਦਮ ਲੈਣ ਦੀ ਲੋੜ ਨਹੀਂ।
ਇੱਕ FastAPI ਐਪ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ ਫਿਰ ਵੀ “ਅਸਲੀ” ਮਹਿਸੂਸ ਕਰਵਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਇਕ Python object app ਬਣਾਉਂਦੇ ਹੋ, ਕੁਝ ਰੂਟ ਜੋੜਦੇ ਹੋ, ਅਤੇ ਲੋਕਲ ਸਰਵਰ ਚਲਾਕੇ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਟ੍ਰਾਈ ਕਰਦੇ ਹੋ।
ਸਭ ਤੋਂ ਛੋਟਾ ਉਪਯੋਗੀ ਉਦਾਹਰਣ:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI"}
ਇੱਥੇ: ਇੱਕ ਰੂਟ (GET /) ਜੋ JSON ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਇਸਨੂੰ ਇੱਕ 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 ਨਾਲ ਲਿਸਟ ਪਾਉਆਮ ਸਟਾਰਟਰ ਢਾਂਚਾ:
main.py (ਜਿੱਥੇ app ਅਤੇ routes ਬਣਦੇ ਹਨ)requirements.txt ਜਾਂ pyproject.toml (ਨਿਭਰਤਾਵਾਂ)ਆਮ ਤੌਰ 'ਤੇ ਤੁਸੀਂ:
uvicorn main:app --reload)http://127.0.0.1:8000 ਖੋਲ੍ਹੋ ਅਤੇ endpoints ਟ੍ਰਾਈ ਕਰੋFastAPI "dependencies" ਉਹ ਸਾਂਝੇ ਇਨਪੁਟ ਹਨ ਜੋ ਤੁਹਾਡੇ endpoints ਨੂੰ ਆਪਣਾ ਕੰਮ ਕਰਨ ਲਈ ਚਾਹੀਦੇ ਹਨ—ਜਿਵੇਂ ਕਿ ਡੇਟਾਬੇਸ ਸੈਸ਼ਨ, ਮੌਜੂਦਾ ਲੌਗਿਨ ਯੂਜ਼ਰ, ਐਪ ਸੈਟਿੰਗਜ਼, ਜਾਂ ਆਮ query ਪੈਰਾਮ। ਹਰ ਰੂਟ ਵਿੱਚ ਇਹਨਾਂ ਨੂੰ ਹਥਿਆਉਣ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਇਕ ਵਾਰੀ ਐਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਅਤੇ FastAPI ਜਿੱਥੇ ਲੋੜ ਹੋਏ ਉਥੇ ਇਹ ਪੈਸ ਕਰ ਦਿੰਦਾ ਹੈ।
ਇੱਕ dependency ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ (ਜਾਂ ਕਲਾਸ) ਹੁੰਦੀ ਹੈ ਜੋ ਤੁਹਾਡੇ endpoint ਲਈ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ। FastAPI ਇਹਨੂੰ ਤੁਹਾਡੇ ਲਈ ਕਾਲ ਕਰੇਗਾ, ਇਸਦੇ ਪੈਰਾਮ ਦੇ ਆਧਾਰ ਤੇ ਵੀ ਜੋ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਨਤੀਜਾ ਤੁਹਾਡੇ path operation ਫੰਕਸ਼ਨ ਵਿੱਚ inject ਕਰ ਦੇਵੇਗਾ।
ਇਸਨੂੰ dependency injection ਕਹਿੰਦੇ ਹਨ, ਪਰ ਤੁਸੀਂ ਇਸਨੂੰ ਐਸਾ ਸੋਚ ਸਕਦੇ ਹੋ: “ਜੋ ਤੁਸੀਂ ਚਾਹੀਦਾ ਹੈ ਉਸਨੂੰ ਘੋਸ਼ਣਾ ਕਰੋ, ਅਤੇ FastAPI ਉਸਨੂੰ ਜੋੜ ਦੇਵੇਗਾ।”
ਬਿਨਾਂ dependencies ਦੇ, ਤੁਸੀਂ ਸ਼ਾਇਦ:
Dependencies ਨਾਲ, ਤੁਸੀਂ ਉਹ ਲੋジਿਕ ਕੇਂਦਰਿਤ ਕਰ ਲੈਂਦੇ ਹੋ। ਜੇ ਬਾਅਦ ਵਿੱਚ ਤੁਸੀਂ ਡੀਬੀ ਸੈਸ਼ਨ ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ ਬਦਲਦੇ ਹੋ ਜਾਂ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਲੋਡ ਕਰਨ ਦਾ ਤਰੀਕਾ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਥਾਂ 'ਤੇ ਅਪਡੇਟ ਕਰੋ—ਨਾ ਕਿ ਦਰਜਨਾਂ endpoints 'ਚ।
page/limit ਦੀ parsing ਅਤੇ validation ਦੁਬਾਰਾ ਵਰਤਣਾ।ਇੱਥੇ ਇੱਕ ਧਾਰਣਾਤਮਕ ਪੈਟਰਨ ਹੈ ਜੋ ਬਹੁਤ 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 ਸਵਾਲ ਕਰਦਾ ਹੈ: “ਤੁਸੀਂ ਕੌਣ ਹੋ?” Authorization ਸਵਾਲ ਕਰਦਾ ਹੈ: “ਤੁਹਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਆਗਿਆ ਹੈ?”
ਉਦਾਹਰਣ: ਇੱਕ ਯੂਜ਼ਰ authenticated ਹੋ ਸਕਦਾ ਹੈ (ਸਹੀ login/token) ਪਰ ਫਿਰ ਵੀ ਇਕ admin-ਕੇਵਲ route ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੋ ਸਕਦੀ।
X-API-Key)। ਰੋਟੇਸ਼ਨ ਅਤੇ ਰਿਵੋਕੇਸ਼ਨ ਦਾ ਪ੍ਰਬੰਧ ਕਰੋ।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 ਦਾ “ਮੇਰੇ ਮਸ਼ੀਨ ਤੇ ਚੱਲਦਾ ਹੈ” ਵਾਅਦਾ ਤੁਹਾਨੂੰ ਭਰੋਸਾ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ship ਕਰ ਸਕਦੇ ਹੋ। ਚੰਗੀ ਖ਼ਬਰ: FastAPI Starlette 'ਤੇ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਬਹੁਤ ਘੱਟ ਸੈਟਅਪ ਵਿੱਚ ਮਜ਼ਬੂਤ ਟੈਸਟਿੰਗ ਟੂਲ ਮਿਲਦੇ ਹਨ।
Unit tests ਛੋਟੇ ਹਿੱਸਿਆਂ 'ਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹਨ: ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਇੱਕ ਕੀਮਤ ਗਣਨ ਕਰਦਾ ਹੈ, ਇੱਕ dependency ਜੋ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਲੋਡ ਕਰਦਾ ਹੈ, ਜਾਂ ਇੱਕ ਸਰਵਿਸ ਮੈਥਡ ਜੋ ਡੇਟਾਬੇਸ ਨਾਲ ਗੱਲ ਕਰਦਾ ਹੈ (ਅਕਸਰ mocked)।
Integration tests API ਨੂੰ end-to-end ਅੰਜਾਮ ਦਿੰਦੇ ਹਨ: ਤੁਸੀਂ ਇੱਕ endpoint ਕਾਲ ਕਰਦੇ ਹੋ ਅਤੇ ਪੂਰੇ HTTP ਜਵਾਬ 'ਤੇ assert ਕਰਦੇ ਹੋ। ਇਹ ਉਹ ਟੈਸਟ ਹਨ ਜੋ routing ਗਲਤੀਆਂ, dependency wiring ਮੁੱਦਿਆਂ, ਅਤੇ validation ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਫੜਦੇ ਹਨ।
ਇੱਕ ਸਿਹਤਮੰਦ ਟੈਸਟ ਸੂਟ ਆਮ ਤੌਰ 'ਤੇ ਵੱਧ unit tests (ਤੇਜ਼) ਅਤੇ ਘੱਟ integration tests (ਉੱਚ ਭਰੋਸਾ) ਰੱਖਦਾ ਹੈ।
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
ਟੈਸਟ ਉਹ ਚੀਜ਼ਾਂ ਜਿਨ੍ਹਾਂ 'ਤੇ ਯੂਜ਼ਰ ਅਤੇ ਹੋਰ ਸਿਸਟਮ ਨਿਰਭਰ ਹਨ:
ਪੇਸ਼ਗੀ ਡੇਟਾ ਵਰਤੋ, ਬਾਹਰੀ ਸੇਵਾਵਾਂ ਨੂੰ ਅਲੱਗ ਕਰੋ (mock ਜਾਂ ਟੈਸਟ DB), ਅਤੇ ਟੈਸਟਾਂ ਵਿੱਚ ਸਾਂਝੀ ਸਟੇਟ ਤੋਂ ਬਚੋ। ਤੇਜ਼ ਟੈਸਟ ਚਲਦੇ ਹਨ; ਹੌਲੇ ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ ਛੱਡੇ ਜਾਂਦੇ ਹਨ।
FastAPI ਐਪ ਨੂੰ ਆਨਲਾਈਨ ਲਿਆਉਣਾ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਹੀ “ਰੰਨਰ” ਚੁਣਨ ਅਤੇ ਕੁਝ ਪ੍ਰੋਡਕਸ਼ਨ ਜ਼ਰੂਰੀਆਂ ਸ਼ਾਮਲ ਕਰਨ ਬਾਰੇ ਹੈ।
ਜਦ ਤੁਸੀਂ ਲੋਕਲ ਤੌਰ 'ਤੇ uvicorn main:app --reload ਚਲਾਉਂਦੇ ਹੋ, ਤਦ ਤੁਸੀਂ ਇੱਕ ਡੈਵ ਸੈਟਅਪ ਵਰਤ ਰਹੇ ਹੁੰਦੇ ਹੋ: auto-reload, ਡਿਬੱਗ ਇੰਫੋ, ਅਤੇ ਸੇਟਿੰਗਜ਼ ਜੋ ਸੁਵਿਧਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ।
ਪ੍ਰੋਡ ਵਿੱਚ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ Uvicorn reload ਬਿਨਾਂ ਚਲਾਉਂਦੇ ਹੋ, ਅਕਸਰ ਇੱਕ process manager (ਜਿਵੇਂ Gunicorn ਨਾਲ Uvicorn workers) ਦੇ ਪਿੱਛੇ ਜਾਂ reverse proxy ਦੇ ਨਾਲ। ਮਕਸਦ ਹੈ ਸਥਿਰਤਾ: ਕੰਟਰੋਲਡ restarts, ਭਰੋਸੇਯੋਗ ਪ੍ਰਦਰਸ਼ਨ, ਅਤੇ ਸੁਰੱਖਿਅਤ defaults।
ਆਮ ਪੈਟਰਨ:
ਇਸ ਨਾਲ ਇੱਕੋ ਕੋਡਬੇਸ ਨੂੰ ਬਿਨਾਂ ਫਾਈਲ ਐਡਿਟ ਕੀਤੇ ਕਈ environment ਵਿੱਚ deploy ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
"ਕਰਨਯੋਗ" ਕਹਿਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਓ:
/health ਵਰਗੇ endpoints uptime ਮੋਨੀਟਰਿੰਗ ਅਤੇ load balancers ਲਈ।ਜੇ ਤੁਸੀਂ "ਲੋਕਲ ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ" ਤੋਂ "ਸ਼ਿੱਪਬਲ" ਵੱਲ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ API contract ਨੂੰ ਜਨਰੇਟ ਅਤੇ ਮੈਨੇਜ ਕਰਨ ਦਾ ਇੱਕ standardized ਤਰੀਕਾ ਰੱਖਣਾ ਵੀ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ। ਕੁਝ ਟੀਮ FastAPI ਦੇ OpenAPI ਆਉਟਪੁਟ ਨੂੰ automated workflows ਨਾਲ ਜੋੜਦੀਆਂ ਹਨ—ਉਦਾਹਰਣ ਵਜੋਂ client ਜਨਰੇਟਰ ਬਣਾਉਣਾ, CI ਵਿੱਚ ਰਿਕਵੈਸਟ ਵੈਲਿਡੇਸ਼ਨ ਕਰਨਾ, ਅਤੇ ਲਗਾਤਾਰ deploy। Koder.ai ਵਰਗੇ ਟੂਲ ਵੀ ਇਸ ਚਰਨ ਨਾਲ ਮੈਚ ਕਰ ਸਕਦੇ ਹਨ: ਤੁਸੀਂ chat ਵਿੱਚ API ਵਰਨਣ ਕਰਕੇ endpoints ਤੇ ਮਾਡਲ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉ, ਫਿਰ generated ਕੋਡ ਨੂੰ ਸਧਾਰਨ review/deploy ਪਾਈਪਲਾਈਨ ਵਿੱਚ export ਕਰੋ।
FastAPI ਉਹੋ ਸਮਾਂ ਚੰਗਾ ਚੋਣ ਹੈ ਜਦ ਤੁਸੀਂ Python ਵਿੱਚ ਇੱਕ ਸਾਫ਼, ਆਧੁਨਿਕ ਤਰੀਕੇ ਨਾਲ REST APIs ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ—ਖ਼ਾਸ ਕਰਕੇ ਜੇ ਤੁਸੀਂ ਸਪਸ਼ਟ request/response ਮਾਡਲ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵਧਣ 'ਤੇ ਭਰੋਸੇਯੋਗ ਵਿਹਾਰ ਚਾਹੁੰਦੇ ਹੋ।
FastAPI ਆਮ ਤੌਰ 'ਤੇ ਇਨ੍ਹਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਚਮਕਦਾ ਹੈ:
FastAPI ਹਮੇਸ਼ਾਂ ਸਭ ਤੋਂ ਸੌਖਾ ਜਵਾਬ ਨਹੀਂ:
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 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.
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.
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/replacePath parameters are part of the URL structure and usually identify a specific resource (required).
GET /users/42 → 42 is a path parameterQuery parameters are appended after ? and are usually optional filters or controls.
Pydantic models define the shape and rules of your data (types, required fields, constraints). FastAPI uses them to:
If validation fails, FastAPI typically responds with 422 Unprocessable Entity and details about which field is wrong.
FastAPI automatically generates an OpenAPI schema from your endpoints, type hints, and models.
You usually get interactive docs for free:
/docs/redocBecause the schema is derived from code, the docs stay in sync as you change parameters and models.
Use async def when your endpoint spends time waiting on I/O (database calls, external HTTP requests, file/object storage).
Use regular def when:
Mixing sync and async endpoints in the same app is common.
Dependencies are reusable “building blocks” that FastAPI injects into endpoints via Depends().
They’re commonly used for:
This reduces repetition and centralizes cross-cutting logic so changes happen in one place.
FastAPI doesn’t secure your API by default—you choose an approach and apply it consistently.
Common patterns include:
Also remember the basics:
For testing, you can use FastAPI/Starlette’s TestClient to call your API in-process (no server required).
Practical items to assert:
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.
@app.delete("/items/{id}")This makes your API surface easy to scan directly from code.
GET /users?limit=10&active=true → limit, active are query parameters/health