REST API ਕਿਵੇਂ ਬਣਾਈਏ: ਡਿਜ਼ਾਈਨ, ਸੁਰੱਖਿਆ ਅਤੇ ਡਿਪਲੌਏਮੈਂਟ
REST API ਬਣਾਉਣ ਲਈ, ਆਪਣੀ ਐਪ ਵਿੱਚ ਸੰਭਾਲੇ ਜਾਣ ਵਾਲੇ ਰਿਸੋਰਸ (ਯੂਜ਼ਰ, ਆਰਡਰ, ਬੁਕਿੰਗ) ਲਿਖੋ, ਹਰ ਇੱਕ ਨੂੰ /orders ਅਤੇ /orders/{id} ਵਰਗਾ URL ਦਿਓ, ਅਤੇ ਕਾਰਵਾਈਆਂ ਲਈ HTTP ਮੈਥਡ ਵਰਤੋ: ਪੜ੍ਹਨ ਲਈ GET, ਬਣਾਉਣ ਲਈ POST, ਬਦਲਣ ਲਈ PATCH, ਹਟਾਉਣ ਲਈ DELETE। ਅਰਥਪੂਰਨ ਸਟੇਟਸ ਕੋਡਾਂ ਨਾਲ JSON ਵਾਪਸ ਕਰੋ, ਹਰ ਇਨਪੁੱਟ ਦੀ ਵੈਲੀਡੇਸ਼ਨ ਕਰੋ, ਸਰਵਰ 'ਤੇ ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਹਰ ਰਿਕਾਰਡ ਲਈ ਇਜਾਜ਼ਤ ਦੀ ਜਾਂਚ ਲਾਜ਼ਮੀ ਕਰੋ, ਅਤੇ ਸੂਚੀਆਂ ਨੂੰ ਪੰਨਿਆਂ ਵਿੱਚ ਵੰਡੋ। ਫਿਰ ਐਂਡਪੁਆਇੰਟਾਂ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਬਣਾਓ ਅਤੇ API ਨੂੰ HTTPS ਪਿੱਛੇ ਡਿਪਲੌਏ ਕਰੋ।
ਇਹ ਗਾਈਡ ਡਿਜ਼ਾਈਨ ਫੈਸਲੇ, ਰੂਟਾਂ ਦਾ ਇੱਕ ਕੰਮ ਕੀਤਾ ਸੈੱਟ, Mythex ਵਰਗੇ AI ਐਪ ਬਿਲਡਰ ਲਈ ਪ੍ਰੋਮਪਟ, ਅਤੇ ਉਹ ਗਲਤੀਆਂ ਕਵਰ ਕਰਦੀ ਹੈ ਜੋ ਸੁਰੱਖਿਆ ਛੇਕ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਜੇ API ਤੁਹਾਡੇ ਲਈ ਨਵਾਂ ਹੈ, ਤਾਂ API ਕੀ ਹੈ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ।
REST API ਕਦੋਂ ਚਾਹੀਦਾ ਹੈ
- ਤੁਹਾਡੇ ਵੈੱਬ ਫ਼ਰੰਟਐਂਡ ਨੂੰ ਸਰਵਰ ਤੋਂ ਡੇਟਾ ਸੇਵ ਅਤੇ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ
- ਮੋਬਾਈਲ ਐਪ, ਭਾਈਵਾਲ ਜਾਂ ਆਟੋਮੇਸ਼ਨ ਟੂਲ ਨੂੰ ਤੁਹਾਡੇ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਚਾਹੀਦੀ ਹੈ
- ਹੋਰ ਸਰਵਿਸਾਂ ਤੁਹਾਨੂੰ ਇਵੈਂਟ ਭੇਜਦੀਆਂ ਹਨ (webhooks)
- ਤੁਸੀਂ ਫ਼ਰੰਟਐਂਡ ਅਤੇ ਬੈਕਐਂਡ ਟੀਮਾਂ ਵਿਚਕਾਰ ਕੰਮ ਵੰਡ ਰਹੇ ਹੋ
REST ਸਭ ਤੋਂ ਆਮ ਸ਼ੈਲੀ ਹੈ, ਪਰ ਇਕੋ ਨਹੀਂ। REST ਬਨਾਮ GraphQL ਦੱਸਦਾ ਹੈ ਕਿ ਕਦੋਂ ਇੱਕ ਲਚਕੀਲਾ ਕਵੇਰੀ ਐਂਡਪੌਇੰਟ ਬਿਹਤਰ ਮੇਲ ਹੈ।
ਪਹਿਲਾਂ ਡਿਜ਼ਾਈਨ ਕਰੋ: ਰਿਸੋਰਸ ਅਤੇ ਰੂਟ
ਆਪਣੀ ਐਪ ਦੇ ਨਾਂਵ ਅਤੇ ਲੋਕ ਉਨ੍ਹਾਂ ਨਾਲ ਕੀ ਕਰਦੇ ਹਨ, ਲਿਖੋ। ਇੱਕ ਸਧਾਰਨ ਬੁਕਿੰਗ ਐਪ ਲਈ:
| ਮੈਥਡ | ਰੂਟ | ਕੀ ਕਰਦਾ ਹੈ | ਸਫ਼ਲਤਾ ਕੋਡ |
|---|---|---|---|
GET | /api/bookings | ਕਾਲ ਕਰਨ ਵਾਲੇ ਦੀਆਂ ਬੁਕਿੰਗਾਂ ਦੀ ਸੂਚੀ (ਪੇਜੀਨੇਟਡ) | 200 |
POST | /api/bookings | ਨਵੀਂ ਬੁਕਿੰਗ ਬਣਾਓ | 201 |
GET | /api/bookings/{id} | ਇੱਕ ਬੁਕਿੰਗ ਪ੍ਰਾਪਤ ਕਰੋ | 200 |
PATCH | /api/bookings/{id} | ਕੁਝ ਫ਼ੀਲਡ ਬਦਲੋ | 200 |
DELETE | /api/bookings/{id} | ਬੁਕਿੰਗ ਰੱਦ ਕਰੋ | 204 |
GET | /api/health | ਮਾਨੀਟਰਿੰਗ ਲਈ ਹੈਲਥ ਚੈੱਕ | 200 |
ਇਹ ਬਣਾਓ, ਪੜ੍ਹੋ, ਬਦਲੋ ਅਤੇ ਹਟਾਓ (CRUD) ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ; ਵੇਖੋ CRUD ਕੀ ਹੈ। ਕੁਝ ਸੰਮੇਲਨ ਜੋ ਵਰਤਣ ਯੋਗ ਹਨ:
- URL ਵਿੱਚ ਬਹੁਵਚਨ ਨਾਂਵ, ਕ੍ਰਿਆ ਨਹੀਂ:
/bookings,/getBookingsਨਹੀਂ। - ਸਿਰਫ਼ ਇੱਕ ਪੱਧਰ ਤੱਕ ਨੈਸਟ ਕਰੋ ਜਦੋਂ ਮਾਲਕੀ ਸਪਸ਼ਟ ਹੋਵੇ:
/bookings/{id}/notes। - CRUD ਤੋਂ ਬਾਹਰ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਸਬ-ਰਿਸੋਰਸ ਹੋ ਸਕਦੀਆਂ ਹਨ:
POST /bookings/{id}/cancelਕਿਸੇ ਜਾਦੂਈ PATCH ਨਾਲੋਂ ਸਾਫ਼ ਹੈ। - ਫ਼ੀਲਡਾਂ ਦੇ ਨਾਂ ਇਕਸਾਰ ਰੱਖੋ, ਜਿਵੇਂ ਹਰ ਥਾਂ
created_at।
ਸਟੇਟਸ ਕੋਡ ਅਤੇ ਗ਼ਲਤੀਆਂ
ਮਿਆਰੀ HTTP ਕੋਡ ਵਰਤੋ ਤਾਂ ਕਿ ਕਲਾਇੰਟ ਟੈਕਸਟ ਪੜ੍ਹੇ ਬਿਨਾਂ ਸਮਝ ਜਾਵੇ ਕਿ ਕੀ ਹੋਇਆ:
| ਕੋਡ | ਮਤਲਬ | ਕਦੋਂ ਵਰਤੋ |
|---|---|---|
| 200 | OK | ਸਫ਼ਲ ਪੜ੍ਹਨ ਜਾਂ ਅੱਪਡੇਟ |
| 201 | Created | POST ਨੇ ਕੁਝ ਬਣਾਇਆ |
| 204 | No Content | ਸਫ਼ਲਤਾ, ਪਰ ਵਾਪਸ ਕਰਨ ਲਈ ਕੁਝ ਨਹੀਂ |
| 400 | Bad Request | ਇਨਪੁੱਟ ਵੈਲੀਡੇਸ਼ਨ ਵਿੱਚ ਫ਼ੇਲ੍ਹ |
| 401 | Unauthorized | ਲੌਗਇਨ ਨਹੀਂ ਜਾਂ ਟੋਕਨ ਗ਼ਲਤ |
| 403 | Forbidden | ਲੌਗਇਨ ਹੈ ਪਰ ਇਜਾਜ਼ਤ ਨਹੀਂ |
| 404 | Not Found | ਮੌਜੂਦ ਨਹੀਂ, ਜਾਂ ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਇਹ ਪਤਾ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਕਿ ਇਹ ਮੌਜੂਦ ਹੈ |
| 409 | Conflict | ਡੁਪਲੀਕੇਟ, ਜਾਂ ਸਲਾਟ ਪਹਿਲਾਂ ਹੀ ਬੁੱਕ ਹੈ |
| 429 | Too Many Requests | ਰੇਟ ਲਿਮਿਟ ਪਾਰ ਹੋ ਗਈ |
| 500 | Server Error | ਤੁਹਾਡੇ ਪਾਸੇ ਕੁਝ ਟੁੱਟ ਗਿਆ |
ਗ਼ਲਤੀਆਂ ਇੱਕੋ ਜਿਹੇ JSON ਢਾਂਚੇ ਵਿੱਚ ਵਾਪਸ ਕਰੋ, ਜਿਵੇਂ {"error": {"code": "slot_taken", "message": "That time is no longer available."}}, ਅਤੇ ਜਵਾਬਾਂ ਵਿੱਚ ਕਦੇ ਵੀ ਸਟੈਕ ਟਰੇਸ ਜਾਂ ਡੇਟਾਬੇਸ ਗ਼ਲਤੀਆਂ ਨਾ ਪਾਓ।
ਵਿਕਲਪ ਅਤੇ ਸਮਝੌਤੇ
| ਫ਼ੈਸਲਾ | ਸਰਲ ਚੋਣ | ਬਦਲ |
|---|---|---|
| API ਕਿੱਥੇ ਰਹੇ | ਤੁਹਾਡੇ ਵੈੱਬ ਫ਼ਰੇਮਵਰਕ ਵਿੱਚ API ਰੂਟ | ਵੱਖਰੀ API ਸਰਵਿਸ, ਕਈ ਕਲਾਇੰਟਾਂ ਜਾਂ ਵੱਖਰੀ ਭਾਸ਼ਾ ਲਈ ਲਾਭਦਾਇਕ |
| ਪ੍ਰਮਾਣੀਕਰਨ | ਤੁਹਾਡੀ ਆਪਣੀ ਵੈੱਬ ਐਪ ਲਈ ਸੈਸ਼ਨ ਕੁਕੀਜ਼ | ਮੋਬਾਈਲ ਐਪਾਂ ਅਤੇ ਤੀਜੀ ਧਿਰਾਂ ਲਈ ਟੋਕਨ (ਬੀਅਰਰ ਟੋਕਨ ਜਾਂ API ਕੀ) |
| ਪੇਜੀਨੇਸ਼ਨ | ?page=2&limit=20 | ਕਰਸਰ-ਅਧਾਰਤ (?after=...), ਵੱਡੀਆਂ ਅਤੇ ਬਦਲਦੀਆਂ ਸੂਚੀਆਂ ਲਈ ਵਧੇਰੇ ਸਥਿਰ |
| ਵਰਜ਼ਨਿੰਗ | ਬਾਹਰੀ ਯੂਜ਼ਰ ਹੋਣ ਤੱਕ ਕੋਈ ਨਹੀਂ | ਜਦੋਂ ਹੋਰ ਲੋਕ ਇਸ 'ਤੇ ਨਿਰਭਰ ਹੋਣ, ਤਾਂ ਪਾਥ ਵਿੱਚ /v1/ |
| ਦਸਤਾਵੇਜ਼ | ਰੂਟਾਂ ਦੀ ਸੂਚੀ ਵਾਲਾ README | OpenAPI ਸਪੈਸਿਫ਼ਿਕੇਸ਼ਨ, ਜਿਸ ਤੋਂ ਟੂਲ ਇੰਟਰੈਕਟਿਵ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਕਲਾਇੰਟ ਕੋਡ ਬਣਾ ਸਕਦੇ ਹਨ |
ਕਦਮ-ਦਰ-ਕਦਮ
- ਰਿਸੋਰਸ ਅਤੇ ਰੂਟ ਲਿਖੋ ਜਿਵੇਂ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਨਾਲ ਇਹ ਵੀ ਕਿ ਹਰ ਇੱਕ ਨੂੰ ਕੌਣ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ।
- ਡੇਟਾ ਮਾਡਲ ਬਣਾਓ ਆਪਣੇ ਡੇਟਾਬੇਸ ਵਿੱਚ, ਲੋੜੀਂਦੀਆਂ ਫ਼ੀਲਡਾਂ ਅਤੇ ਸੰਬੰਧਾਂ ਨਾਲ।
- ਪਹਿਲਾਂ ਪੜ੍ਹਨ ਵਾਲੇ ਰੂਟ ਬਣਾਓ, ਫਿਰ ਬਣਾਉਣ, ਅੱਪਡੇਟ ਅਤੇ ਹਟਾਉਣ ਵਾਲੇ।
- ਹਰ ਲਿਖਤ 'ਤੇ ਇਨਪੁੱਟ ਵੈਲੀਡੇਟ ਕਰੋ ਇੱਕ ਸਕੀਮਾ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ: ਲੋੜੀਂਦੀਆਂ ਫ਼ੀਲਡਾਂ, ਕਿਸਮਾਂ, ਲੰਬਾਈ, ਮਨਜ਼ੂਰ ਮੁੱਲ। ਅਣਜਾਣ ਫ਼ੀਲਡਾਂ ਰੱਦ ਕਰੋ।
- ਪ੍ਰਮਾਣੀਕਰਨ ਜੋੜੋ, ਫਿਰ ਹਰ ਰਿਕਾਰਡ ਲਈ ਅਧਿਕਾਰ:
/bookings/42ਲੋਡ ਕਰਨ ਵੇਲੇ ਜਾਂਚੋ ਕਿ ਬੁਕਿੰਗ 42 ਕਾਲ ਕਰਨ ਵਾਲੇ ਦੀ ਹੈ, ਸਿਰਫ਼ ਇਹ ਨਹੀਂ ਕਿ ਕੋਈ ਲੌਗਇਨ ਹੈ। - ਹਰ ਸੂਚੀ ਨੂੰ ਪੇਜੀਨੇਟ ਕਰੋ ਅਤੇ ਪੰਨੇ ਦਾ ਆਕਾਰ ਸੀਮਤ ਕਰੋ।
- ਲੌਗਇਨ ਅਤੇ ਮਹਿੰਗੇ ਰੂਟਾਂ ਦੀ ਰੇਟ ਸੀਮਾ ਲਗਾਓ। ਰੇਟ ਲਿਮਿਟਿੰਗ ਵੇਖੋ।
- CORS ਸੈੱਟ ਕਰੋ ਸਿਰਫ਼ ਉਦੋਂ ਜਦੋਂ ਹੋਰ ਡੋਮੇਨਾਂ ਦੇ ਬ੍ਰਾਊਜ਼ਰਾਂ ਨੇ API ਕਾਲ ਕਰਨੀ ਹੋਵੇ, ਅਤੇ ਉਨ੍ਹਾਂ ਔਰਿਜਿਨ ਨੂੰ ਸਾਫ਼-ਸਾਫ਼ ਲਿਖੋ। CORS ਗ਼ਲਤੀਆਂ ਠੀਕ ਕਰਨਾ ਤੁਹਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਕਿਹੜੀਆਂ ਗ਼ਲਤੀਆਂ ਆਉਣਗੀਆਂ।
- ਹਰ ਰੂਟ ਲਈ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਟੈਸਟ ਲਿਖੋ, ਫ਼ੇਲ੍ਹ ਹੋਣ ਵਾਲੇ ਮਾਮਲਿਆਂ ਸਮੇਤ।
- ਡਿਪਲੌਏ ਕਰੋ ਗੁਪਤ ਜਾਣਕਾਰੀ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ, HTTPS ਨਾਲ, ਲੌਗਾਂ ਅਤੇ ਹੈਲਥ ਚੈੱਕ ਨਾਲ।
ਆਪਣੇ AI ਬਿਲਡਰ ਨੂੰ ਦੇਣ ਯੋਗ ਪ੍ਰੌਮਪਟ
ਸਕੈਫੋਲਡ:
ਬੁਕਿੰਗਾਂ ਲਈ ਇਨ੍ਹਾਂ ਰੂਟਾਂ ਵਾਲਾ REST API ਬਣਾਓ: GET /api/health, GET /api/bookings (ਪੇਜੀਨੇਟਡ, ਪ੍ਰਤੀ ਪੰਨਾ ਵੱਧ ਤੋਂ ਵੱਧ 50), POST /api/bookings, GET /api/bookings/:id, PATCH /api/bookings/:id, DELETE /api/bookings/:id। ਡੇਟਾ ਸਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰੋ। ਰਿਕਵੈਸਟ ਬਾਡੀ ਨੂੰ ਸਕੀਮਾ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਵੈਲੀਡੇਟ ਕਰੋ ਅਤੇ ਅਣਜਾਣ ਫ਼ੀਲਡਾਂ ਰੱਦ ਕਰੋ। ਗ਼ਲਤੀਆਂ ਨੂੰ {"error": {"code", "message"}} ਵਜੋਂ JSON ਵਿੱਚ ਵਾਪਸ ਕਰੋ, ਸਹੀ ਸਟੇਟਸ ਕੋਡਾਂ ਨਾਲ (400, 401, 403, 404, 409)। ਗੁਪਤ ਜਾਣਕਾਰੀ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਰੱਖੋ।
ਸੁਰੱਖਿਆ:
ਹਰ ਬੁਕਿੰਗ ਰੂਟ 'ਤੇ ਲੌਗਇਨ ਲਾਜ਼ਮੀ ਕਰੋ। ਹਰ ਰੀਡ, ਅੱਪਡੇਟ ਅਤੇ ਡਿਲੀਟ 'ਤੇ ਸਰਵਰ 'ਤੇ ਜਾਂਚੋ ਕਿ ਬੁਕਿੰਗ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਦੀ ਹੈ; ਜੇ ਨਹੀਂ, ਤਾਂ 404 ਵਾਪਸ ਕਰੋ। ਬੇਨਤੀ ਬਾਡੀ ਵਿੱਚੋਂ ਯੂਜ਼ਰ ID ਜਾਂ ਰੋਲ ਕਦੇ ਸਵੀਕਾਰ ਨਾ ਕਰੋ। POST /api/bookings ਨੂੰ ਪ੍ਰਤੀ ਯੂਜ਼ਰ ਪ੍ਰਤੀ ਮਿੰਟ 20 ਤੱਕ ਸੀਮਤ ਕਰੋ। ਸਰਵਰ 'ਤੇ ਗ਼ਲਤੀਆਂ ਲੌਗ ਕਰੋ, ਪਰ ਸਟੈਕ ਟਰੇਸ ਵਾਪਸ ਨਾ ਕਰੋ।
ਦਸਤਾਵੇਜ਼:
ਇਨ੍ਹਾਂ ਰੂਟਾਂ ਦਾ OpenAPI ਵੇਰਵਾ ਲਿਖੋ, ਅਤੇ ਹਰ ਇੱਕ ਲਈ ਉਦਾਹਰਨ ਬੇਨਤੀਆਂ ਅਤੇ ਜਵਾਬਾਂ ਵਾਲਾ ਛੋਟਾ README ਲਿਖੋ।
ਆਪਣੇ API ਦੀ ਜਾਂਚ
ਫ਼ਰੰਟਐਂਡ ਤੋਂ ਬਾਹਰੋਂ ਟੈਸਟ ਕਰੋ, ਕਿਉਂਕਿ ਹਮਲਾਵਰ ਵੀ ਇੰਝ ਹੀ ਕਰਨਗੇ:
- ਹਰ ਰੂਟ ਸਹੀ ਇਨਪੁੱਟ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਦਸਤਾਵੇਜ਼ੀ ਢਾਂਚਾ ਤੇ ਕੋਡ ਵਾਪਸ ਕਰਦਾ ਹੈ
- ਗੁੰਮ ਜਾਂ ਗ਼ਲਤ ਫ਼ੀਲਡਾਂ 'ਤੇ ਸਾਫ਼ ਸੁਨੇਹੇ ਨਾਲ 400 ਮਿਲਦਾ ਹੈ
- ਹਰ ਸੁਰੱਖਿਅਤ ਰੂਟ 'ਤੇ ਟੋਕਨ ਨਾ ਹੋਣ 'ਤੇ 401 ਮਿਲਦਾ ਹੈ
- ਯੂਜ਼ਰ A ਵੱਲੋਂ ਯੂਜ਼ਰ B ਦਾ ID ਨਾਲ ਰਿਕਾਰਡ ਮੰਗਣ 'ਤੇ 404 ਜਾਂ 403 ਮਿਲਦਾ ਹੈ
- ਸੂਚੀਆਂ ਪੇਜੀਨੇਟਡ ਹਨ, ਅਤੇ ਬਹੁਤ ਵੱਡੀ
limitਸੀਮਤ ਹੋ ਜਾਂਦੀ ਹੈ - ਡੁਪਲੀਕੇਟ ਜਾਂ ਟਕਰਾਅ ਵਾਲੀਆਂ ਬਣਾਉਣ ਦੀਆਂ ਬੇਨਤੀਆਂ 409 ਦਿੰਦੀਆਂ ਹਨ, 500 ਨਹੀਂ
- ਰੇਟ ਲਿਮਿਟ 'ਤੇ 429 ਮਿਲਦਾ ਹੈ
- ਗ਼ਲਤੀ ਜਵਾਬਾਂ ਵਿੱਚ ਸਟੈਕ ਟਰੇਸ, SQL ਜਾਂ ਗੁਪਤ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੁੰਦੀ
- CORS ਸਿਰਫ਼ ਉਨ੍ਹਾਂ ਔਰਿਜਿਨ ਨੂੰ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ
ਆਮ ਗ਼ਲਤੀਆਂ
- ਲੌਗਇਨ ਚੈੱਕ ਕਰਨਾ, ਪਰ ਮਾਲਕੀ ਨਹੀਂ। ਸਭ ਤੋਂ ਆਮ API ਛੇਕ: ਕੋਈ ਵੀ ਲੌਗਇਨ ਯੂਜ਼ਰ ID ਬਦਲ ਕੇ ਕਿਸੇ ਵੀ ਰਿਕਾਰਡ ਨੂੰ ਪੜ੍ਹ ਸਕਦਾ ਹੈ।
- ਕਲਾਇੰਟ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ। ਬੇਨਤੀ ਬਾਡੀ ਦੀਆਂ ਕੀਮਤਾਂ, ਰੋਲ ਅਤੇ ਯੂਜ਼ਰ ID ਬਦਲੇ ਜਾ ਸਕਦੇ ਹਨ।
- ਪੂਰੀਆਂ ਡੇਟਾਬੇਸ ਕਤਾਰਾਂ ਵਾਪਸ ਕਰਨਾ। ਪਾਸਵਰਡ ਹੈਸ਼ ਅਤੇ ਅੰਦਰੂਨੀ ਫ਼ੀਲਡਾਂ ਲੀਕ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਹਰ ਜਵਾਬ ਵਿੱਚ ਕੀ ਜਾਵੇ, ਇਹ ਤੈਅ ਕਰੋ।
- ਬੇਹੱਦ ਸੂਚੀਆਂ। ਹਰ ਰਿਕਾਰਡ ਲਈ ਇੱਕ ਬੇਨਤੀ ਪੂਰੀ ਐਪ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦੀ ਹੈ।
- ਗ਼ਲਤੀ ਅੰਦਰ ਰੱਖ ਕੇ
200 OK। ਕਲਾਇੰਟ ਅਤੇ ਮਾਨੀਟਰਿੰਗ ਨੂੰ ਪਤਾ ਨਹੀਂ ਲੱਗਦਾ ਕਿ ਇਹ ਫ਼ੇਲ੍ਹ ਹੋਇਆ। - CORS ਸਭ ਕੁਝ ਇਜਾਜ਼ਤ ਦੇਣ ਲਈ ਸੈੱਟ ਉਸ API 'ਤੇ ਜੋ ਕੁਕੀਜ਼ ਵਰਤਦਾ ਹੈ।
- ਕੋਈ ਹੈਲਥ ਚੈੱਕ ਜਾਂ ਲੌਗ ਨਹੀਂ, ਇਸ ਲਈ ਆਊਟੇਜ ਦਾ ਪਤਾ ਯੂਜ਼ਰਾਂ ਤੋਂ ਲੱਗਦਾ ਹੈ।
ਲਾਂਚ ਤੋਂ ਪਹਿਲਾਂ ਵਿਆਪਕ ਜਾਂਚ ਲਈ, AI ਨਾਲ ਬਣੀਆਂ ਐਪਾਂ ਲਈ ਸੁਰੱਖਿਆ ਚੈੱਕਲਿਸਟ ਵੇਖੋ।
Mythex ਵਿੱਚ REST API ਬਣਾਉਣਾ
ਤੁਸੀਂ Mythex ਤੋਂ ਆਪਣੀ ਐਪ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਜਾਂ ਵੱਖਰੀ ਸੇਵਾ ਵਜੋਂ API ਮੰਗ ਸਕਦੇ ਹੋ। ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ REST API ਬੈਕਐਂਡ ਰੈਸਿਪੀ ਵਿੱਚ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਮਪਟ ਹੈ: ਆਪਣਾ ਫ਼ਰੇਮਵਰਕ ਅਤੇ ਰੂਟ ਦੱਸੋ, ਸਾਫ਼ JSON ਗਲਤੀਆਂ ਮੰਗੋ, ਸੀਕ੍ਰੇਟਸ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਰੱਖੋ, ਅਤੇ ਇੱਕ Dockerfile ਸ਼ਾਮਲ ਕਰੋ। Node, Python, C#, Java ਅਤੇ ਹੋਰਾਂ ਵਿੱਚ ਕੰਟੇਨਰ ਬੈਕਐਂਡ Dockerfile ਰਾਹੀਂ ਪ੍ਰਕਾਸ਼ਿਤ ਹੁੰਦੇ ਹਨ, ਅਤੇ Mythex Publish ਤੋਂ ਡਿਪਲੋਏ ਸੰਭਾਲਦਾ ਹੈ (API ਬੈਕਐਂਡ)। ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਵੈੱਬਸਾਈਟ ਅਤੇ API ਨਾਲ-ਨਾਲ ਚੱਲ ਸਕਦੇ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਪ੍ਰੀਵਿਊ ਵਿੱਚ ਉਹਨਾਂ ਵਿਚਕਾਰ ਬਦਲ ਸਕਦੇ ਹੋ। ਕੁੰਜੀਆਂ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਸੀਕ੍ਰੇਟਸ ਵਜੋਂ ਰੱਖੋ, ਅਤੇ ਜੇ API ਨੂੰ ਡੇਟਾਬੇਸ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਚੈਟ ਵਿੱਚ ਮੰਗੋ: ਹਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਆਪਣਾ Postgres ਡੇਟਾਬੇਸ ਹੋ ਸਕਦਾ ਹੈ, ਜੋ ਹਰ ਯੋਜਨਾ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ। ਏਜੰਟ API ਦੀ ਜਾਂਚ ਵੀ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ Pro ਤੇ ਤੁਸੀਂ ਐਡੀਟਰ ਅਤੇ ਟਰਮੀਨਲ ਵਿੱਚ ਆਪ ਕੋਡ ਸੰਪਾਦਿਤ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਇਸਨੂੰ ਦੋ-ਪਾਸੜ GitHub ਸਿੰਕ ਵਿੱਚ ਰੱਖ ਸਕਦੇ ਹੋ। ਆਪਣੇ API ਦੇ ਆਲੇ-ਦੁਆਲੇ ਨਿਰਧਾਰਤ ਕੰਮਾਂ ਲਈ, ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬ ਕਿਵੇਂ ਚਲਾਈਏ ਦੇਖੋ।
ਸਵਾਲ
REST API ਕੀ ਹੁੰਦਾ ਹੈ?
REST API ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਤੁਹਾਡੀ ਐਪ ਦੇ ਡੇਟਾ ਨਾਲ HTTP ਰਾਹੀਂ ਕੰਮ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ। ਹਰ ਕਿਸਮ ਦਾ ਡੇਟਾ ਆਪਣੇ URL ਵਾਲਾ ਇੱਕ ਰਿਸੋਰਸ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ `/orders`, ਅਤੇ ਮਿਆਰੀ ਮੈਥਡ ਉਸ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ: ਪੜ੍ਹਨ ਲਈ GET, ਬਣਾਉਣ ਲਈ POST, ਬਦਲਣ ਲਈ PATCH ਜਾਂ PUT, ਅਤੇ ਹਟਾਉਣ ਲਈ DELETE। ਡੇਟਾ ਆਮ ਤੌਰ 'ਤੇ JSON ਵਿੱਚ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।
REST API ਕਿਹੜੀ ਭਾਸ਼ਾ ਵਿੱਚ ਬਣਾਵਾਂ?
ਉਹ ਭਾਸ਼ਾ ਵਰਤੋ ਜੋ ਤੁਸੀਂ ਜਾਂ ਤੁਹਾਡੀ ਟੀਮ ਸੰਭਾਲ ਸਕੇ। Express ਜਾਂ Fastify ਵਾਲਾ Node.js, FastAPI ਵਾਲਾ Python, ਅਤੇ C# ਜਾਂ Java ਫ਼ਰੇਮਵਰਕ ਸਾਰੇ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ। ਰੂਟਾਂ, ਸਟੇਟਸ ਕੋਡਾਂ, ਵੈਲੀਡੇਸ਼ਨ ਅਤੇ ਪ੍ਰਮਾਣੀਕਰਨ ਦੇ ਡਿਜ਼ਾਈਨ ਨਿਯਮ ਭਾਸ਼ਾ ਨਾਲੋਂ ਵੱਧ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ। Mythex Node, Python, Java, C# ਜਾਂ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਵਿੱਚ API ਚਲਾਉਂਦਾ ਹੈ ਜੋ Dockerfile ਤੋਂ ਵੈੱਬ ਸਰਵਰ ਵਜੋਂ ਚੱਲ ਸਕੇ, ਇਸ ਲਈ ਤੁਸੀਂ ਉਹ ਚੁਣ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ।
ਮੈਂ REST API ਨੂੰ ਕਿਵੇਂ ਸੁਰੱਖਿਅਤ ਕਰਾਂ?
ਹਰ ਗ਼ੈਰ-ਜਨਤਕ ਰੂਟ 'ਤੇ ਪ੍ਰਮਾਣੀਕਰਨ ਲਾਜ਼ਮੀ ਕਰੋ, ਸਰਵਰ 'ਤੇ ਜਾਂਚੋ ਕਿ ਕਾਲ ਕਰਨ ਵਾਲਾ ਹਰ ਖ਼ਾਸ ਰਿਕਾਰਡ ਤੱਕ ਪਹੁੰਚ ਸਕਦਾ ਹੈ ਜਾਂ ਨਹੀਂ, ਸਾਰੇ ਇਨਪੁੱਟ ਦੀ ਵੈਲੀਡੇਸ਼ਨ ਕਰੋ, HTTPS ਵਰਤੋ, ਬੇਨਤੀਆਂ ਦੀ ਗਿਣਤੀ ਸੀਮਤ ਕਰੋ, ਅਤੇ ਗੁਪਤ ਜਾਣਕਾਰੀ ਨੂੰ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਰੱਖੋ। ਕਲਾਇੰਟ ਵੱਲੋਂ ਭੇਜੇ ਗਏ ID ਜਾਂ ਰੋਲ 'ਤੇ ਕਦੇ ਭਰੋਸਾ ਨਾ ਕਰੋ।
ਕੀ REST API ਲਈ ਵੱਖਰੀ ਬੈਕਐਂਡ ਦੀ ਲੋੜ ਹੈ?
ਹਮੇਸ਼ਾ ਨਹੀਂ। Next.js ਵਰਗੇ ਫ਼ਰੇਮਵਰਕ ਪੰਨਿਆਂ ਦੇ ਨਾਲ-ਨਾਲ API ਰੂਟ ਵੀ ਦੇ ਸਕਦੇ ਹਨ। ਵੱਖਰੀ API ਸੇਵਾ ਉਦੋਂ ਸਮਝਦਾਰੀ ਹੈ ਜਦੋਂ ਕਈ ਕਲਾਇੰਟ (ਵੈੱਬ, ਮੋਬਾਈਲ, ਭਾਗੀਦਾਰ) ਇਸਨੂੰ ਵਰਤਣ, ਜਾਂ ਜਦੋਂ ਇਸਨੂੰ ਆਪਣੀ ਭਾਸ਼ਾ ਜਾਂ ਸਕੇਲਿੰਗ ਚਾਹੀਦੀ ਹੋਵੇ। Mythex ਵਿੱਚ ਇੱਕ ਵੈੱਬਸਾਈਟ ਅਤੇ ਇੱਕ API ਇੱਕੋ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਰਹਿ ਸਕਦੇ ਹਨ ਅਤੇ ਇਕੱਠੇ ਪ੍ਰਕਾਸ਼ਿਤ ਹੋ ਸਕਦੇ ਹਨ।