ਆਪਣੀ ਐਪ ਵਿੱਚ API ਕੁੰਜੀਆਂ ਸੁਰੱਖਿਅਤ ਕਿਵੇਂ ਰੱਖੀਏ
API ਕੁੰਜੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਲਈ, ਉਨ੍ਹਾਂ ਨੂੰ ਆਪਣੇ ਹੋਸਟ 'ਤੇ ਸੀਕ੍ਰੇਟ ਜਾਂ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਵਜੋਂ ਸੰਭਾਲੋ, ਸਿਰਫ਼ ਸਰਵਰ ਵਾਲੇ ਕੋਡ ਵਿੱਚ ਵਰਤੋ, ਅਤੇ ਕਦੇ ਵੀ ਚੈਟ, ਕੋਡ ਫਾਈਲਾਂ, ਸਕ੍ਰੀਨਸ਼ਾਟਾਂ ਜਾਂ Git ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਨਾ ਪਾਓ। ਹਰ ਕੁੰਜੀ ਨੂੰ ਉਤਨੀ ਹੀ ਇਜਾਜ਼ਤ ਦਿਓ ਜਿੰਨੀ ਉਸਨੂੰ ਚਾਹੀਦੀ ਹੈ, ਪ੍ਰਦਾਤਾ 'ਤੇ ਖਰਚ ਸੀਮਾਵਾਂ ਸੈੱਟ ਕਰੋ, ਅਤੇ ਜੇ ਕੋਈ ਕੁੰਜੀ ਕਦੇ ਲੀਕ ਹੋਵੇ, ਤਾਂ ਉਸਨੂੰ ਬਦਲੋ — ਨਵੀਂ ਬਣਾਓ ਅਤੇ ਪੁਰਾਣੀ ਮਿਟਾਓ — ਨਾ ਕਿ ਸਿਰਫ਼ ਉਹ ਥਾਂ ਲੁਕਾਓ ਜਿੱਥੇ ਉਹ ਦਿਖੀ ਸੀ।
ਇੱਕ API ਕੁੰਜੀ ਕਿਸੇ ਸੇਵਾ ਲਈ ਪਾਸਵਰਡ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਡੀ OpenAI ਕੁੰਜੀ ਕਿਸੇ ਨੂੰ ਤੁਹਾਡੇ ਪੈਸੇ AI 'ਤੇ ਖਰਚਣ ਦਿੰਦੀ ਹੈ; ਤੁਹਾਡੀ Stripe ਸੀਕ੍ਰੇਟ ਕੁੰਜੀ ਕਿਸੇ ਨੂੰ ਰਿਫੰਡ ਜਾਰੀ ਕਰਨ ਦਿੰਦੀ ਹੈ; ਤੁਹਾਡੀ ਈਮੇਲ ਪ੍ਰਦਾਤਾ ਦੀ ਕੁੰਜੀ ਕਿਸੇ ਨੂੰ ਤੁਹਾਡੇ ਨਾਂ 'ਤੇ ਮੇਲ ਭੇਜਣ ਦਿੰਦੀ ਹੈ। AI ਐਪ ਬਿਲਡਰ ਇਨ੍ਹਾਂ ਨੂੰ ਜੋੜਨ ਵਿੱਚ ਮਾਹਿਰ ਹਨ, ਪਰ ਹਮੇਸ਼ਾ ਇਹ ਧਿਆਨ ਨਹੀਂ ਰੱਖਦੇ ਕਿ ਇਹ ਕਿੱਥੇ ਪਹੁੰਚਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਗਾਈਡ ਦੱਸਦੀ ਹੈ ਕਿ ਇਨ੍ਹਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਿਵੇਂ ਰੱਖਣਾ ਹੈ ਅਤੇ ਕਿਵੇਂ ਜਾਂਚਣਾ ਹੈ।
ਜਨਤਕ ਕੁੰਜੀਆਂ ਬਨਾਮ ਸੀਕ੍ਰੇਟ ਕੁੰਜੀਆਂ
ਹਰ ਕੁੰਜੀ ਸੀਕ੍ਰੇਟ ਨਹੀਂ ਹੁੰਦੀ। ਫਰਕ ਜਾਣਨ ਨਾਲ ਤੁਸੀਂ ਗਲਤ ਕੁੰਜੀ ਲਈ ਘਬਰਾਉਣ ਅਤੇ ਸਹੀ ਕੁੰਜੀ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਤੋਂ ਬਚਦੇ ਹੋ।
| ਕਿਸਮ | ਉਦਾਹਰਨਾਂ | ਕੀ ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੋ ਸਕਦੀ ਹੈ? |
|---|---|---|
| Publishable / ਜਨਤਕ ਕੁੰਜੀਆਂ | Stripe pk_… ਕੁੰਜੀ, ਸਿਰਫ਼ ਤੁਹਾਡੇ ਡੋਮੇਨ ਲਈ ਸੀਮਿਤ ਮੈਪ ਕੁੰਜੀ, ਕੁਝ ਐਨਾਲਿਟਿਕਸ ID | ਹਾਂ — ਇਸੇ ਲਈ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ |
| ਸੀਕ੍ਰੇਟ ਕੁੰਜੀਆਂ | Stripe sk_…, OpenAI ਅਤੇ Anthropic ਕੁੰਜੀਆਂ, ਈਮੇਲ ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਕੁੰਜੀਆਂ, ਡੇਟਾਬੇਸ ਪਾਸਵਰਡ | ਕਦੇ ਨਹੀਂ |
| ਸਰਵਿਸ/ਐਡਮਿਨ ਕੁੰਜੀਆਂ | ਉਹ ਕੁੰਜੀਆਂ ਜੋ ਹੋਸਟ ਕੀਤੇ ਡੇਟਾਬੇਸ 'ਤੇ ਪਹੁੰਚ ਨਿਯਮਾਂ ਨੂੰ ਪਾਸ ਕਰਦੀਆਂ ਹਨ | ਕਦੇ ਨਹੀਂ — ਸਭ ਤੋਂ ਸੰਵੇਦਨਸ਼ੀਲ ਸਮਝੋ |
ਜੇ ਤੁਹਾਨੂੰ ਪੱਕਾ ਨਹੀਂ ਕਿ ਕੋਈ ਕੁੰਜੀ ਕਿਸ ਕਿਸਮ ਦੀ ਹੈ, ਤਾਂ ਪ੍ਰਦਾਤਾ ਦਾ ਦਸਤਾਵੇਜ਼ ਜਾਂਚੋ। ਸ਼ੱਕ ਹੋਵੇ ਤਾਂ ਇਸਨੂੰ ਸੀਕ੍ਰੇਟ ਸਮਝੋ।
ਕਦਮ 1: ਕੁੰਜੀਆਂ ਨੂੰ ਕੋਡ ਤੋਂ ਬਾਹਰ, ਸੀਕ੍ਰੇਟ ਵਜੋਂ ਰੱਖੋ
ਕੁੰਜੀਆਂ ਤੁਹਾਡੇ ਹੋਸਟ ਦੀਆਂ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਜਾਂ ਸੀਕ੍ਰੇਟ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਤੁਹਾਡਾ ਕੋਡ ਚੱਲਣ ਸਮੇਂ ਨਾਮ ਨਾਲ ਉਨ੍ਹਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ process.env.OPENAI_API_KEY), ਇਸ ਲਈ ਮੁੱਲ ਤੁਹਾਡੀਆਂ ਫਾਈਲਾਂ ਵਿੱਚ ਕਦੇ ਨਹੀਂ ਦਿਸਦਾ। ਪਿਛੋਕੜ ਲਈ, ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਅਤੇ ਸੀਕ੍ਰੇਟ ਕੀ ਹਨ ਦੇਖੋ।
ਕੋਡ ਵਿੱਚੋਂ ਹਰ API ਕੁੰਜੀ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲਾਂ ਵਿੱਚ ਲੈ ਜਾਓ। ਹਰ ਕੁੰਜੀ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਤੁਸੀਂ ਲੱਭੀ, ਉਹ ਕਿਹੜੀ ਫਾਈਲ ਵਿੱਚ ਸੀ, ਅਤੇ ਤੁਸੀਂ ਕਿਹੜਾ ਵੇਰੀਏਬਲ ਨਾਮ ਵਰਤਿਆ। ਮੈਨੂੰ ਮੁੱਲ ਨਾ ਦਿਖਾਓ।
ਫਿਰ ਜਾਂਚੋ ਕਿ ਕੁਝ ਬਾਕੀ ਨਹੀਂ:
ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਖੋਜੋ, ਕੌਂਫਿਗ ਫਾਈਲਾਂ ਅਤੇ ਕਿਸੇ ਵੀ .env ਫਾਈਲ ਸਮੇਤ, ਹਰ ਉਸ ਚੀਜ਼ ਲਈ ਜੋ API ਕੁੰਜੀ ਜਾਂ ਪਾਸਵਰਡ ਵਰਗੀ ਲੱਗਦੀ ਹੈ। ਫਾਈਲ ਅਤੇ ਲਾਈਨ ਦੱਸੋ, ਮੁੱਲ ਨਹੀਂ।
ਕਦਮ 2: ਸੀਕ੍ਰੇਟ ਕੁੰਜੀਆਂ ਸਿਰਫ਼ ਸਰਵਰ 'ਤੇ ਵਰਤੋ
ਇਹ ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ ਨਿਯਮ ਹੈ। ਜੋ ਵੀ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਮਿਲਦਾ ਹੈ, ਉਹ ਕੋਈ ਵੀ ਵਿਜ਼ਟਰ ਪੜ੍ਹ ਸਕਦਾ ਹੈ — ਪੇਜ ਸੋਰਸ ਅਤੇ JavaScript ਫਾਈਲਾਂ ਸਭ ਡਿਵੈਲਪਰ ਟੂਲਜ਼ ਵਿੱਚ ਦਿਸਦੀਆਂ ਹਨ।
ਇਸ ਲਈ ਜੇ ਐਪ ਨੂੰ OpenAI ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੈ, ਤਾਂ ਬ੍ਰਾਊਜ਼ਰ ਤੁਹਾਡੇ ਸਰਵਰ ਨੂੰ ਕਾਲ ਕਰੇ, ਅਤੇ ਤੁਹਾਡਾ ਸਰਵਰ ਕੁੰਜੀ ਨਾਲ OpenAI ਨੂੰ ਕਾਲ ਕਰੇ। ਕੁੰਜੀ ਕਦੇ ਸਰਵਰ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਂਦੀ।
ਚੈਟ ਫੀਚਰ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਸਿੱਧਾ OpenAI ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਉਸ ਕਾਲ ਨੂੰ ਸਰਵਰ API ਰੂਟ ਵਿੱਚ ਲੈ ਜਾਓ ਜੋ ਐਨਵਾਇਰਨਮੈਂਟ ਤੋਂ OPENAI_API_KEY ਪੜ੍ਹਦਾ ਹੈ। ਬ੍ਰਾਊਜ਼ਰ ਸਿਰਫ਼ ਸਾਡੇ ਰੂਟ ਨੂੰ ਕਾਲ ਕਰੇ। ਰੂਟ ਲਈ ਲੌਗਇਨ ਲਾਜ਼ਮੀ ਕਰੋ।
ਫਰੰਟਐਂਡ ਫਰੇਮਵਰਕਾਂ ਵਿੱਚ ਇੱਕ ਆਮ ਜਾਲ ਵੇਖੋ: ਜਨਤਕ ਪ੍ਰੀਫਿਕਸ ਵਾਲੇ ਵੇਰੀਏਬਲ — Vite ਵਿੱਚ VITE_, Next.js ਵਿੱਚ NEXT_PUBLIC_ — ਜਾਣਬੁੱਝ ਕੇ ਬ੍ਰਾਊਜ਼ਰ ਕੋਡ ਵਿੱਚ ਬਣਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਪ੍ਰੀਫਿਕਸਾਂ ਵਾਲੀ ਸੀਕ੍ਰੇਟ ਕੁੰਜੀ ਜਨਤਕ ਹੋ ਜਾਂਦੀ ਹੈ, ਭਾਵੇਂ ਉਹ "ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਵਿੱਚ" ਹੋਵੇ।
ਕਦਮ 3: ਜਾਂਚੋ ਕਿ ਕੁਝ ਲੀਕ ਨਹੀਂ ਹੋ ਰਿਹਾ
ਇਹ ਭਰੋਸਾ ਨਾ ਕਰੋ ਕਿ ਇਹ ਕੰਮ ਕਰ ਗਿਆ ਹੈ — ਲਾਈਵ ਸਾਈਟ ਜਾਂਚੋ:
- ਪ੍ਰਕਾਸ਼ਿਤ ਐਪ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਖੋਲ੍ਹੋ।
- ਡਿਵੈਲਪਰ ਟੂਲਜ਼ ਖੋਲ੍ਹੋ, ਫਿਰ Sources ਜਾਂ Network ਟੈਬ।
- ਹਰ ਸੀਕ੍ਰੇਟ ਕੁੰਜੀ ਦੇ ਪਹਿਲੇ ਅੱਖਰ (ਉਦਾਹਰਨ ਲਈ
sk_ਜਾਂsk-) ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਵਿੱਚ ਖੋਜੋ। - ਐਪ ਦੀਆਂ ਨੈੱਟਵਰਕ ਬੇਨਤੀਆਂ ਜਾਂਚੋ। ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਸਿੱਧੀ ਕਿਸੇ ਭੁਗਤਾਨ ਵਾਲੇ AI ਪ੍ਰਦਾਤਾ ਨੂੰ ਜਾਣ ਵਾਲੀ ਬੇਨਤੀ ਖਤਰੇ ਦਾ ਨਿਸ਼ਾਨ ਹੈ।
ਜੇ ਤੁਹਾਨੂੰ ਕੋਈ ਸੀਕ੍ਰੇਟ ਕੁੰਜੀ ਮਿਲਦੀ ਹੈ, ਤਾਂ ਉਸਨੂੰ ਸਰਵਰ 'ਤੇ ਲਿਜਾਓ (ਕਦਮ 2) ਅਤੇ ਬਦਲੋ (ਕਦਮ 6), ਕਿਉਂਕਿ ਉਹ ਪਹਿਲਾਂ ਹੀ ਜਨਤਕ ਹੋ ਚੁੱਕੀ ਸੀ।
ਕਦਮ 4: ਹਰ ਕੁੰਜੀ ਕੀ ਕਰ ਸਕਦੀ ਹੈ, ਉਹ ਸੀਮਿਤ ਕਰੋ
ਬਹੁਤ ਸਾਰੇ ਪ੍ਰਦਾਤਾ ਤੁਹਾਨੂੰ ਕੁੰਜੀ ਸੀਮਿਤ ਕਰਨ ਦਿੰਦੇ ਹਨ:
- ਸਕੋਪ ਕੀਤੀਆਂ ਜਾਂ ਸੀਮਿਤ ਕੁੰਜੀਆਂ ਜੋ ਸਿਰਫ਼ ਉਹੀ ਕਰ ਸਕਣ ਜੋ ਤੁਹਾਡੀ ਐਪ ਨੂੰ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, Stripe ਖਾਸ ਇਜਾਜ਼ਤਾਂ ਵਾਲੀਆਂ ਸੀਮਿਤ ਕੁੰਜੀਆਂ ਦਿੰਦਾ ਹੈ।
- ਡੋਮੇਨ ਜਾਂ IP ਸੀਮਾਵਾਂ ਉਨ੍ਹਾਂ ਕੁੰਜੀਆਂ ਲਈ ਜੋ ਜਨਤਕ ਹੋਣੀਆਂ ਹੀ ਹਨ, ਜਿਵੇਂ ਮੈਪ ਕੁੰਜੀਆਂ।
- ਹਰ ਐਪ ਅਤੇ ਹਰ ਮਾਹੌਲ ਲਈ ਵੱਖਰੀਆਂ ਕੁੰਜੀਆਂ, ਤਾਂ ਜੋ ਇੱਕ ਲੀਕ ਸਭ ਕੁਝ ਉਜਾਗਰ ਨਾ ਕਰੇ, ਅਤੇ ਇੱਕ ਨੂੰ ਰੱਦ ਕਰਨ ਨਾਲ ਬਾਕੀ ਨਾ ਟੁੱਟਣ।
- ਬਣਾਉਂਦੇ ਸਮੇਂ ਟੈਸਟ ਕੁੰਜੀਆਂ, ਅਤੇ ਲਾਈਵ ਕੁੰਜੀਆਂ ਸਿਰਫ਼ ਪ੍ਰਕਾਸ਼ਿਤ ਐਪ ਵਿੱਚ।
ਕਦਮ 5: ਨੁਕਸਾਨ ਦੀ ਹੱਦ ਤੈਅ ਕਰੋ
ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੁਰੱਖਿਅਤ ਕੁੰਜੀ ਵੀ ਤੁਹਾਡੀ ਆਪਣੀ ਐਪ ਰਾਹੀਂ ਦੁਰਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ — ਉਦਾਹਰਨ ਲਈ, ਕੋਈ ਤੁਹਾਡੇ AI ਫੀਚਰ ਨੂੰ ਹਜ਼ਾਰਾਂ ਵਾਰ ਸਕ੍ਰਿਪਟ ਰਾਹੀਂ ਚਲਾ ਰਿਹਾ ਹੋਵੇ।
- ਹਰ ਪੇਡ ਪ੍ਰਦਾਤਾ 'ਤੇ ਖਰਚ ਸੀਮਾਵਾਂ ਜਾਂ ਅਲਰਟ ਸੈੱਟ ਕਰੋ।
- ਕਿਸੇ ਵੀ ਫੀਚਰ ਲਈ ਲੌਗਇਨ ਲਾਜ਼ਮੀ ਕਰੋ ਜੋ ਹਰ ਕਾਲ 'ਤੇ ਪੈਸੇ ਖਰਚਦਾ ਹੈ।
- ਇੱਕ ਪ੍ਰਤੀ-ਵਰਤੋਂਕਾਰ ਰੇਟ ਲਿਮਿਟ ਜੋੜੋ। ਦੇਖੋ ਰੇਟ ਲਿਮਿਟਿੰਗ ਕੀ ਹੈ।
/api/chat 'ਤੇ ਹਰ ਵਰਤੋਂਕਾਰ ਲਈ ਪ੍ਰਤੀ ਘੰਟਾ 30 AI ਬੇਨਤੀਆਂ ਦੀ ਸੀਮਾ ਜੋੜੋ। ਸੀਮਾ ਪਹੁੰਚਣ 'ਤੇ ਸਾਫ਼ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੋ। ਜੋ ਵਰਤੋਂਕਾਰ ਲੌਗਇਨ ਨਹੀਂ ਹਨ, ਉਨ੍ਹਾਂ ਦੀਆਂ ਬੇਨਤੀਆਂ ਰੱਦ ਕਰੋ।
ਕਦਮ 6: ਲੀਕ ਹੋਈਆਂ ਕੁੰਜੀਆਂ ਬਦਲੋ
ਜੇ ਕੋਈ ਸੀਕ੍ਰੇਟ ਕੁੰਜੀ ਉਸ ਥਾਂ ਦਿਸਦੀ ਹੈ ਜਿੱਥੇ ਉਸਨੂੰ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ — ਚੈਟ ਸੁਨੇਹਾ, ਕਮਿਟ, ਸਕ੍ਰੀਨਸ਼ਾਟ, ਸਪੋਰਟ ਟਿਕਟ, ਬ੍ਰਾਊਜ਼ਰ ਕੋਡ — ਤਾਂ ਉਸਨੂੰ ਸਮਝੌਤਾ ਹੋਇਆ ਮੰਨੋ।
- ਪ੍ਰਦਾਤਾ 'ਤੇ ਨਵੀਂ ਕੁੰਜੀ ਬਣਾਓ।
- ਆਪਣੀ ਐਪ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਸੀਕ੍ਰੇਟ ਅੱਪਡੇਟ ਕਰੋ।
- ਰੀ-ਡਿਪਲੌਏ ਜਾਂ ਦੁਬਾਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ ਤਾਂ ਜੋ ਲਾਈਵ ਐਪ ਨਵੀਂ ਕੁੰਜੀ ਵਰਤੇ।
- ਪ੍ਰਦਾਤਾ 'ਤੇ ਪੁਰਾਣੀ ਕੁੰਜੀ ਮਿਟਾਓ।
- ਪ੍ਰਦਾਤਾ ਦੇ ਵਰਤੋਂ ਲੌਗ ਜਾਂਚੋ ਕਿ ਕੋਈ ਅਜਿਹੀ ਗਤੀਵਿਧੀ ਤਾਂ ਨਹੀਂ ਜੋ ਤੁਹਾਨੂੰ ਪਛਾਣੀ ਨਾ ਲੱਗੇ।
ਚੈਟ ਸੁਨੇਹਾ ਜਾਂ Git ਕਮਿਟ ਮਿਟਾਉਣਾ ਕਾਫ਼ੀ ਨਹੀਂ। Git ਇਤਿਹਾਸ ਪੁਰਾਣੇ ਵਰਜਨ ਰੱਖਦਾ ਹੈ, ਅਤੇ ਜੋ ਵੀ ਜਨਤਕ ਹੋਇਆ ਹੋਵੇ ਉਹ ਨਕਲ ਹੋ ਚੁੱਕਾ ਹੋ ਸਕਦਾ ਹੈ।
ਆਮ ਗਲਤੀਆਂ
- ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਕੁੰਜੀ ਪੇਸਟ ਕਰਨਾ। ਹੁਣ ਉਹ ਚੈਟ ਇਤਿਹਾਸ ਵਿੱਚ ਹੈ। ਇਸ ਦੀ ਥਾਂ ਸੀਕ੍ਰੇਟ ਫਾਰਮ ਵਰਤੋ।
- ਸੀਕ੍ਰੇਟ ਵੇਰੀਏਬਲ 'ਤੇ ਜਨਤਕ ਪ੍ਰੀਫਿਕਸ।
VITE_OPENAI_API_KEYਕੁੰਜੀ ਹਰ ਵਿਜ਼ਟਰ ਤੱਕ ਪਹੁੰਚਾ ਦਿੰਦਾ ਹੈ। .envਫਾਈਲ ਕਮਿਟ ਕਰਨਾ। ਪਹਿਲੇ ਪੁਸ਼ ਤੋਂ ਪਹਿਲਾਂ ਪੱਕਾ ਕਰੋ ਕਿ ਇਹ.gitignoreਵਿੱਚ ਹੈ।- ਹਰ ਥਾਂ ਇੱਕੋ ਕੁੰਜੀ। ਟੈਸਟ ਅਤੇ ਲਾਈਵ ਲਈ, ਅਤੇ ਹਰ ਐਪ ਲਈ ਵੱਖਰੀਆਂ ਕੁੰਜੀਆਂ ਵਰਤੋ।
- ਕੋਈ ਖਰਚ ਸੀਮਾ ਨਾ ਹੋਣਾ। ਲੀਕ ਜਾਂ ਦੁਰਵਰਤੀ ਕੁੰਜੀ ਜਿਸ 'ਤੇ ਕੋਈ ਹੱਦ ਨਹੀਂ, ਤੁਹਾਡੇ ਧਿਆਨ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਵੱਡਾ ਬਿੱਲ ਬਣਾ ਸਕਦੀ ਹੈ।
- ਲੁਕਾਉਣਾ, ਬਦਲਣਾ ਨਹੀਂ। ਇੱਕ ਵਾਰ ਕੁੰਜੀ ਜਨਤਕ ਹੋ ਜਾਵੇ, ਤਾਂ ਸਿਰਫ਼ ਨਵੀਂ ਕੁੰਜੀ ਹੀ ਇਸਨੂੰ ਠੀਕ ਕਰਦੀ ਹੈ।
- ਸਕ੍ਰੀਨਸ਼ਾਟਾਂ ਵਿੱਚ ਕੁੰਜੀਆਂ। ਮਦਦ ਲਈ ਸਾਂਝਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸੈਟਿੰਗ ਪੇਜ ਕੱਟੋ ਜਾਂ ਧੁੰਦਲੇ ਕਰੋ।
ਚੈੱਕਲਿਸਟ
- ਹਰ ਕੁੰਜੀ ਸੀਕ੍ਰੇਟ ਜਾਂ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਵਜੋਂ ਸੰਭਾਲੀ ਗਈ ਹੈ, ਕੋਡ ਵਿੱਚ ਨਹੀਂ।
- ਕੋਈ
.envਫਾਈਲ ਜਾਂ ਕੁੰਜੀ Git ਵਿੱਚ ਕਮਿਟ ਨਹੀਂ ਹੋਈ। - ਸੀਕ੍ਰੇਟ ਕੁੰਜੀਆਂ ਸਿਰਫ਼ ਸਰਵਰ ਵਾਲੇ ਕੋਡ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
- ਕੋਈ ਸੀਕ੍ਰੇਟ ਵੇਰੀਏਬਲ
VITE_ਜਾਂNEXT_PUBLIC_ਵਰਗਾ ਜਨਤਕ ਪ੍ਰੀਫਿਕਸ ਨਹੀਂ ਵਰਤਦਾ। - ਲਾਈਵ ਸਾਈਟ ਦੇ JavaScript ਵਿੱਚ ਹਰ ਕੁੰਜੀ ਦਾ ਪ੍ਰੀਫਿਕਸ ਖੋਜਿਆ ਅਤੇ ਕੁਝ ਨਹੀਂ ਮਿਲਿਆ।
- ਜਿੱਥੇ ਪ੍ਰਦਾਤਾ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਕੁੰਜੀਆਂ ਸਕੋਪ ਜਾਂ ਸੀਮਿਤ ਹਨ।
- ਟੈਸਟ ਅਤੇ ਲਾਈਵ ਕੁੰਜੀਆਂ ਵੱਖਰੀਆਂ ਹਨ।
- ਪੇਡ ਫੀਚਰਾਂ ਲਈ ਲੌਗਇਨ ਅਤੇ ਪ੍ਰਤੀ-ਵਰਤੋਂਕਾਰ ਸੀਮਾਵਾਂ ਹਨ।
- ਹਰ ਪੇਡ ਪ੍ਰਦਾਤਾ 'ਤੇ ਖਰਚ ਸੀਮਾ ਜਾਂ ਅਲਰਟ ਹੈ।
- ਮੈਨੂੰ ਪਤਾ ਹੈ ਕਿ ਹਰ ਕੁੰਜੀ ਕਿਵੇਂ ਬਦਲਣੀ ਹੈ, ਅਤੇ ਜੋ ਵੀ ਕਦੇ ਜਨਤਕ ਹੋਈ, ਉਸਨੂੰ ਬਦਲਿਆ ਗਿਆ ਹੈ।
Mythex 'ਤੇ ਕੁੰਜੀਆਂ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ
Mythex ਕੁੰਜੀਆਂ ਨੂੰ ਤੁਹਾਡੇ ਕੋਡ ਅਤੇ ਚੈਟ ਤੋਂ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਬਾਹਰ ਰੱਖਦਾ ਹੈ:
- ਸੀਕ੍ਰੇਟ ਬੇਨਤੀ ਕਾਰਡ। ਜਦੋਂ ਏਜੰਟ ਨੂੰ ਕੁੰਜੀ ਚਾਹੀਦੀ ਹੈ, ਉਹ ਚੈਟ ਵਿੱਚ ਇੱਕ ਕਾਰਡ ਦਿਖਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਮੁੱਲ ਫਾਰਮ ਫੀਲਡਾਂ ਵਿੱਚ ਭਰਦੇ ਹੋ, ਸੁਨੇਹਾ ਬਾਕਸ ਵਿੱਚ ਨਹੀਂ, ਅਤੇ ਇਹ ਪ੍ਰੋਜੈਕਟ ਸੀਕ੍ਰੇਟ ਵਜੋਂ ਸੰਭਾਲੀ ਜਾਂਦੀ ਹੈ। ਦੇਖੋ Secrets in chat।
- Project settings → Secrets, ਜਾਂ ਚੈਟ ਵਿੱਚ
/secrets, ਤਾਂ ਜੋ ਤੁਸੀਂ ਖੁਦ ਕੁੰਜੀਆਂ ਜੋੜੋ ਜਾਂ ਬਦਲੋ। ਦੇਖੋ Environment variables and secrets।
ਪ੍ਰਕਾਸ਼ਿਤ ਐਪ ਲਈ ਸੀਕ੍ਰੇਟ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਦੁਬਾਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ ਤਾਂ ਜੋ ਲਾਈਵ ਐਪ ਉਸਨੂੰ ਲਵੇ। ਐਕਸਪੋਰਟ ਕੀਤੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਸੀਕ੍ਰੇਟ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦੇ, ਇਸ ਲਈ ਜਿੱਥੇ ਵੀ ਕੋਡ ਚਲਾਓ ਉੱਥੇ ਉਨ੍ਹਾਂ ਨੂੰ ਮੁੜ ਜੋੜੋ। ਜੇ ਕੋਈ ਕੁੰਜੀ ਕਦੇ ਚੈਟ ਵਿੱਚ ਦਿਸ ਜਾਵੇ, ਤਾਂ ਪ੍ਰਦਾਤਾ 'ਤੇ ਉਸਨੂੰ ਬਦਲੋ।
ਪ੍ਰੀ-ਲਾਂਚ ਸੁਰੱਖਿਆ ਦੇ ਬਾਕੀ ਕੰਮ ਲਈ, AI ਨਾਲ ਬਣੀਆਂ ਐਪਾਂ ਲਈ ਸੁਰੱਖਿਆ ਚੈੱਕਲਿਸਟ ਦੇਖੋ। ਜੇ ਤੁਸੀਂ AI ਫੀਚਰ ਜੋੜ ਰਹੇ ਹੋ, ਤਾਂ LLM APIs ਕਿਵੇਂ ਵਰਤੀਏ ਕੁੰਜੀਆਂ ਅਤੇ ਲਾਗਤਾਂ ਬਾਰੇ ਹੋਰ ਵਿਸਥਾਰ ਨਾਲ ਦੱਸਦਾ ਹੈ।
ਸਵਾਲ
ਕੀ ਫਰੰਟਐਂਡ ਕੋਡ ਵਿੱਚ API ਕੁੰਜੀ ਪਾਉਣੀ ਸੁਰੱਖਿਅਤ ਹੈ?
ਸਿਰਫ਼ ਉਦੋਂ ਜਦੋਂ ਪ੍ਰਦਾਤਾ ਨੇ ਉਸ ਕੁੰਜੀ ਨੂੰ ਜਨਤਕ ਹੋਣ ਲਈ ਬਣਾਇਆ ਹੋਵੇ, ਜਿਵੇਂ Stripe ਦੀ publishable key ਜਾਂ ਸਿਰਫ਼ ਤੁਹਾਡੇ ਡੋਮੇਨ ਲਈ ਸੀਮਿਤ ਮੈਪ ਕੁੰਜੀ। ਕੋਈ ਵੀ ਕੁੰਜੀ ਜੋ ਪੈਸੇ ਖਰਚ ਸਕਦੀ ਹੈ ਜਾਂ ਨਿੱਜੀ ਡੇਟਾ ਪੜ੍ਹ ਸਕਦੀ ਹੈ, ਸਰਵਰ 'ਤੇ ਹੀ ਰਹਿਣੀ ਚਾਹੀਦੀ ਹੈ, ਕਿਉਂਕਿ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਭੇਜੀ ਹਰ ਚੀਜ਼ ਕੋਈ ਵੀ ਪੜ੍ਹ ਸਕਦਾ ਹੈ।
ਜੇ ਮੈਂ API ਕੁੰਜੀ ਕਿਸੇ ਚੈਟ ਜਾਂ ਜਨਤਕ ਰਿਪੋ ਵਿੱਚ ਪੇਸਟ ਕਰ ਦਿੱਤੀ ਹੋਵੇ ਤਾਂ ਮੈਂ ਕੀ ਕਰਾਂ?
ਉਸਨੂੰ ਬਦਲੋ: ਪ੍ਰਦਾਤਾ 'ਤੇ ਨਵੀਂ ਕੁੰਜੀ ਬਣਾਓ, ਆਪਣੀ ਐਪ ਦੇ ਸੀਕ੍ਰੇਟ ਅੱਪਡੇਟ ਕਰੋ, ਦੁਬਾਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ, ਫਿਰ ਪੁਰਾਣੀ ਕੁੰਜੀ ਮਿਟਾਓ। ਸੁਨੇਹਾ ਜਾਂ ਕਮਿਟ ਮਿਟਾਉਣਾ ਕਾਫ਼ੀ ਨਹੀਂ, ਕਿਉਂਕਿ ਨਕਲਾਂ ਪਹਿਲਾਂ ਹੀ ਬਣ ਚੁੱਕੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।
API ਕੁੰਜੀਆਂ ਕਿੱਥੇ ਸੰਭਾਲਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ?
ਆਪਣੇ ਹੋਸਟ ਦੀਆਂ ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ ਜਾਂ ਸੀਕ੍ਰੇਟ ਸੈਟਿੰਗਾਂ ਵਿੱਚ, ਜੋ ਸਰਵਰ ਵਾਲਾ ਕੋਡ ਚੱਲਣ ਸਮੇਂ ਪੜ੍ਹਦਾ ਹੈ। ਇਹ ਸੋਰਸ ਫਾਈਲਾਂ ਵਿੱਚ ਨਹੀਂ ਲਿਖੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ, Git ਵਿੱਚ ਕਮਿਟ ਨਹੀਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ, ਅਤੇ ਸਕ੍ਰੀਨਸ਼ਾਟਾਂ ਵਿੱਚ ਨਹੀਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ।
ਮੈਂ ਕਿਵੇਂ ਪਤਾ ਕਰਾਂ ਕਿ ਮੇਰੀ ਵੈੱਬਸਾਈਟ ਵਿੱਚ API ਕੁੰਜੀ ਜਨਤਕ ਹੋ ਗਈ ਹੈ?
ਆਪਣੀ ਲਾਈਵ ਸਾਈਟ ਖੋਲ੍ਹੋ, ਪੇਜ ਸੋਰਸ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਡਿਵੈਲਪਰ ਟੂਲਜ਼ ਵਿੱਚ JavaScript ਫਾਈਲਾਂ ਵੇਖੋ, ਅਤੇ ਕੁੰਜੀ ਦੀ ਸ਼ੁਰੂਆਤ ਲੱਭੋ। ਜੇ ਇਹ ਦਿਸਦੀ ਹੈ, ਤਾਂ ਇਹ ਜਨਤਕ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਰਵਰ 'ਤੇ ਲਿਜਾ ਕੇ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ।