🥇GIT ಸರ್ವರ್‌ಗೆ ಬಹು-ಬಳಕೆದಾರ ಪ್ರವೇಶದ ಸಂಘಟನೆ

Git ಸರ್ವರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವಾಗ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡುವಾಗ, ಹಲವಾರು ಯೋಜನೆಗಳಿಗೆ ಹಲವಾರು ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶವನ್ನು ಆಯೋಜಿಸುವ ಬಗ್ಗೆ ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸುತ್ತದೆ. ನಾನು ಸಮಸ್ಯೆಯನ್ನು ಸಂಶೋಧಿಸಿದ್ದೇನೆ ಮತ್ತು ನನ್ನ ಎಲ್ಲಾ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸುವ ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ: ಸರಳ, ಸುರಕ್ಷಿತ, ವಿಶ್ವಾಸಾರ್ಹ.

ನನ್ನ ಹಾರೈಕೆಗಳು:

ಪ್ರತಿಯೊಬ್ಬ ಬಳಕೆದಾರರು ತಮ್ಮ ಸ್ವಂತ ಖಾತೆಯೊಂದಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತಾರೆ
ಹಲವಾರು ಬಳಕೆದಾರರು ಒಂದು ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು
ಒಂದೇ ಬಳಕೆದಾರನು ಅನೇಕ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು
ಪ್ರತಿಯೊಬ್ಬ ಬಳಕೆದಾರರು ಅವರು ಕೆಲಸ ಮಾಡುವ ಯೋಜನೆಗಳಿಗೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತಾರೆ
ಕಮಾಂಡ್ ಲೈನ್ ಮೂಲಕ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗಬೇಕು ಮತ್ತು ಕೆಲವು ರೀತಿಯ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಅಲ್ಲ

ಇದು ಸಹ ಉತ್ತಮವಾಗಿರುತ್ತದೆ:

ನಿಯಂತ್ರಿಸುವ ವ್ಯಕ್ತಿಗಳಿಗೆ ಓದಲು-ಮಾತ್ರ ಅನುಮತಿಗಳನ್ನು ನೀಡಿ
Git ನಲ್ಲಿ ಬಳಕೆದಾರರ ಪ್ರವೇಶ ಹಕ್ಕುಗಳನ್ನು ಅನುಕೂಲಕರವಾಗಿ ನಿರ್ವಹಿಸಿ

GIT ಸರ್ವರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಸಂಭವನೀಯ ಆಯ್ಕೆಗಳ ಅವಲೋಕನ

ಮೊದಲನೆಯದಾಗಿ, ಯಾವುದನ್ನು ಆರಿಸಬೇಕೆಂದು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು, ಆದ್ದರಿಂದ Git ಪ್ರೋಟೋಕಾಲ್‌ಗಳ ತ್ವರಿತ ಅವಲೋಕನ ಇಲ್ಲಿದೆ.

ssh - ಸರ್ವರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ವಿಶೇಷವಾಗಿ ರಚಿಸಲಾದ ಬಳಕೆದಾರ ಖಾತೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
- ಎಲ್ಲಾ ರೆಪೊಸಿಟರಿಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಒಂದು ಖಾತೆಯ ಬಳಕೆಯನ್ನು Git ತನ್ನ ಶಿಫಾರಸುಗಳಿಂದ ಹೊರಗಿಡದಿರುವುದು ವಿಚಿತ್ರವಾಗಿದೆ. ಇದು ನನ್ನ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸುತ್ತಿಲ್ಲ.
- ನೀವು ಬಹು ಖಾತೆಗಳನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ಕೆಲವು ಡೈರೆಕ್ಟರಿಗಳಿಗೆ ಮಾತ್ರ ನೀವು ಬಳಕೆದಾರರ ಪ್ರವೇಶವನ್ನು ಹೇಗೆ ಮಿತಿಗೊಳಿಸಬಹುದು?
  - ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಮುಚ್ಚುವುದು ಸೂಕ್ತವಲ್ಲ, ಏಕೆಂದರೆ ಇತರ ಬಳಕೆದಾರರಿಗೆ ಬರೆಯುವ ಪ್ರವೇಶವನ್ನು ಆಯೋಜಿಸುವುದು ಕಷ್ಟ
  - ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ಸಿಮ್‌ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸುವುದು ಸಹ ಕಷ್ಟಕರವಾಗಿದೆ ಏಕೆಂದರೆ Git ಅವುಗಳನ್ನು ಲಿಂಕ್‌ಗಳಾಗಿ ಅರ್ಥೈಸುವುದಿಲ್ಲ
  - ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸಲು ಸಾಧ್ಯವಿದೆ, ಆದರೆ ಅದು ಯಾವಾಗಲೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಸಂಪೂರ್ಣ ಗ್ಯಾರಂಟಿ ಇಲ್ಲ
    - ಅಂತಹ ಬಳಕೆದಾರರಿಗೆ ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮ ಸ್ವಂತ ಕಮಾಂಡ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಬಹುದು, ಆದರೆ
      - ಮೊದಲನೆಯದಾಗಿ, ಇದು ಈಗಾಗಲೇ ಕೆಲವು ರೀತಿಯ ಕಠಿಣ ನಿರ್ಧಾರವಾಗಿದೆ,
      - ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಇದನ್ನು ತಪ್ಪಿಸಬಹುದು.
ಆದರೆ ಬಳಕೆದಾರರಿಗೆ ಯಾವುದೇ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುವುದು ಬಹುಶಃ ಸಮಸ್ಯೆಯಲ್ಲವೇ?.. ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ಅದನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದರೆ ಈ ವಿಧಾನವನ್ನು ತಳ್ಳಿಹಾಕಲಾಗುವುದಿಲ್ಲ. ನಾವು ನಂತರ ಈ ವಿಧಾನಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತೇವೆ, ಆದರೆ ಸದ್ಯಕ್ಕೆ ನಾವು ಇತರ ಪರ್ಯಾಯಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಗಣಿಸುತ್ತೇವೆ, ಬಹುಶಃ ಸರಳವಾದ ಏನಾದರೂ ಇರುತ್ತದೆ.
git ಸ್ಥಳೀಯ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು sshf ಗಳ ಸಂಯೋಜನೆಯಲ್ಲಿ ಬಳಸಬಹುದು, ಬಹು ಬಳಕೆದಾರರನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಹಿಂದಿನ ಪ್ರಕರಣದಂತೆಯೇ ಇರುತ್ತದೆ
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 ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಮತ್ತು "ಡೆವಲಪರ್ 2" ಯೋಜನೆಗಳು proj2 ಮತ್ತು proj3 ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ.

ಯಾವುದೇ ಡೆವಲಪರ್‌ಗಳು ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ssh ಮೂಲಕ ಸಂಪರ್ಕಿಸಿದರೆ, ಅವರು ಭಾಗವಹಿಸದ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಗಳ ವಿಷಯಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಸಹ ಅವರ ಹಕ್ಕುಗಳು ಸಾಕಾಗುವುದಿಲ್ಲ. ಇದನ್ನು ತಾನೇ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಈ ತತ್ವದ ಆಧಾರವು ಲಿನಕ್ಸ್ ಹಕ್ಕುಗಳ ಮೂಲಭೂತ ಭದ್ರತೆಯಾಗಿರುವುದರಿಂದ, ಈ ಯೋಜನೆಯು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಯೋಜನೆಯನ್ನು ನಿರ್ವಹಿಸಲು ತುಂಬಾ ಸುಲಭ.

ಅಭ್ಯಾಸ ಮಾಡಲು ಮುಂದುವರೆಯೋಣ.

Linux ಸರ್ವರ್‌ನಲ್ಲಿ Git ರೆಪೊಸಿಟರಿಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ಪರಿಶೀಲಿಸೋಣ.

[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 ರಚಿಸಿದ ಫೈಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಇದು ಕಾರ್ಯಚಟುವಟಿಕೆಯಲ್ಲಿ ಸ್ಥಗಿತಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.

ಲಿನಕ್ಸ್ ಚೌನ್ - ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರಿಂದ ಫೈಲ್ ಮಾಲೀಕರನ್ನು ಬದಲಾಯಿಸುವುದು

ಫೈಲ್‌ನ ಮಾಲೀಕರು ಅದರ ಮಾಲೀಕತ್ವವನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದರೆ ಅವನು ಅವನಿಗೆ ಸೇರಿದ ಫೈಲ್‌ನ ಗುಂಪನ್ನು ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ನಂತರ ಅದೇ ಗುಂಪಿನಲ್ಲಿರುವ ಇತರ ಬಳಕೆದಾರರಿಂದ ಈ ಫೈಲ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು. ಅದು ನಮಗೆ ಬೇಕು.

Git ಹುಕ್ ಅನ್ನು ಬಳಸುವುದು

ಹುಕ್‌ಗಾಗಿ ಕೆಲಸ ಮಾಡುವ ಡೈರೆಕ್ಟರಿಯು ಯೋಜನೆಯ ಮೂಲ ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ. ಹುಕ್ ಎನ್ನುವುದು ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಆಗಿದ್ದು ಅದು ಪುಶ್ ಮಾಡುವ ಬಳಕೆದಾರರ ಅಡಿಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ. ಇದನ್ನು ತಿಳಿದುಕೊಂಡು ನಾವು ನಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

[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

Git ಸರ್ವರ್‌ನಲ್ಲಿ, ಬದ್ಧತೆಯ ನಂತರ ನಾವು ಹುಕ್ ಪೋಸ್ಟ್-ಅಪ್‌ಡೇಟ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ

[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 .
Процесс не может получить доступ к файлу, так как этот файл занят другим процессом.

— Git ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಅಳಿಸಲು, ಡೈರೆಕ್ಟರಿಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆರವುಗೊಳಿಸಿ. ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಅಳಿಸುವುದು ಅಸಾಧ್ಯವಾದ ಕಾರಣ, ಉತ್ಪತ್ತಿಯಾಗುವ ದೋಷವನ್ನು ನಾವು ಸಹಿಸೋಣ, ಆದರೆ ಇದು ನಮಗೆ ಅಗತ್ಯವಿರುವ ನಡವಳಿಕೆಯಾಗಿದೆ.

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

ಲೇಖನದಲ್ಲಿ ನೀವು ಸಣ್ಣ ಉಪಯುಕ್ತ ವಿಷಯಗಳ ಮೇಲೆ ಮುಗ್ಗರಿಸಬಹುದು:

ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಡೈರೆಕ್ಟರಿ ಟ್ರೀ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು
ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಾಲಿನಿಂದ ಫೈಲ್‌ನ ಅಂತ್ಯಕ್ಕೆ ಸೆಡ್‌ನಲ್ಲಿ ವಿಳಾಸಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ರವಾನಿಸುವುದು, ಅಂದರೆ, ಮೊದಲ ಸಾಲನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಸಾಲುಗಳಲ್ಲಿ ಸೆಡ್ ಅನ್ನು ಬದಲಿಸುವುದು ಹೇಗೆ
ಲಿನಕ್ಸ್ ಹುಡುಕಾಟದಲ್ಲಿ ಹುಡುಕಾಟ ಸ್ಥಿತಿಯನ್ನು ಹೇಗೆ ತಿರುಗಿಸುವುದು
Linux ಶೆಲ್‌ನಲ್ಲಿ ಒಂದು-ಲೈನರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಬಹು ಸಾಲುಗಳನ್ನು ಲೂಪ್‌ಗೆ ಹೇಗೆ ರವಾನಿಸುವುದು
ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಒಂದೇ ಉಲ್ಲೇಖಗಳಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳುವುದು ಹೇಗೆ
ವಿಂಡೋಸ್ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಅದರ ಎಲ್ಲಾ ವಿಷಯಗಳೊಂದಿಗೆ ಡೈರೆಕ್ಟರಿಯನ್ನು ಹೇಗೆ ಅಳಿಸುವುದು
ಫೈಲ್ ಅನ್ನು ಪುನಃ ಬರೆಯದೆ ಮರುಹೆಸರಿಸಲು bash mv ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ನಿಮ್ಮ ಕಾಳಜಿಗೆ ಧನ್ಯವಾದಗಳು.

ಮೂಲ: www.habr.com

GIT ಸರ್ವರ್‌ಗೆ ಬಹು-ಬಳಕೆದಾರ ಪ್ರವೇಶದ ಸಂಘಟನೆ