ਗ੍ਰੀਨਬੋਨ ਵੁਲਨੇਰਬਿਲਟੀ ਮੈਨੇਜਰ (ਜੀਵੀਐਮ) ਸੈਟਅਪ ਵਿੱਚ ਪੋਸਟਗਰੇਐਸਕਯੂਐਲ ਸੰਸਕਰਣ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਚੰਗੀ ਤਰ੍ਹਾਂ ਚਲਾਉਣ ਲਈ GVM ਅਤੇ PostgreSQL ਪ੍ਰਾਪਤ ਕਰਨਾ: ਇੰਸਟਾਲੇਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰਨਾ

ਜਦੋਂ ਤੁਸੀਂ ਸੈੱਟਅੱਪ ਕਰ ਰਹੇ ਹੋ ਗ੍ਰੀਨਬੋਨ ਕਮਜ਼ੋਰੀ ਪ੍ਰਬੰਧਕ (ਜੀਵੀਐਮ) ਤੁਹਾਡੀ ਨੈੱਟਵਰਕ ਸੁਰੱਖਿਆ ਨੂੰ ਮਜ਼ਬੂਤ ​​ਕਰਨ ਲਈ, PostgreSQL ਗਲਤੀ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਆਪਣੇ ਸਿਸਟਮ ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਹੈ, ਅਧਿਕਾਰਤ ਸੈੱਟਅੱਪ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕੀਤੀ ਹੈ, ਅਤੇ ਫਿਰ ਵੀ ਪੋਸਟਗਰੇਐਸਕਯੂਐਲ ਸੰਸਕਰਣ ਬੇਮੇਲ ਹੋਣ ਕਾਰਨ ਸੈੱਟਅੱਪ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ। 🛠️

ਬਹੁਤ ਸਾਰੇ ਉਪਭੋਗਤਾ ਇਸ ਮੁੱਦੇ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਡਿਫਾਲਟ PostgreSQL ਸੰਸਕਰਣ (ਜਿਵੇਂ ਕਿ ਸੰਸਕਰਣ 14) GVM (ਵਰਜਨ 17) ਦੁਆਰਾ ਲੋੜੀਂਦੇ ਇੱਕ ਨਾਲ ਟਕਰਾਅ ਕਰਦਾ ਹੈ। ਇੱਥੋਂ ਤੱਕ ਕਿ ਇੱਕ ਤਾਜ਼ਾ ਅੱਪਡੇਟ ਅਤੇ ਅੱਪਗਰੇਡ ਦੇ ਨਾਲ, PostgreSQL ਸੰਰਚਨਾ ਨੂੰ ਵਾਧੂ ਕਦਮਾਂ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਇੱਥੇ ਕੇਸ ਸੀ। ਇਹ ਮੁੱਦਾ ਅਕਸਰ ਸੰਸਕਰਣ ਲੋੜਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਹੁੰਦਾ ਹੈ ਜੋ ਮਿਆਰੀ ਸਥਾਪਨਾ ਗਾਈਡਾਂ ਵਿੱਚ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੁੰਦੇ ਹਨ।

ਜੇਕਰ ਤੁਹਾਨੂੰ GVM ਚਲਾਉਣ ਲਈ PostgreSQL 17 ਦੀ ਲੋੜ ਬਾਰੇ ਗਲਤੀਆਂ ਪ੍ਰਾਪਤ ਹੋਈਆਂ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਇਕੱਲੇ ਨਹੀਂ ਹੋ। ਇੰਸਟਾਲੇਸ਼ਨ ਸਕ੍ਰਿਪਟ ਬੰਦ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਹਾਨੂੰ ਵਰਤਣ ਵਰਗੇ ਸੁਝਾਅ ਮਿਲ ਜਾਣਗੇ pg_upgradecluster ਪਰ ਇਸ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਕੋਈ ਸਪੱਸ਼ਟ ਕਦਮ ਨਹੀਂ ਹਨ। ਇਹ ਸਥਿਤੀ ਉਲਝਣ ਵਾਲੀ ਹੋ ਸਕਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਜੇ ਤੁਸੀਂ ਸਿੱਧੇ ਪੈਕੇਜ ਸਥਾਪਨਾਵਾਂ ਦੇ ਆਦੀ ਹੋ।

ਇਸ ਗਾਈਡ ਵਿੱਚ, ਅਸੀਂ ਇਸ PostgreSQL ਸੰਸਕਰਣ ਗਲਤੀ ਦੇ ਕਾਰਨਾਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਅਤੇ ਵਿਹਾਰਕ ਹੱਲਾਂ ਦੁਆਰਾ ਚੱਲਾਂਗੇ। ਅੰਤ ਤੱਕ, ਤੁਸੀਂ GVM ਦੀਆਂ ਲੋੜਾਂ ਨਾਲ ਆਪਣੇ PostgreSQL ਸੰਸਕਰਣ ਨੂੰ ਇਕਸਾਰ ਕਰਨ ਅਤੇ ਤੁਹਾਡੇ ਸੈੱਟਅੱਪ ਨੂੰ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਚਲਾਉਣ ਲਈ ਕਦਮਾਂ ਨੂੰ ਸਮਝ ਸਕੋਗੇ। 🚀

GVM ਲਈ PostgreSQL ਸੰਸਕਰਣ ਫਿਕਸ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸਮਝਣਾ

ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਬਣਾਈਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ PostgreSQL ਸੰਸਕਰਣ ਬੇਮੇਲ Greenbone Vulnerability Manager (GVM) ਵਿੱਚ PostgreSQL ਨੂੰ ਵਰਜਨ 17 ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਕਦਮਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਦਾ ਹੈ, GVM ਦੀਆਂ ਲੋੜਾਂ ਨਾਲ ਅਨੁਕੂਲਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। Bash ਸਕ੍ਰਿਪਟ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਸ਼ੁਰੂਆਤੀ ਕੰਮ ਸਿਸਟਮ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੌਜੂਦਾ PostgreSQL ਸੰਸਕਰਣ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈ। ਇਹ "psql --version" ਨੂੰ ਚਲਾ ਕੇ ਅਤੇ "awk" ਅਤੇ "cut" ਵਰਗੇ ਟੂਲਸ ਨਾਲ ਆਉਟਪੁੱਟ ਨੂੰ ਪਾਰਸ ਕਰਕੇ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਪੂਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਸਥਾਪਿਤ ਸੰਸਕਰਣ GVM ਦੀਆਂ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਸੰਸਕਰਣ ਪੁਰਾਣਾ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਸੰਸਕਰਣ 17 ਨੂੰ ਸਥਾਪਿਤ ਕਰਕੇ PostgreSQL ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧਦੀ ਹੈ। ਇਹ ਪਹੁੰਚ ਨਾ ਸਿਰਫ਼ ਇੰਸਟਾਲੇਸ਼ਨ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ ਸਗੋਂ ਵਰਜਨ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਦਸਤੀ ਗਲਤੀਆਂ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਵੀ ਘਟਾਉਂਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ ਨੂੰ ਰੂਟ ਜਾਂ "sudo" ਨਾਲ ਚਲਾਉਣਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇਸ ਕੋਲ ਇਹਨਾਂ ਸਿਸਟਮ-ਪੱਧਰ ਦੇ ਕੰਮਾਂ ਲਈ ਲੋੜੀਂਦੇ ਅਧਿਕਾਰ ਹਨ।

ਅਗਲੇ ਹਿੱਸੇ ਵਿੱਚ, ਸਕ੍ਰਿਪਟ PostgreSQL ਕਲੱਸਟਰ ਨੂੰ ਅੱਪਗ੍ਰੇਡ ਕਰਨ ਲਈ "pg_upgradecluster" ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜੋ ਕਿ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਸੰਸਕਰਣ ਤਬਦੀਲੀਆਂ ਦੌਰਾਨ ਡਾਟਾ ਗੁਆਉਣ ਤੋਂ ਬਚਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਕਮਾਂਡ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਕ੍ਰੈਚ ਤੋਂ ਮੁੜ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਬਜਾਏ ਮੌਜੂਦਾ ਕਲੱਸਟਰ ਨੂੰ ਨਵੇਂ ਸੰਸਕਰਣ ਵਿੱਚ ਅੱਪਗਰੇਡ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਡੀ ਸੰਸਥਾ ਵਿੱਚ ਇੱਕ ਡੇਟਾਬੇਸ ਨੂੰ ਅੱਪਗਰੇਡ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਮੈਨੂਅਲ ਮਾਈਗ੍ਰੇਸ਼ਨ ਤੋਂ ਬਚਣਾ ਚਾਹੋਗੇ ਕਿਉਂਕਿ ਉਹ ਡੇਟਾ ਵਿੱਚ ਅੰਤਰ ਜਾਂ ਡਾਊਨਟਾਈਮ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ। ਇੱਕ ਵਾਰ ਅੱਪਗਰੇਡ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਸਕ੍ਰਿਪਟ "systemctl ਰੀਸਟਾਰਟ postgresql" ਦੀ ਵਰਤੋਂ ਕਰਕੇ PostgreSQL ਸੇਵਾ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਦੀ ਹੈ। ਨਵੀਆਂ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕਰਨ ਲਈ ਇਹ ਮੁੜ-ਚਾਲੂ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ GVM ਸਹੀ ਸੰਸਕਰਣ ਲੋੜਾਂ ਪੂਰੀਆਂ ਕਰਨ ਵਾਲੇ ਡੇਟਾਬੇਸ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦਾ ਹੈ। 🔄

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

ਅੰਤ ਵਿੱਚ, ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਕਿ ਕਮਾਂਡਾਂ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਉਮੀਦ ਅਨੁਸਾਰ ਚੱਲਦੀਆਂ ਹਨ, ਬੈਸ਼ ਅਤੇ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟਾਂ ਦੋਵਾਂ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਪਾਈਥਨ ਵਿੱਚ "unittest.mock.patch()" ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਕ੍ਰਿਪਟ ਕਮਾਂਡਾਂ ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਨਕਲ ਕਰ ਸਕਦੀ ਹੈ, ਅਸਲ ਵਾਤਾਵਰਣ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਟੈਸਟਿੰਗ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਹ ਟੈਸਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਕਮਾਂਡਾਂ ਉਹਨਾਂ ਨੂੰ ਲਾਈਵ ਸਿਸਟਮ ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਮੀਦ ਕੀਤੇ ਨਤੀਜੇ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ, ਤੈਨਾਤੀ ਮੁੱਦਿਆਂ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ। ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਈ ਸਰਵਰਾਂ ਵਿੱਚ GVM ਸੈਟ ਅਪ ਕਰ ਰਹੇ ਹੋ; ਪਹਿਲਾਂ ਤੋਂ ਚੱਲ ਰਹੇ ਟੈਸਟ ਇਹ ਵਿਸ਼ਵਾਸ ਪ੍ਰਦਾਨ ਕਰਨਗੇ ਕਿ ਹਰੇਕ ਇੰਸਟਾਲੇਸ਼ਨ ਇਕਸਾਰ ਹੈ। Bash ਅਤੇ Python ਦੋਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਇਹ ਸਕ੍ਰਿਪਟਾਂ PostgreSQL ਅੱਪਗਰੇਡ ਸਮੱਸਿਆ ਲਈ ਅਨੁਕੂਲ, ਮਜ਼ਬੂਤ ​​ਹੱਲ ਪੇਸ਼ ਕਰਦੀਆਂ ਹਨ, ਪ੍ਰਬੰਧਕਾਂ ਨੂੰ ਵਰਜਨ-ਸਬੰਧਤ ਰੁਕਾਵਟਾਂ ਤੋਂ ਬਿਨਾਂ GVM ਸੈੱਟਅੱਪ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੀਆਂ ਹਨ। 🚀

#!/bin/bash
# Script to update PostgreSQL cluster and configure GVM requirements
# Checks if PostgreSQL is installed and upgrades to the required version for GVM (version 17)
# Usage: Run as root or with sudo permissions

echo "Checking PostgreSQL version..."
POSTGRESQL_VERSION=$(psql --version | awk '{print $3}' | cut -d '.' -f 1)

if [ "$POSTGRESQL_VERSION" -lt 17 ]; then
  echo "Upgrading PostgreSQL to version 17..."
  sudo apt-get install -y postgresql-17
  if [ $? -ne 0 ]; then
    echo "Error installing PostgreSQL 17. Check your repositories or network connection."
    exit 1
  fi
  echo "PostgreSQL 17 installed successfully."
else
  echo "PostgreSQL version is sufficient for GVM setup."
fi

# Upgrade the cluster if required
echo "Upgrading PostgreSQL cluster to version 17..."
sudo pg_upgradecluster 14 main

# Restart PostgreSQL to apply changes
sudo systemctl restart postgresql

echo "PostgreSQL setup complete. Please retry GVM setup."

import subprocess
import sys

def check_postgresql_version():
    try:
        version_output = subprocess.check_output(['psql', '--version'])
        version = int(version_output.decode().split()[2].split('.')[0])
        return version
    except Exception as e:
        print("Error checking PostgreSQL version:", e)
        sys.exit(1)

def install_postgresql(version):
    try:
        subprocess.check_call(['sudo', 'apt-get', 'install', '-y', f'postgresql-{version}'])
        print(f"PostgreSQL {version} installed successfully.")
    except Exception as e:
        print("Error installing PostgreSQL:", e)
        sys.exit(1)

def upgrade_cluster(old_version, new_version):
    try:
        subprocess.check_call(['sudo', 'pg_upgradecluster', str(old_version), 'main'])
        print(f"Cluster upgraded to PostgreSQL {new_version}.")
    except Exception as e:
        print("Error upgrading PostgreSQL cluster:", e)
        sys.exit(1)

# Main logic
if __name__ == "__main__":
    required_version = 17
    current_version = check_postgresql_version()

    if current_version < required_version:
        print(f"Upgrading PostgreSQL from version {current_version} to {required_version}.")
        install_postgresql(required_version)
        upgrade_cluster(current_version, required_version)
    else:
        print("PostgreSQL version is already up to date.")

# Python Unit Tests (test_postgresql_upgrade.py)
import unittest
from unittest.mock import patch
import subprocess
from postgresql_upgrade_script import check_postgresql_version, install_postgresql

class TestPostgresqlUpgrade(unittest.TestCase):

    @patch('subprocess.check_output')
    def test_check_postgresql_version(self, mock_check_output):
        mock_check_output.return_value = b'psql (PostgreSQL) 14.0'
        self.assertEqual(check_postgresql_version(), 14)

    @patch('subprocess.check_call')
    def test_install_postgresql(self, mock_check_call):
        mock_check_call.return_value = 0
        install_postgresql(17)
        mock_check_call.assert_called_with(['sudo', 'apt-get', 'install', '-y', 'postgresql-17'])

if __name__ == '__main__':
    unittest.main()

GVM ਲਈ PostgreSQL ਨਾਲ ਅਨੁਕੂਲਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ: ਇੱਕ ਡੂੰਘੀ ਦਿੱਖ

ਇੰਸਟਾਲ ਕਰਨ ਵੇਲੇ ਗ੍ਰੀਨਬੋਨ ਕਮਜ਼ੋਰੀ ਪ੍ਰਬੰਧਕ (ਜੀਵੀਐਮ), ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਨਿਰਭਰਤਾ ਇਕਸਾਰ ਜ਼ਰੂਰੀ ਹੈ, ਖਾਸ ਕਰਕੇ PostgreSQL ਨਾਲ। ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਵਿਚਕਾਰ ਅਨੁਕੂਲਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਰਿਹਾ ਹੈ libgvmd ਅਤੇ ਤੁਹਾਡੇ ਸਿਸਟਮ ਉੱਤੇ PostgreSQL ਸੰਸਕਰਣ। GVM ਨੂੰ ਅਕਸਰ ਇੱਕ ਖਾਸ PostgreSQL ਸੰਸਕਰਣ (ਇਸ ਕੇਸ ਵਿੱਚ, ਸੰਸਕਰਣ 17) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ ਇਸਦੇ ਡੇਟਾਬੇਸ-ਸੰਚਾਲਿਤ ਕਾਰਜਸ਼ੀਲਤਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕੀਤਾ ਜਾ ਸਕੇ। ਮੇਲ ਖਾਂਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਿੱਥੇ GVM ਲੋੜੀਂਦੀਆਂ ਟੇਬਲਾਂ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਕਰ ਸਕਦਾ ਜਾਂ ਲੋੜੀਂਦੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਨਹੀਂ ਚਲਾ ਸਕਦਾ। ਇਹ ਇਸ ਵਿੱਚ ਅੰਤਰ ਦੇ ਕਾਰਨ ਹੈ ਕਿ ਕਿਵੇਂ ਹਰੇਕ PostgreSQL ਸੰਸਕਰਣ GVM ਦੁਆਰਾ ਲੋੜੀਂਦੇ ਖਾਸ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।

ਇਹ ਅਨੁਕੂਲਤਾ ਲੋੜਾਂ ਮਹੱਤਵਪੂਰਨ ਹਨ ਕਿਉਂਕਿ GVM ਕਮਜ਼ੋਰੀ ਡੇਟਾ ਨੂੰ ਪ੍ਰਬੰਧਨ ਅਤੇ ਸਟੋਰ ਕਰਨ ਲਈ ਡਾਟਾਬੇਸ ਲੈਣ-ਦੇਣ 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਸਹੀ ਸੰਸਕਰਣ ਹੋਣ ਨਾਲ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ ਕਿ ਸਾਰੇ GVM ਮੋਡਿਊਲ ਡਾਟਾਬੇਸ ਨਾਲ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰ ਸਕਦੇ ਹਨ, ਸਕੈਨ ਦੌਰਾਨ ਨਿਰਵਿਘਨ ਡਾਟਾ ਪ੍ਰਾਪਤੀ ਅਤੇ ਅੱਪਡੇਟ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ। ਇਸ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਨਾਲ ਅਧੂਰੇ ਸਕੈਨ ਜਾਂ ਗਲਤ ਰਿਪੋਰਟਿੰਗ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜੋ ਕਿ ਕਮਜ਼ੋਰੀ ਪ੍ਰਬੰਧਨ ਹੱਲ ਵਜੋਂ GVM ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਉਦੇਸ਼ ਨੂੰ ਹਰਾ ਦਿੰਦੀ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਤੁਸੀਂ ਸਟੀਕ ਸੰਸਕਰਣ ਲੋੜਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋ—ਜਿਵੇਂ ਕਿ PostgreSQL 17 ਨੂੰ ਅੱਪਗ੍ਰੇਡ ਕਰਨਾ—ਟੂਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਦੀ ਸੁਰੱਖਿਆ ਕਰਦਾ ਹੈ। 🛠️

ਗੁੰਝਲਦਾਰ ਵਾਤਾਵਰਣਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ, ਇੱਕ PostgreSQL ਕਲੱਸਟਰ ਨੂੰ ਅਪਗ੍ਰੇਡ ਕਰਨਾ ਔਖਾ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਉਤਪਾਦਨ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ। ਹਾਲਾਂਕਿ, ਸੰਦ ਜਿਵੇਂ pg_upgradecluster ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਡੇਟਾ ਗੁਆਏ ਬਿਨਾਂ ਅਪਗ੍ਰੇਡ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇ ਕੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਓ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਨਵੀਆਂ ਸੌਫਟਵੇਅਰ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹੋਏ ਤੁਹਾਡਾ ਇਤਿਹਾਸਕ ਡੇਟਾ ਬਰਕਰਾਰ ਰਹੇ। ਜੇਕਰ ਤੁਸੀਂ ਉਤਪਾਦਨ ਵਿੱਚ ਇੱਕ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਸਕ੍ਰਿਪਟਾਂ ਜੋ ਇਹਨਾਂ ਕਦਮਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਦੀਆਂ ਹਨ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਅਤੇ ਮਲਟੀਪਲ ਸਰਵਰਾਂ ਵਿੱਚ ਇਕਸਾਰਤਾ ਬਣਾਈ ਰੱਖਣ ਦਾ ਇੱਕ ਸੁਰੱਖਿਅਤ ਤਰੀਕਾ ਪੇਸ਼ ਕਰਦੀਆਂ ਹਨ। ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਜਿੱਥੇ ਆਟੋਮੇਸ਼ਨ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਸਕ੍ਰਿਪਟਿੰਗ ਅਤੇ ਟੈਸਟਿੰਗ ਕਦਮ ਅਚਾਨਕ ਡਾਊਨਟਾਈਮ ਜਾਂ ਅਸੰਗਤਤਾਵਾਂ ਨੂੰ ਰੋਕਦੇ ਹਨ, ਮਨ ਦੀ ਸ਼ਾਂਤੀ ਦਿੰਦੇ ਹਨ ਕਿ ਸਿਸਟਮ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨਗੇ।