GIT ਸਰਵਰ ਤੱਕ ਬਹੁ-ਉਪਭੋਗਤਾ ਪਹੁੰਚ ਦਾ ਸੰਗਠਨ

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

ਮੇਰੀਆਂ ਇੱਛਾਵਾਂ ਹਨ:

• ਹਰੇਕ ਉਪਭੋਗਤਾ ਆਪਣੇ ਖਾਤੇ ਨਾਲ ਜੁੜਦਾ ਹੈ
• ਕਈ ਉਪਭੋਗਤਾ ਇੱਕ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ
• ਇੱਕੋ ਉਪਭੋਗਤਾ ਕਈ ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ
• ਹਰੇਕ ਉਪਭੋਗਤਾ ਕੋਲ ਸਿਰਫ ਉਹਨਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ ਜਿਸ 'ਤੇ ਉਹ ਕੰਮ ਕਰਦਾ ਹੈ
• ਕਮਾਂਡ ਲਾਈਨ ਰਾਹੀਂ ਜੁੜਨਾ ਸੰਭਵ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕਿ ਕਿਸੇ ਕਿਸਮ ਦੇ ਵੈਬ ਇੰਟਰਫੇਸ ਰਾਹੀਂ

ਇਹ ਵੀ ਬਹੁਤ ਵਧੀਆ ਹੋਵੇਗਾ:

• ਨਿਯੰਤਰਣ ਕਰਨ ਵਾਲੇ ਵਿਅਕਤੀਆਂ ਨੂੰ ਸਿਰਫ਼ ਪੜ੍ਹਨ-ਪੜ੍ਹਨ ਦੀਆਂ ਇਜਾਜ਼ਤਾਂ ਦਿਓ
• Git ਵਿੱਚ ਉਪਭੋਗਤਾ ਪਹੁੰਚ ਅਧਿਕਾਰਾਂ ਦਾ ਸੁਵਿਧਾਜਨਕ ਪ੍ਰਬੰਧਨ ਕਰੋ

GIT ਸਰਵਰ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਸੰਭਵ ਵਿਕਲਪਾਂ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਕਿਸ ਵਿੱਚੋਂ ਚੁਣਨਾ ਹੈ, ਇਸ ਲਈ ਇੱਥੇ ਗਿੱਟ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਹੈ।

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

  ਪਰ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਕਿਸੇ ਵੀ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋਵੇਗਾ?... ਆਮ ਤੌਰ 'ਤੇ, ਇਸ ਵਿਧੀ ਤੋਂ ਇਨਕਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇਹ ਸਮਝਦੇ ਹੋ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ. ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਇਸ ਵਿਧੀ 'ਤੇ ਵਾਪਸ ਆਵਾਂਗੇ, ਪਰ ਹੁਣ ਲਈ ਅਸੀਂ ਹੋਰ ਵਿਕਲਪਾਂ ਬਾਰੇ ਸੰਖੇਪ ਵਿੱਚ ਵਿਚਾਰ ਕਰਾਂਗੇ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਕੁਝ ਸੌਖਾ ਹੋਵੇਗਾ।

• git ਲੋਕਲ ਪ੍ਰੋਟੋਕੋਲ ਨੂੰ sshfs ਦੇ ਨਾਲ ਜੋੜ ਕੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਮਲਟੀਪਲ ਯੂਜ਼ਰ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਪਰ ਅਸਲ ਵਿੱਚ ਪਿਛਲੇ ਕੇਸ ਵਾਂਗ ਹੀ
• http - ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ
• git ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਹੈ
• https - ਇੰਸਟਾਲ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੈ, ਤੁਹਾਨੂੰ ਵਾਧੂ ਸੌਫਟਵੇਅਰ ਦੀ ਲੋੜ ਹੈ, ਉਪਭੋਗਤਾ ਪਹੁੰਚ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਕਿਸੇ ਕਿਸਮ ਦਾ ਕੰਟਰੋਲ ਪੈਨਲ... ਇਹ ਸੰਭਵ ਜਾਪਦਾ ਹੈ, ਪਰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਹਰ ਚੀਜ਼ ਗੁੰਝਲਦਾਰ ਹੈ।

Git ਸਰਵਰ ਲਈ ਬਹੁ-ਉਪਭੋਗਤਾ ਪਹੁੰਚ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ssh ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਆਉ ssh ਪ੍ਰੋਟੋਕੋਲ ਤੇ ਵਾਪਸ ਚਲੀਏ।

ਕਿਉਂਕਿ ਤੁਸੀਂ git ਲਈ ssh ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਸਰਵਰ ਡੇਟਾ ਦੀ ਸੁਰੱਖਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਉਪਭੋਗਤਾ ਜੋ ssh ਦੁਆਰਾ ਕਨੈਕਟ ਕਰਦਾ ਹੈ ਉਹ ਲੀਨਕਸ ਸਰਵਰ 'ਤੇ ਆਪਣਾ ਲੌਗਇਨ ਵਰਤਦਾ ਹੈ, ਤਾਂ ਜੋ ਉਹ ssh ਕਲਾਇੰਟ ਦੁਆਰਾ ਜੁੜ ਸਕਣ ਅਤੇ ਸਰਵਰ ਦੀ ਕਮਾਂਡ ਲਾਈਨ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਣ।
ਅਜਿਹੀ ਪਹੁੰਚ ਦੇ ਵਿਰੁੱਧ ਕੋਈ ਪੂਰੀ ਸੁਰੱਖਿਆ ਨਹੀਂ ਹੈ.

ਪਰ ਉਪਭੋਗਤਾ ਨੂੰ ਲੀਨਕਸ ਫਾਈਲਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ. ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਸਿਰਫ git ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਲਈ, ਕਮਾਂਡ ਲਾਈਨ ਰਾਹੀਂ ਪਹੁੰਚ ਨੂੰ ਸੀਮਤ ਨਾ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਪਰ ਉਪਭੋਗਤਾ ਨੂੰ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਦੇਖਣ ਤੋਂ ਮਨਾਹੀ ਕਰਨ ਲਈ ਲੀਨਕਸ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਉਹਨਾਂ ਨੂੰ ਛੱਡ ਕੇ ਜਿਸ ਵਿੱਚ ਉਹ ਹਿੱਸਾ ਲੈਂਦਾ ਹੈ।
ਸਪੱਸ਼ਟ ਵਿਕਲਪ ਲੀਨਕਸ ਅਨੁਮਤੀਆਂ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ।

ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ, ssh ਪਹੁੰਚ ਲਈ ਸਿਰਫ ਇੱਕ ਖਾਤੇ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ. ਇਹ ਸੰਰਚਨਾ ਕਈ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਅਸੁਰੱਖਿਅਤ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਸਿਫਾਰਸ਼ ਕੀਤੇ ਗਿੱਟ ਵਿਕਲਪਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ।

ਲੇਖ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਦਿੱਤੀਆਂ ਗਈਆਂ ਲੋੜਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਅਧਿਕਾਰਾਂ ਅਤੇ ਮਾਲਕਾਂ ਦੀ ਨਿਯੁਕਤੀ ਨਾਲ ਹੇਠ ਲਿਖੀ ਡਾਇਰੈਕਟਰੀ ਬਣਤਰ ਬਣਾਈ ਗਈ ਹੈ:

1) ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀਆਂ

dir1(proj1:proj1,0770)
dir2(proj2:proj2,0770)
dir3(proj3:proj3,0770)
...
ਜਿੱਥੇ
dir1, dir2, dir3 - ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀਆਂ: ਪ੍ਰੋਜੈਕਟ 1, ਪ੍ਰੋਜੈਕਟ 2, ਪ੍ਰੋਜੈਕਟ 3।

proj1:proj1, proj2:proj2, proj3:proj3 ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਬਣਾਏ ਗਏ ਲੀਨਕਸ ਉਪਭੋਗਤਾ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸੰਬੰਧਿਤ ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀਆਂ ਦੇ ਮਾਲਕਾਂ ਵਜੋਂ ਨਿਯੁਕਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਸਾਰੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ ਲਈ ਅਨੁਮਤੀਆਂ 0770 'ਤੇ ਸੈੱਟ ਹਨ - ਮਾਲਕ ਅਤੇ ਉਸਦੇ ਸਮੂਹ ਲਈ ਪੂਰੀ ਪਹੁੰਚ ਅਤੇ ਬਾਕੀ ਸਾਰਿਆਂ ਲਈ ਪੂਰੀ ਪਾਬੰਦੀ।

2) ਡਿਵੈਲਪਰ ਖਾਤੇ

Разработчик 1: dev1:dev1,proj1,proj2
Разработчик 2: dev2:dev2,proj2,proj3

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

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, "ਡਿਵੈਲਪਰ 1" ਪ੍ਰੋਜੈਕਟ proj1 ਅਤੇ proj2 'ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਅਤੇ "Developer 2" proj2 ਅਤੇ proj3 ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।

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

ਕਿਉਂਕਿ ਇਸ ਸਿਧਾਂਤ ਦਾ ਆਧਾਰ ਲੀਨਕਸ ਅਧਿਕਾਰਾਂ ਦੀ ਮੁਢਲੀ ਸੁਰੱਖਿਆ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਕੀਮ ਭਰੋਸੇਯੋਗ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਕੀਮ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ.

ਆਓ ਅਭਿਆਸ ਵੱਲ ਵਧੀਏ।

ਲੀਨਕਸ ਸਰਵਰ 'ਤੇ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀਆਂ ਬਣਾਉਣਾ

ਆਓ ਜਾਂਚ ਕਰੀਏ।

[root@server ~]# cd /var/
[root@server var]# useradd gitowner
[root@server var]# mkdir gitservertest
[root@server var]# chown gitowner:gitowner gitservertest
[root@server var]# adduser proj1
[root@server var]# adduser proj2
[root@server var]# adduser proj3
[root@server var]# adduser dev1
[root@server var]# adduser dev2
[root@server var]# passwd dev1
[root@server var]# passwd dev2

ਮੈਂ ਹੱਥਾਂ ਨਾਲ ਟਾਈਪ ਕਰਕੇ ਥੱਕ ਗਿਆ ਹਾਂ...

[root@server gitservertest]# sed "s/ /n/g" <<< "proj1 proj2 proj3" | while read u; do mkdir $u; chown $u:$u $u; chmod 0770 $u; done

[root@server gitservertest]# usermod -aG proj1 dev1
[root@server gitservertest]# usermod -aG proj2 dev1
[root@server gitservertest]# usermod -aG proj2 dev2
[root@server gitservertest]# usermod -aG proj3 dev2

ਸਾਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਦੂਜੇ ਲੋਕਾਂ ਦੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਸਮੱਗਰੀਆਂ ਨੂੰ ਦੇਖਣਾ ਵੀ ਅਸੰਭਵ ਹੈ।

[dev1@server ~]$ cd /var/gitservertest/proj3
-bash: cd: /var/gitservertest/proj3: Permission denied
[dev1@server ~]$ ls /var/gitservertest/proj3
ls: cannot open directory /var/gitservertest/proj3: Permission denied

Git ਵਿੱਚ ਇੱਕੋ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕਈ ਡਿਵੈਲਪਰਾਂ ਨਾਲ ਸਹਿਯੋਗ ਕਰੋ

ਇੱਕ ਸਵਾਲ ਰਹਿੰਦਾ ਹੈ, ਜੇਕਰ ਇੱਕ ਡਿਵੈਲਪਰ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਤਾਂ ਦੂਜੇ ਡਿਵੈਲਪਰ ਇਸਨੂੰ ਨਹੀਂ ਬਦਲ ਸਕਦੇ, ਕਿਉਂਕਿ ਉਹ ਖੁਦ ਇਸਦਾ ਮਾਲਕ ਹੈ (ਉਦਾਹਰਨ ਲਈ, dev1), ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦਾ ਉਪਭੋਗਤਾ ਮਾਲਕ ਨਹੀਂ (ਉਦਾਹਰਨ ਲਈ, proj1)। ਕਿਉਂਕਿ ਸਾਡੇ ਕੋਲ ਸਰਵਰ-ਸਾਈਡ ਰਿਪੋਜ਼ਟਰੀ ਹੈ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ".git" ਡਾਇਰੈਕਟਰੀ ਕਿਵੇਂ ਬਣਤਰ ਹੈ ਅਤੇ ਕੀ ਨਵੀਆਂ ਫਾਈਲਾਂ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ।

ਇੱਕ ਸਥਾਨਕ Git ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਉਣਾ ਅਤੇ Git ਸਰਵਰ ਵੱਲ ਧੱਕਣਾ

ਆਉ ਕਲਾਇੰਟ ਮਸ਼ੀਨ ਵੱਲ ਵਧੀਏ।

Microsoft Windows [Version 6.1.7601]
(c) Корпорация Майкрософт (Microsoft Corp.), 2009. Все права защищены.

C:gittest>git init .
Initialized empty Git repository in C:/gittest/.git/

C:gittest>echo "test dev1 to proj2" > test1.txt

C:gittest>git add .

C:gittest>git status
On branch master
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   test1.txt

C:gittest>git commit -am "new test file added"
[master (root-commit) a7ac614] new test file added
 1 file changed, 1 insertion(+)
 create mode 100644 test1.txt
 
C:gittest>git remote add origin "ssh://[email protected]/var/gitservertest/proj2"

C:gittest>git push origin master
dev1:[email protected]'s password:
Counting objects: 3, done.
Writing objects: 100% (3/3), 243 bytes | 243.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ssh://10.1.1.11/var/gitservertest/proj2
 * [new branch]      master -> master

C:gittest>

ਉਸੇ ਸਮੇਂ, ਸਰਵਰ 'ਤੇ ਨਵੀਆਂ ਫਾਈਲਾਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਅਤੇ ਉਹ ਉਸ ਉਪਭੋਗਤਾ ਨਾਲ ਸਬੰਧਤ ਹਨ ਜਿਸ ਨੇ ਪੁਸ਼ ਕੀਤਾ ਸੀ

[dev1@server proj2]$ tree
.
├── 1.txt
├── branches
├── config
├── description
├── HEAD
├── hooks
│   ├── applypatch-msg.sample
│   ├── commit-msg.sample
│   ├── post-update.sample
│   ├── pre-applypatch.sample
│   ├── pre-commit.sample
│   ├── prepare-commit-msg.sample
│   ├── pre-push.sample
│   ├── pre-rebase.sample
│   └── update.sample
├── info
│   └── exclude
├── objects
│   ├── 75
│   │   └── dcd269e04852ce2f683b9eb41ecd6030c8c841
│   ├── a7
│   │   └── ac6148611e69b9a074f59a80f356e1e0c8be67
│   ├── f0
│   │   └── 82ea1186a491cd063925d0c2c4f1c056e32ac3
│   ├── info
│   └── pack
└── refs
    ├── heads
    │   └── master
    └── tags

12 directories, 18 files
[dev1@server proj2]$ ls -l objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
-r--r--r--. 1 dev1 dev1 54 Jun 20 14:34 objects/75/dcd269e04852ce2f683b9eb41ecd6030c8c841
[dev1@server proj2]$

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

Linux chown - ਇੱਕ ਨਿਯਮਤ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਇੱਕ ਫਾਈਲ ਦੇ ਮਾਲਕ ਨੂੰ ਬਦਲਣਾ

ਕਿਸੇ ਫ਼ਾਈਲ ਦਾ ਮਾਲਕ ਇਸਦੀ ਮਲਕੀਅਤ ਨਹੀਂ ਬਦਲ ਸਕਦਾ। ਪਰ ਉਹ ਉਸ ਫਾਈਲ ਦੇ ਸਮੂਹ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ ਜੋ ਉਸਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਇਸ ਫਾਈਲ ਨੂੰ ਦੂਜੇ ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਸੰਸ਼ੋਧਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਉਸੇ ਸਮੂਹ ਵਿੱਚ ਹਨ. ਇਹੀ ਸਾਨੂੰ ਚਾਹੀਦਾ ਹੈ।

ਗਿੱਟ ਹੁੱਕ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਹੁੱਕ ਲਈ ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ ਪ੍ਰੋਜੈਕਟ ਦੀ ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਹੈ। ਹੁੱਕ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਹੈ ਜੋ ਪੁਸ਼ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾ ਦੇ ਅਧੀਨ ਚੱਲਦਾ ਹੈ. ਇਹ ਜਾਣ ਕੇ, ਅਸੀਂ ਆਪਣੀਆਂ ਯੋਜਨਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ।

[dev1@server proj2]$ mv hooks/post-update{.sample,}
[dev1@server proj2]$ sed -i '2,$ s/^/#/' hooks/post-update
[dev1@server proj2]$ cat <<< 'find . -group $(whoami) -exec chgrp proj2 '"'"'{}'"'"' ;' >> hooks/post-update

ਜਾਂ ਸਿਰਫ਼

vi hooks/post-update

ਆਉ ਕਲਾਇੰਟ ਮਸ਼ੀਨ ਤੇ ਵਾਪਸ ਚਲੀਏ।

C:gittest>echo "dev1 3rd line" >> test1.txt

C:gittest>git commit -am "3rd from dev1, testing server hook"
[master b045e22] 3rd from dev1, testing server hook
 1 file changed, 1 insertion(+)

C:gittest>git push origin master
dev1:[email protected]'s password:
   d22c66e..b045e22  master -> master

ਗਿੱਟ ਸਰਵਰ 'ਤੇ, ਅਸੀਂ ਕਮਿਟ ਤੋਂ ਬਾਅਦ ਹੁੱਕ ਪੋਸਟ-ਅੱਪਡੇਟ ਸਕ੍ਰਿਪਟ ਦੇ ਸੰਚਾਲਨ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ

[dev1@server proj2]$ find . ! -group proj2

- ਖਾਲੀ, ਸਭ ਕੁਝ ਠੀਕ ਹੈ।

Git ਵਿੱਚ ਇੱਕ ਦੂਜੇ ਡਿਵੈਲਪਰ ਨੂੰ ਕਨੈਕਟ ਕਰਨਾ

ਆਉ ਦੂਜੇ ਡਿਵੈਲਪਰ ਦੇ ਕੰਮ ਦੀ ਨਕਲ ਕਰੀਏ.

ਗਾਹਕ 'ਤੇ

C:gittest>git remote remove origin

C:gittest>git remote add origin "ssh://[email protected]/var/gitservertest/proj2"

C:gittest>echo "!!! dev2 added this" >> test1.txt

C:gittest>echo "!!! dev2 wrote" > test2.txt

C:gittest>git add test2.txt

C:gittest>git commit -am "dev2 added to test1 and created test2"
[master 55d49a6] dev2 added to test1 and created test2
 2 files changed, 2 insertions(+)
 create mode 100644 test2.txt

C:gittest>git push origin master
[email protected]'s password:
   b045e22..55d49a6  master -> master

ਅਤੇ ਉਸੇ ਸਮੇਂ, ਸਰਵਰ ਤੇ ...

[dev1@server proj2]$ find . ! -group proj2

- ਦੁਬਾਰਾ ਖਾਲੀ, ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ.

ਇੱਕ Git ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਮਿਟਾਉਣਾ ਅਤੇ Git ਸਰਵਰ ਤੋਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ

ਖੈਰ, ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਫਿਰ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਹੈ।

C:gittest>rd /S /Q .
Процесс не может получить доступ к файлу, так как этот файл занят другим процессом.

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

C:gittest>dir
 Содержимое папки C:gittest

21.06.2019  08:43    <DIR>          .
21.06.2019  08:43    <DIR>          ..

C:gittest>git clone ssh://[email protected]/var/gitservertest/proj2
Cloning into 'proj2'...
[email protected]'s password:

C:gittest>cd proj2

C:gittestproj2>dir
 Содержимое папки C:gittestproj2

21.06.2019  08:46    <DIR>          .
21.06.2019  08:46    <DIR>          ..
21.06.2019  08:46               114 test1.txt
21.06.2019  08:46                19 test2.txt
C:gittestproj2>type test1.txt
"test dev1 to proj2"
"dev1 added some omre"
"dev1 3rd line"
"!!! dev2 added this"

C:gittestproj2>type test2.txt
"!!! dev2 wrote"

Git ਵਿੱਚ ਪਹੁੰਚ ਨੂੰ ਸਾਂਝਾ ਕਰਨਾ

ਹੁਣ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰੀਏ ਕਿ Git ਦੁਆਰਾ ਵੀ ਦੂਜਾ ਡਿਵੈਲਪਰ Proj1 ਪ੍ਰੋਜੈਕਟ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਜਿਸ 'ਤੇ ਉਹ ਕੰਮ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੈ।

C:gittestproj2>git remote remove origin

C:gittestproj2>git remote add origin "ssh://[email protected]/var/gitservertest/proj1"

C:gittestproj2>git push origin master
[email protected]'s password:
fatal: '/var/gitservertest/proj1' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

ਹੁਣ ਅਸੀਂ ਪਹੁੰਚ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ

[root@server ~]# usermod -aG proj1 dev2

ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ.

C:gittestproj2>git push origin master
[email protected]'s password:
To ssh://10.1.1.11/var/gitservertest/proj1
 * [new branch]      master -> master

ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ,

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜੇ ਫਾਈਲਾਂ ਅਤੇ ਡਾਇਰੈਕਟਰੀਆਂ ਬਣਾਉਣ ਵੇਲੇ ਡਿਫੌਲਟ ਅਨੁਮਤੀਆਂ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਹੈ, ਤਾਂ CentOS ਵਿੱਚ ਤੁਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ

setfacl -Rd -m o::5 -m g::7 /var/gitservertest

ਲੇਖ ਵਿਚ ਵੀ ਤੁਸੀਂ ਛੋਟੀਆਂ ਲਾਭਦਾਇਕ ਚੀਜ਼ਾਂ 'ਤੇ ਠੋਕਰ ਖਾ ਸਕਦੇ ਹੋ:

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

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ.

ਸਰੋਤ: www.habr.com