ਕੰਟੇਨਰਾਈਜ਼ੇਸ਼ਨ: ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ ਨਾਲ ਡੌਕਰਫਾਈਲ ਅਤੇ ਚਿੱਤਰ ਅਨੁਕੂਲਤਾ

ਲਾਭ:

• ਕੰਟੇਨਰ ਅਤੇ ਡੌਕਰਫਾਈਲ ਸੰਕਲਪਾਂ, ਬੁਨਿਆਦੀ ਨਿਰਦੇਸ਼ਾਂ ਅਤੇ ਲੇਅਰ ਤਰਕ ਨੂੰ ਸਮਝਣ ਦੀ ਸਮਰੱਥਾ, ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਪੈਦਾ ਕਰਨ ਲਈ ਤਿਆਰ ਡੌਕਰਫਾਈਲ ਹੈ
• ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਅਤੇ ਛੋਟੇ ਬੇਸ ਚਿੱਤਰ ਦੇ ਨਾਲ ਚਿੱਤਰ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਤੈਨਾਤੀ ਦੀ ਗਤੀ ਅਤੇ ਸੁਰੱਖਿਆ ਨੂੰ ਵਧਾਉਣ ਦੀ ਸਮਰੱਥਾ
• ਚਿੱਤਰ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਏਮਬੈਡ ਨਾ ਕਰਨ, ਇਸਨੂੰ ਰੂਟ ਦੀ ਬਜਾਏ ਇੱਕ ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ ਨਾਲ ਚਲਾਉਣ, ਅਤੇ ਚਿੱਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨ ਦੇ ਸੁਰੱਖਿਆ ਸਿਧਾਂਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

ਵਾਕ "ਇਹ ਮੇਰੇ ਕੰਪਿਊਟਰ 'ਤੇ ਚੱਲ ਰਿਹਾ ਸੀ" ਸਾਫਟਵੇਅਰ ਦੇ ਇਤਿਹਾਸ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹਿੰਗਾ ਵਾਕ ਹੈ। ਵੱਖ-ਵੱਖ ਲਾਇਬ੍ਰੇਰੀ ਸੰਸਕਰਣ ਦੇ ਕਾਰਨ ਇੱਕ ਵੱਖਰੇ ਸਰਵਰ 'ਤੇ ਇੱਕੋ ਕੋਡ ਫਟਦਾ ਹੈ। ਕੰਟੇਨਰ ਤਕਨਾਲੋਜੀ ਬਿਲਕੁਲ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦੀ ਹੈ: ਇਹ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਹਰ ਉਸ ਚੀਜ਼ ਨਾਲ ਰੱਖਦਾ ਹੈ ਜਿਸਦੀ ਇਸਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜ ਹੁੰਦੀ ਹੈ — ਲਾਇਬ੍ਰੇਰੀਆਂ, ਰਨਟਾਈਮ, ਸੈਟਿੰਗਾਂ — ਇੱਕ ਸਿੰਗਲ ਪੋਰਟੇਬਲ ਪੈਕੇਜ ਵਿੱਚ। ਇਹ ਪੈਕੇਜ ਹਰ ਜਗ੍ਹਾ ਬਿਲਕੁਲ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਕਰਦਾ ਹੈ। ਸਭ ਤੋਂ ਆਮ ਕੰਟੇਨਰ ਟੂਲ ਡੌਕਰ ਹੈ।

ਇੱਕ ਕੰਟੇਨਰ ਦੇ ਵਰਣਨ ਨੂੰ ਡੌਕਰਫਾਈਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ: ਇਹ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਕਿਸ ਅਧਾਰ ਚਿੱਤਰ ਤੋਂ ਸ਼ੁਰੂ ਹੋਵੇਗੀ, ਕਿਹੜੀਆਂ ਫਾਈਲਾਂ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਵੇਗੀ, ਅਤੇ ਕਿਹੜੀਆਂ ਕਮਾਂਡਾਂ ਚੱਲਣਗੀਆਂ। ਇਸ ਵਿਅੰਜਨ ਤੋਂ ਇੱਕ ਚਿੱਤਰ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ; ਜਦੋਂ ਚਿੱਤਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਇੱਕ ਕੰਟੇਨਰ ਬਣ ਜਾਂਦਾ ਹੈ। AI ਇੱਕ ਡੌਕਰਫਾਈਲ ਲਿਖਣ ਵਿੱਚ ਬਹੁਤ ਕੁਸ਼ਲ ਹੈ ਅਤੇ - ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ - ਇਸਨੂੰ ਘੱਟ ਕਰਨ ਅਤੇ ਸੁਰੱਖਿਅਤ ਕਰਨ ਵਿੱਚ. ਪਰ ਇਹ ਸਮਝਣਾ ਤੁਹਾਡਾ ਕੰਮ ਹੈ ਕਿ ਤਿਆਰ ਕੀਤੀ ਵਿਅੰਜਨ ਕੀ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਕਿੱਥੇ ਭੇਦ ਲੀਕ ਕਰ ਸਕਦੀ ਹੈ।

ਡੌਕਰਫਾਈਲ ਦੀਆਂ ਬੁਨਿਆਦੀ ਹਦਾਇਤਾਂ

ਇੱਕ ਡੌਕਰਫਾਈਲ ਦਾ ਆਡਿਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਬੁਨਿਆਦੀ ਹਦਾਇਤਾਂ ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

• `From`: ਆਧਾਰ ਚਿੱਤਰ ਚੁਣਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ python:3.12-slim)। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਚਿੱਤਰ ਦਾ ਆਕਾਰ ਅਤੇ ਸੁਰੱਖਿਆ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਆਉਂਦੀ ਹੈ।
• 'WORKDIR': ਕਾਰਜਸ਼ੀਲ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ।
• `COPY` / `ADD`: ਫ਼ਾਈਲਾਂ ਨੂੰ ਚਿੱਤਰ ਵਿੱਚ ਕਾਪੀ ਕਰਦਾ ਹੈ।
• `ਰਨ`: ਬਿਲਡ ਦੇ ਦੌਰਾਨ ਇੱਕ ਕਮਾਂਡ ਚਲਾਉਂਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਨਿਰਭਰਤਾ ਸਥਾਪਤ ਕਰਦਾ ਹੈ)। ਹਰ RUN ਇੱਕ ਨਵੀਂ ਲੇਅਰ ਬਣਾਉਂਦਾ ਹੈ।
• 'ENV': ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।
• 'ਐਕਸਪੋਜ਼': ਉਹ ਦਸਤਾਵੇਜ਼ ਜਿਨ੍ਹਾਂ 'ਤੇ ਕੰਟੇਨਰ ਸੁਣ ਰਿਹਾ ਹੈ।
• `CMD` / `ENTRYPOINT`: ਉਹ ਕਮਾਂਡ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਜੋ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਹੋਣ 'ਤੇ ਚੱਲੇਗੀ।

ਇੱਕ ਨਾਜ਼ੁਕ ਧਾਰਨਾ ਲੇਅਰ ਹੈ: ਡੌਕਰ ਹਰੇਕ ਹਦਾਇਤ ਨੂੰ ਇੱਕ ਲੇਅਰ ਵਜੋਂ ਕੈਸ਼ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਵਾਰ-ਵਾਰ ਬਦਲਦੇ ਕਦਮਾਂ ਨੂੰ ਅੰਤ ਵਿੱਚ ਪਾਉਂਦੇ ਹੋ, ਤਾਂ ਨਾ ਬਦਲਣ ਵਾਲੀਆਂ ਪਰਤਾਂ ਕੈਸ਼ ਤੋਂ ਆ ਜਾਣਗੀਆਂ ਅਤੇ ਬਿਲਡ ਤੇਜ਼ ਹੋ ਜਾਵੇਗਾ।

ਸੰਕੇਤ: ਚਿੱਤਰ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣ ਲਈ ਦੋ ਸਭ ਤੋਂ ਵੱਡੇ ਲੀਵਰ ਹਨ: (1) ਇੱਕ ਛੋਟਾ ਅਧਾਰ ਚਿੱਤਰ ਚੁਣਨਾ ਜਿਵੇਂ ਕਿ ਪਤਲਾ ਜਾਂ ਅਲਪਾਈਨ; (2) ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ — ਇੱਕ ਪੜਾਅ 'ਤੇ ਬਿਲਡ ਟੂਲਸ ਨੂੰ ਛੱਡਣਾ ਅਤੇ ਸਿਰਫ ਫਾਈਨਲ ਉਤਪਾਦ ਨੂੰ ਇੱਕ ਪਤਲੇ ਚਿੱਤਰ ਵਿੱਚ ਪੋਰਟ ਕਰਨਾ। AI ਜਦੋਂ ਵੀ ਚਾਹੇ ਇਨ੍ਹਾਂ ਦੋਵਾਂ ਨੂੰ ਮੁਹਾਰਤ ਨਾਲ ਲਾਗੂ ਕਰ ਸਕਦਾ ਹੈ।

ਛੋਟਾ ਚਿੱਤਰ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ? ਕਿਉਂਕਿ ਚਿੱਤਰ ਦਾ ਆਕਾਰ ਕੇਵਲ ਇੱਕ ਡਿਸਕ ਮੁੱਦਾ ਨਹੀਂ ਹੈ. ਇੱਕ ਵੱਡੀ ਤਸਵੀਰ ਨੂੰ ਹਰੇਕ ਤੈਨਾਤੀ ਦੇ ਨਾਲ ਖਿੱਚਣ ਵਿੱਚ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਰਜਿਸਟਰੀ ਵਿੱਚ ਵਧੇਰੇ ਜਗ੍ਹਾ ਲੈਂਦੀ ਹੈ, ਨਵੇਂ ਪੌਡਾਂ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਨੂੰ ਹੌਲੀ ਕਰ ਦਿੰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਸਕੇਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਵਧੇਰੇ ਪੈਕੇਜ ਹੁੰਦੇ ਹਨ, ਇਹ ਇੱਕ ਵੱਡੀ ਹਮਲੇ ਵਾਲੀ ਸਤਹ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ — ਯਾਨੀ ਹਮਲਾਵਰ ਦਾ ਸ਼ੋਸ਼ਣ ਕਰਨ ਲਈ ਖੁੱਲ੍ਹੀ ਥਾਂ। 1 GB ਚਿੱਤਰ ਦੀ ਬਜਾਏ 100 MB ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ; ਇਹ ਤੈਨਾਤੀ ਦੇ ਸਮੇਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਲਾਗਤ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਆ ਵਧਾਉਂਦਾ ਹੈ। ਇੱਕ ਡੌਕਰਫਾਈਲ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਇਹਨਾਂ ਤਿੰਨਾਂ ਲਾਭਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਪ੍ਰਾਪਤ ਕਰ ਰਿਹਾ ਹੈ. ਇੱਕ ਅਨੁਕੂਲਿਤ ਡੌਕਰਫਾਈਲ ਲਈ ਏਆਈ ਨੂੰ ਪੁੱਛਣ ਵੇਲੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ "ਸਭ ਤੋਂ ਛੋਟਾ ਅੰਤਮ ਚਿੱਤਰ" ਟੀਚਾ ਦੱਸੋ; ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਸੰਕਲਨ ਪੜਾਅ ਨੂੰ ਵੱਖ ਕਰਨ ਅਤੇ ਬੇਲੋੜੇ ਪੈਕੇਜਾਂ ਨੂੰ ਰੱਦ ਕਰਨ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ।

ਕਦਮ-ਦਰ-ਕਦਮ: ਏਆਈ ਨਾਲ ਡੌਕਰਫਾਈਲ ਤਿਆਰ ਕਰਨਾ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਣਾ

1. ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਵਰਣਨ ਕਰੋ। ਭਾਸ਼ਾ, ਸੰਸਕਰਣ, ਇਨਪੁਟ ਕਮਾਂਡ, ਸੁਣਿਆ ਪੋਰਟ।
2. ਪਹਿਲਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰੋ। ਇੱਕ ਸਧਾਰਨ ਕੰਮ ਕਰਨ ਵਾਲੀ ਡੌਕਰਫਾਈਲ ਦੀ ਬੇਨਤੀ ਕਰੋ।
3. ਇਸਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ। ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ, ਮਾਈਨਰ ਬੇਸ ਇਮੇਜ ਅਤੇ ਲੇਅਰ ਆਰਡਰ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਲਈ ਸਮਾਨ AI ਨੂੰ ਪੁੱਛੋ।
4. ਸੁਰੱਖਿਆ ਦੀ ਜਾਂਚ ਕਰੋ। ਕੀ ਗੁਪਤ ਏਮਬੇਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਕੀ ਇਹ ਰੂਟ ਦੇ ਤੌਰ ਤੇ ਚਲਦਾ ਹੈ, ਕੀ ਕੋਈ ਬੇਲੋੜੇ ਸਾਧਨ ਹਨ?
5. ਬਣਾਓ ਅਤੇ ਆਕਾਰ ਨੂੰ ਮਾਪੋ. ਡੌਕਰ ਬਿਲਡ ਤੋਂ ਬਾਅਦ ਡੌਕਰ ਚਿੱਤਰਾਂ ਦੇ ਨਾਲ ਆਕਾਰ ਦੇਖੋ.
6. ਸਕੈਨ ਕਰੋ। ਡੌਕਰ ਸਕਾਊਟ ਜਾਂ ਟ੍ਰੀਵੀ ਵਰਗੇ ਸ਼ੋਸ਼ਣ ਸਕੈਨਰ ਨਾਲ ਜਾਣੀਆਂ ਗਈਆਂ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਜਾਂਚ ਕਰੋ।

ਸੁਰੱਖਿਆ: ਕੰਟੇਨਰ-ਵਿਸ਼ੇਸ਼ ਜੋਖਮ

ਕੰਟੇਨਰ ਸੁਰੱਖਿਆ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਤਿੰਨ ਨਿਯਮ:

1. ਚਿੱਤਰ ਵਿੱਚ ਸੀਕਰੇਟ ਨੂੰ ਏਮਬੈਡ ਨਾ ਕਰੋ। ENV API_KEY=... ਜਾਂ COPY .env ਵਰਗੀਆਂ ਲਾਈਨਾਂ ਸਥਾਈ ਤੌਰ 'ਤੇ ਚਿੱਤਰ ਦੀਆਂ ਪਰਤਾਂ ਦਾ ਰਾਜ਼ ਲਿਖਦੀਆਂ ਹਨ; ਚਿੱਤਰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਕੋਈ ਵੀ ਇਸ ਨੂੰ ਪੜ੍ਹ ਸਕਦਾ ਹੈ। ਰਨਟਾਈਮ 'ਤੇ ਇੱਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਵਜੋਂ ਜਾਂ ਵਾਲਟ ਤੋਂ ਗੁਪਤ ਦਿਓ।
2. ਰੂਟ ਵਜੋਂ ਚੱਲ ਰਿਹਾ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਕੰਟੇਨਰ ਰੂਟ ਦੇ ਤੌਰ ਤੇ ਚੱਲਦੇ ਹਨ; ਇੱਕ ਖੁੱਲਾ ਕੰਟੇਨਰ ਤੋਂ ਬਚਣ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। USER ਹਿਦਾਇਤ ਦੇ ਨਾਲ ਇੱਕ ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ ਕੋਲ ਸੁੱਟੋ।
3. ਛੋਟਾ ਅਤੇ ਅੱਪ-ਟੂ-ਡੇਟ ਆਧਾਰ ਚਿੱਤਰ। ਫੁੱਲੇ ਹੋਏ ਚਿੱਤਰ ਦੋਵੇਂ ਹੌਲੀ ਹੁੰਦੇ ਹਨ ਅਤੇ ਵਧੇਰੇ ਕਮਜ਼ੋਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਸਲਿਮ/ਅਲਪਾਈਨ ਚੁਣੋ, ਸੰਸਕਰਣ ਨੂੰ ਠੀਕ ਕਰੋ (:latest ਨਾ ਵਰਤੋ)।

ਸਾਵਧਾਨ: ਭਾਵੇਂ ਤੁਸੀਂ RUN ਵਿੱਚ ਇੱਕ ਗੁਪਤ ਵਰਤਦੇ ਹੋ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਮਿਟਾਉਂਦੇ ਹੋ, ਇਹ ਮਿਡਲਵੇਅਰ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਡੌਕਰ ਇਤਿਹਾਸ ਦੁਆਰਾ ਵਾਪਸ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਬਿਲਡ ਦੇ ਦੌਰਾਨ ਇੱਕ ਗੁਪਤ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਡੌਕਰ ਦੀ --secret ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਨਾ ਕਿ ENV/COPY।

ਅਨੁਕੂਲਨ ਪ੍ਰਭਾਵ ਸਾਰਣੀ

ਤਕਨੀਕੀ

ਕੀ ਕਰਦਾ ਹੈ

ਆਮ ਪ੍ਰਭਾਵ

ਪਤਲਾ/ਅਲਪਾਈਨ ਬੇਸ ਚਿੱਤਰ

ਬੇਲੋੜੇ ਪੈਕੇਜਾਂ ਨੂੰ ਰੱਦ ਕਰਦਾ ਹੈ

900MB → 120MB

ਬਹੁ-ਪੜਾਅ ਦਾ ਨਿਰਮਾਣ

ਬਿਲਡ ਟੂਲ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ

700MB → 90MB

.dockerignore

ਬਿਲਡ ਵਿੱਚ ਬੇਲੋੜੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰਦਾ ਹੈ

ਤੇਜ਼ ਨਿਰਮਾਣ, ਛੋਟਾ ਸੰਦਰਭ

ਟੀਅਰ ਛਾਂਟੀ

ਕੈਸ਼ ਹਿੱਟ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ

5 ਮਿੰਟ → 40 ਸਕਿੰਟ ਬਣਾਓ

ਸੰਸਕਰਣ ਫਿਕਸਿੰਗ (:15)

ਦੁਹਰਾਉਣਯੋਗਤਾ + ਸੁਰੱਖਿਆ

ਅਚਾਨਕ ਵਿਗੜਨ ਨੂੰ ਰੋਕਦਾ ਹੈ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 — 1.1 GB ਚਿੱਤਰ ਨੂੰ 95 MB ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਗਿਆ। ਇੱਕ ਟੀਮ ਦਾ Node.js ਚਿੱਤਰ 1.1 GB ਸੀ; ਹਰੇਕ ਤੈਨਾਤੀ ਵਿੱਚ ਮਿੰਟ ਲੱਗ ਗਏ। ਉਹਨਾਂ ਨੇ AI ਨੂੰ ਕਿਹਾ "ਇਸ ਨੂੰ ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਅਤੇ ਐਲਪਾਈਨ ਨਾਲ ਅਨੁਕੂਲ ਬਣਾਓ"। AI ਨੇ ਸੰਕਲਨ ਪੜਾਅ ਨੂੰ ਵੱਖ ਕੀਤਾ ਅਤੇ ਸਿਰਫ ਤਿਆਰ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪਤਲੇ ਚਿੱਤਰ ਵਿੱਚ ਭੇਜਿਆ; ਨਤੀਜਾ 95 MB ਸੀ, ਤੈਨਾਤੀ ਸਮਾਂ ਇੱਕ ਤਿਹਾਈ ਘੱਟ ਗਿਆ।

ਕੇਸ 2 - ਦੱਬਿਆ ਹੋਇਆ ਰਾਜ਼ ਫੜਿਆ ਗਿਆ। ਇੱਕ ਇੰਜੀਨੀਅਰ ਨੇ YZ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਡੌਕਰਫਾਈਲ ਵਿੱਚ ਲਾਈਨ ENV DB_PASSWORD=prod_secret ਨੂੰ ਦੇਖਿਆ। ਏਆਈ ਨੇ ਚਿੱਤਰ ਵਿੱਚ ਪਾਸਵਰਡ ਏਮਬੈਡ ਕੀਤਾ ਸੀ ਤਾਂ ਜੋ ਇਹ "ਕੰਮ" ਕਰੇ। ਇੰਜੀਨੀਅਰ ਨੇ ਇਸਨੂੰ ਹਟਾ ਦਿੱਤਾ ਅਤੇ ਇਸਨੂੰ ਰਨਟਾਈਮ 'ਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਤੋਂ ਪਾਸਵਰਡ ਪੜ੍ਹਨ ਲਈ ਬਦਲ ਦਿੱਤਾ। ਨਹੀਂ ਤਾਂ, ਚਿੱਤਰ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਵਾਲਾ ਕੋਈ ਵੀ ਵਿਅਕਤੀ ਪਾਸਵਰਡ ਪੜ੍ਹ ਸਕਦਾ ਹੈ।

ਕੇਸ 3 - ਰੂਟ ਤੋਂ ਬਚਣ ਦਾ ਜੋਖਮ। ਇੱਕ ਸਕੈਨਿੰਗ ਟੂਲ ਨੇ ਦੱਸਿਆ ਕਿ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਗਈ ਤਸਵੀਰ ਰੂਟ ਦੇ ਰੂਪ ਵਿੱਚ ਚੱਲ ਰਹੀ ਸੀ ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਗੰਭੀਰ ਕਮਜ਼ੋਰੀ ਹੈ। ਟੀਮ ਨੇ USER ਐਪਯੂਜ਼ਰ ਨੂੰ ਜੋੜਿਆ ਅਤੇ ਬੇਸ ਚਿੱਤਰ ਨੂੰ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਵਿੱਚ ਧੱਕਿਆ; ਸਕੈਨ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ। ਪਾਠ: ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਚਿੱਤਰ ਨੂੰ ਸਕੈਨ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਸਾਹਮਣੇ ਪ੍ਰਗਟ ਕਰੋ।

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ

1) ਅਨੁਕੂਲਿਤ ਡੌਕਰਫਾਈਲ ਤਿਆਰ ਕਰਨਾ:

[LANGUAGE/FRAMEWORK] ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਪ੍ਰੋਡਕਸ਼ਨ-ਤਿਆਰ ਡੌਕਰਫਾਈਲ ਲਿਖੋ। ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼:- ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਦੀ ਵਰਤੋਂ ਕਰੋ; ਅੰਤਮ ਚਿੱਤਰ ਨੂੰ ਸਭ ਤੋਂ ਛੋਟਾ ਬਣਾਓ।- ਬੇਸ ਚਿੱਤਰ ਪਤਲਾ/ਅਲਪਾਈਨ ਹੈ ਅਤੇ ਸੰਸਕਰਣ ਫਿਕਸ ਹੈ (":ਨਵੀਨਤਮ" ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ)।- ਕੰਟੇਨਰ ਨੂੰ ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ ਨਾਲ ਚਲਾਓ, ਰੂਟ ਨਾਲ ਨਹੀਂ।- ਚਿੱਤਰ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਕਦੇ ਵੀ ਸ਼ਾਮਲ ਨਾ ਕਰੋ; ਰਨਟਾਈਮ 'ਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਉਡੀਕ ਕਰੋ। - .dockerignore ਸੁਝਾਅ ਸ਼ਾਮਲ ਕਰੋ। ਇਨਪੁਟ ਕਮਾਂਡ: [X], ਸੁਣਨ ਵਾਲਾ ਪੋਰਟ: [Y]।

2) ਮੌਜੂਦਾ ਡੌਕਰਫਾਈਲ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਓ:

ਘੱਟ ਕਰਨ ਅਤੇ ਗਤੀ ਵਧਾਉਣ ਲਈ ਇਸ ਡੌਕਰਫਾਈਲ ਨੂੰ ਦੇਖੋ। ਲੇਅਰ ਆਰਡਰ, ਮਲਟੀ-ਫੇਜ਼ ਬਿਲਡ, ਬੇਸ ਇਮੇਜ ਅਤੇ ਰਿਡੰਡੈਂਟ ਪੈਕੇਜਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਠੋਸ ਤਬਦੀਲੀਆਂ ਦੀ ਸਿਫਾਰਸ਼ ਕਰੋ; ਹਰੇਕ ਬਦਲਾਅ ਦੇ ਅੰਦਾਜ਼ਨ ਆਕਾਰ/ਗਤੀ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਲਿਖੋ। ਡੌਕਰਫਾਈਲ: [CONTENT]

3) ਸੁਰੱਖਿਆ ਆਡਿਟ:

ਸੁਰੱਖਿਆ ਲਈ ਇਸ ਡੌਕਰਫਾਈਲ ਦੀ ਜਾਂਚ ਕਰੋ: ਕੀ ਇੱਥੇ ਕੋਈ ਏਮਬੇਡ ਕੀਤੇ ਰਾਜ਼, ਰੂਟ ਉਪਭੋਗਤਾ, ਅਨਫਿਕਸਡ ਸੰਸਕਰਣ, ਬੇਲੋੜੇ ਟੂਲ, ਪੁਰਾਣੇ ਅਧਾਰ ਚਿੱਤਰ ਹਨ? ਖੋਜਾਂ ਨੂੰ ਮਹੱਤਵ ਅਤੇ ਕਿਸੇ ਵੀ ਸੁਧਾਰ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਸੂਚੀਬੱਧ ਕਰੋ। ਡੌਕਰਫਾਈਲ: [CONTENT]

4) ਗਲਤੀ ਹੱਲ ਕਰਨਾ:

ਇਸ ਡੌਕਰ ਬਿਲਡ ਗਲਤੀ ਦਾ ਕੀ ਕਾਰਨ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕਰਨਾ ਹੈ? ਮੈਨੂੰ ਮੂਲ ਕਾਰਨ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਤਬਦੀਲੀਆਂ ਨਾਲ ਹੱਲ ਦੱਸੋ। ਅਸਲ ਮੁੱਲ ਪੈਦਾ ਨਾ ਕਰੋ ਜਿੱਥੇ ਤੁਸੀਂ ਗੁਪਤ ਦੇਖਦੇ ਹੋ, ਪਲੇਸਹੋਲਡਰ ਦੀ ਵਰਤੋਂ ਕਰੋ. ਗਲਤੀ: [LOG] ਡੌਕਰਫਾਈਲ: [CONTENT]

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਮੇਰੀ ਨੋਡ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਡੌਕਰਫਾਈਲ ਲਿਖੋ।"

ਨਤੀਜਾ: ਵਿਸ਼ਾਲ ਅਧਾਰ ਚਿੱਤਰ, ਰੂਟ ਉਪਭੋਗਤਾ, ਸਿੰਗਲ ਪੜਾਅ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਗੁਪਤ ਲਈ ਕਮਜ਼ੋਰ; ਆਕਾਰ ਅਤੇ ਸੁਰੱਖਿਆ ਲਈ ਵਿਚਾਰ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਆਉਟਪੁੱਟ।

ਮਜ਼ਬੂਤ: "ਮੇਰੀ ਨੋਡ 20 ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਪ੍ਰੋਡਕਸ਼ਨ-ਰੈਡੀ ਡੌਕਰਫਾਈਲ ਲਿਖੋ: ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ, ਨੋਡ: 20-ਅਲਪਾਈਨ ਬੇਸ ਇਮੇਜ (ਵਰਜਨ ਫਿਕਸ), ਅਣਅਧਿਕਾਰਤ ਯੂਜ਼ਰ ਨਾਲ ਚਲਾਓ, ਗੁਪਤ ਏਮਬੈਡਿੰਗ, ਪੋਰਟ 3000 'ਤੇ ਸੁਣਨਾ, ਲੌਗਇਨ ਨੋਡ dist/server.js। ਵੀ ਸੁਝਾਅ ਦਿਓ।"

ਅੰਤਰ: ਦੂਜਾ ਪ੍ਰੋਂਪਟ ਸੰਸਕਰਣ ਅਨੁਕੂਲਨ ਤਕਨੀਕ, ਸੁਰੱਖਿਆ ਨਿਯਮ ਅਤੇ ਲਾਗਇਨ ਕਮਾਂਡ ਦਿੰਦਾ ਹੈ; ਆਉਟਪੁੱਟ ਛੋਟਾ, ਸੁਰੱਖਿਅਤ ਅਤੇ ਸਿੱਧੇ ਵਰਤੋਂ ਯੋਗ ਬਣ ਜਾਂਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• `ENV`/`COPY` ਨਾਲ ਚਿੱਤਰ ਵਿੱਚ ਰਾਜ਼ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ। ਇਹ ਲੇਅਰਾਂ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਵਾਪਸ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ.
• ਰੂਟ ਵਜੋਂ ਚੱਲ ਰਿਹਾ ਹੈ। USER ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਛੱਡਣਾ ਇੱਕ ਗੰਭੀਰ ਸੁਰੱਖਿਆ ਜੋਖਮ ਹੈ।
• `:ਨਵੀਨਤਮ` ਦੀ ਵਰਤੋਂ ਕਰਨਾ। ਇਹ ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ ਨਿਰਮਾਣ ਅਤੇ ਅਚਾਨਕ ਰੁਕਾਵਟਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ।
• ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਨੂੰ ਛੱਡਣਾ। ਕੰਪਾਈਲੇਸ਼ਨ ਟੂਲ ਬੇਲੋੜੇ ਅੰਤਮ ਚਿੱਤਰ ਨੂੰ ਫੁੱਲ ਦਿੰਦੇ ਹਨ।
• `.dockerignore` ਨਾ ਲਿਖੋ। ਵੱਡੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਜਿਵੇਂ ਕਿ .git ਅਤੇ node_modules ਬਿਲਡ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ।
• ਚਿੱਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤੇ ਬਿਨਾਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ। ਉਹਨਾਂ ਨੂੰ ਮਹਿਸੂਸ ਕੀਤੇ ਬਿਨਾਂ ਜਾਣੀਆਂ ਗਈਆਂ ਕਮਜ਼ੋਰੀਆਂ ਪੈਦਾ ਕਰਨਾ।

ਸੰਖੇਪ ਵਿੱਚ

ਕੰਟੇਨਰ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਪੋਰਟੇਬਲ ਪੈਕੇਜਾਂ ਵਿੱਚ ਪਾਉਂਦੇ ਹਨ ਜੋ ਹਰ ਥਾਂ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਕਰਦੇ ਹਨ; ਵਿਅੰਜਨ ਡੌਕਰਫਾਈਲ ਹੈ. AI ਉਤਪਾਦਨ-ਤਿਆਰ ਅਤੇ ਅਨੁਕੂਲਿਤ ਡੌਕਰਫਾਈਲਾਂ ਦੇ ਉਤਪਾਦਨ ਵਿੱਚ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ - ਪਰ ਤੁਹਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡਸ, ਛੋਟੇ ਬੇਸ ਚਿੱਤਰਾਂ, ਕੋਈ ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ, ਅਤੇ ਕੋਈ ਭੇਦ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਚਿੱਤਰ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣਾ ਤੈਨਾਤੀ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ; ਗੁਪਤ ਨੂੰ ਏਮਬੈਡ ਨਾ ਕਰਨਾ, ਰੂਟ ਤੋਂ ਬਚਣਾ, ਅਤੇ ਚਿੱਤਰ ਨੂੰ ਸਕੈਨ ਕਰਨਾ ਸੁਰੱਖਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਤਸਦੀਕ ਕਰਨਾ ਤੁਹਾਡੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੈ ਕਿ ਹਰੇਕ ਵਿਅੰਜਨ ਕੀ ਕਰਦਾ ਹੈ ਅਤੇ ਇਹ ਕਿੱਥੇ ਲੀਕ ਹੁੰਦਾ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਇੱਕ ਸਧਾਰਨ ਐਪ ਚੁਣੋ। AI ਨੂੰ "ਅਨੁਕੂਲਿਤ ਡੌਕਰਫਾਈਲ ਜਨਰੇਸ਼ਨ" ਟੈਮਪਲੇਟ ਨਾਲ ਇੱਕ ਡੌਕਰਫਾਈਲ ਤਿਆਰ ਕਰੋ। ਫਿਰ: (1) ਏਮਬੇਡ ਕੀਤੇ ਗੁਪਤ ਅਤੇ ਰੂਟ ਉਪਭੋਗਤਾ ਨੂੰ "ਸੁਰੱਖਿਆ ਜਾਂਚ" ਟੈਂਪਲੇਟ ਨਾਲ ਚੈੱਕ ਕਰੋ; (2) ਜੇ ਸੰਭਵ ਹੋਵੇ, ਡੌਕਰ ਬਣਾਓ ਅਤੇ ਡੌਕਰ ਚਿੱਤਰਾਂ ਨਾਲ ਆਕਾਰ ਨੂੰ ਮਾਪੋ; (3) ਨੋਟ ਕਰੋ ਕਿ ਅਗਲੇ ਪੜਾਅ ਵਜੋਂ ਚਿੱਤਰ ਨੂੰ ਘਟਾਉਣ ਲਈ ਕਿਹੜੀ ਤਕਨੀਕ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੋਵੇਗੀ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ ਸੰਸਕਰਣ, ਇਨਪੁਟ ਕਮਾਂਡ, ਅਤੇ ਪੋਰਟ ਨੂੰ ਮੇਰੇ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ।
• [ ] ਡੌਕਰਫਾਈਲ ਵਿੱਚ ਕੋਈ ਏਮਬੈਡਡ ਰਾਜ਼ ਨਹੀਂ ਹਨ; ਗੁਪਤ ਰਨਟਾਈਮ 'ਤੇ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
• [ ] ਕੰਟੇਨਰ ਇੱਕ ਅਣਅਧਿਕਾਰਤ USER ਨਾਲ ਚੱਲ ਰਿਹਾ ਹੈ, ਰੂਟ ਨਾਲ ਨਹੀਂ।
• [ ] ਬੇਸ ਚਿੱਤਰ ਛੋਟਾ ਹੈ (ਪਤਲਾ/ਅਲਪਾਈਨ) ਅਤੇ ਇਸਦਾ ਸੰਸਕਰਣ ਸਥਿਰ ਹੈ (ਨਹੀਂ: ਨਵੀਨਤਮ)।
• [ ] ਮੈਂ ਮਲਟੀ-ਸਟੇਜ ਬਿਲਡ ਅਤੇ .dockerignore ਦੀ ਵਰਤੋਂ ਕੀਤੀ।
• [ ] ਮੈਂ ਇੱਕ ਕਮਜ਼ੋਰੀ ਸਕੈਨਰ ਨਾਲ ਚਿੱਤਰ ਨੂੰ ਸਕੈਨ ਕੀਤਾ ਹੈ।