ജിഐടി സെർവറിലേക്കുള്ള മൾട്ടി-യൂസർ ആക്‌സസ് ഓർഗനൈസേഷൻ

ഒരു Git സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുമ്പോൾ, നിരവധി പ്രോജക്റ്റുകളിലേക്ക് നിരവധി ഉപയോക്താക്കൾക്ക് ആക്സസ് സംഘടിപ്പിക്കുന്നതിനെക്കുറിച്ചുള്ള ചോദ്യം ഉയർന്നുവരുന്നു. ഞാൻ പ്രശ്നം അന്വേഷിച്ച് എന്റെ എല്ലാ ആവശ്യങ്ങളും നിറവേറ്റുന്ന ഒരു പരിഹാരം കണ്ടെത്തി: ലളിതവും സുരക്ഷിതവും വിശ്വസനീയവുമാണ്.

എന്റെ ആഗ്രഹങ്ങൾ ഇവയാണ്:

• ഓരോ ഉപയോക്താവും അവരുടെ സ്വന്തം അക്കൗണ്ടുമായി ബന്ധിപ്പിക്കുന്നു
• ഒരു പ്രോജക്റ്റിൽ നിരവധി ഉപയോക്താക്കൾക്ക് പ്രവർത്തിക്കാൻ കഴിയും
• ഒരേ ഉപയോക്താവിന് ഒന്നിലധികം പ്രോജക്ടുകളിൽ പ്രവർത്തിക്കാൻ കഴിയും
• ഓരോ ഉപയോക്താവിനും അവൻ പ്രവർത്തിക്കുന്ന പ്രോജക്റ്റുകളിലേക്ക് മാത്രമേ പ്രവേശനമുള്ളൂ
• ഏതെങ്കിലും തരത്തിലുള്ള വെബ് ഇന്റർഫേസിലൂടെ മാത്രമല്ല, കമാൻഡ് ലൈൻ വഴി കണക്റ്റുചെയ്യുന്നത് സാധ്യമായിരിക്കണം

അതും മികച്ചതായിരിക്കും:

• നിയന്ത്രിക്കുന്ന വ്യക്തികൾക്ക് വായന-മാത്രം അനുമതി നൽകുക
• Git-ൽ ഉപയോക്തൃ ആക്‌സസ് അവകാശങ്ങൾ സൗകര്യപ്രദമായി നിയന്ത്രിക്കുക

GIT സെർവർ ആക്സസ് ചെയ്യുന്നതിനുള്ള സാധ്യമായ ഓപ്ഷനുകളുടെ അവലോകനം

ഒന്നാമതായി, എന്താണ് തിരഞ്ഞെടുക്കേണ്ടതെന്ന് നിങ്ങൾ അറിയേണ്ടതുണ്ട്, അതിനാൽ Git പ്രോട്ടോക്കോളുകളുടെ ഒരു ദ്രുത അവലോകനം ഇതാ.

• ssh - സെർവർ ആക്സസ് ചെയ്യാൻ പ്രത്യേകം സൃഷ്ടിച്ച ഒരു ഉപയോക്തൃ അക്കൗണ്ട് ഉപയോഗിക്കുന്നു.
  • എല്ലാ റിപ്പോസിറ്ററികളും ആക്‌സസ് ചെയ്യുന്നതിന് ഒരു അക്കൗണ്ട് ഉപയോഗിക്കുന്നത് Git അതിന്റെ ശുപാർശകളിൽ നിന്ന് ഒഴിവാക്കുന്നില്ല എന്നത് വിചിത്രമാണ്. ഇത് എന്റെ ആവശ്യങ്ങൾ നിറവേറ്റുന്നില്ല.
  • നിങ്ങൾക്ക് ഒന്നിലധികം അക്കൗണ്ടുകൾ ഉപയോഗിക്കാം, എന്നാൽ ചില ഡയറക്‌ടറികളിലേക്ക് ഉപയോക്തൃ ആക്‌സസ് പരിമിതപ്പെടുത്തുന്നത് എങ്ങനെ?
    • ഹോം ഡയറക്ടറി അടയ്ക്കുന്നത് അനുയോജ്യമല്ല, കാരണം മറ്റ് ഉപയോക്താക്കൾക്ക് അവിടെ എഴുത്ത് ആക്സസ് സംഘടിപ്പിക്കുന്നത് ബുദ്ധിമുട്ടാണ്
    • നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിൽ നിന്നുള്ള സിംലിങ്കുകൾ ഉപയോഗിക്കുന്നത് ബുദ്ധിമുട്ടാണ്, കാരണം Git അവയെ ലിങ്കുകളായി വ്യാഖ്യാനിക്കുന്നില്ല
    • ഇന്റർപ്രെറ്ററിലേക്കുള്ള ആക്‌സസ് നിയന്ത്രിക്കുന്നത് സാധ്യമാണ്, എന്നാൽ ഇത് എല്ലായ്പ്പോഴും പ്രവർത്തിക്കുമെന്നതിന് പൂർണ്ണമായ ഉറപ്പില്ല
      • അത്തരം ഉപയോക്താക്കൾക്കായി നിങ്ങൾക്ക് സാധാരണയായി നിങ്ങളുടെ സ്വന്തം കമാൻഡ് ഇന്റർപ്രെറ്റർ ബന്ധിപ്പിക്കാൻ കഴിയും, പക്ഷേ
        • ഒന്നാമതായി, ഇത് ഇതിനകം ഒരുതരം ബുദ്ധിമുട്ടുള്ള തീരുമാനമാണ്,
        • രണ്ടാമതായി, ഇത് മറികടക്കാൻ കഴിയും.

  എന്നാൽ ഉപയോക്താവിന് ഏതെങ്കിലും കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്നത് ഒരു പ്രശ്നമല്ലായിരിക്കാം?.. പൊതുവേ, ഈ രീതി കൃത്യമായി എങ്ങനെ ഉപയോഗിക്കണമെന്ന് നിങ്ങൾ കണ്ടെത്തിയാൽ ഈ രീതി തള്ളിക്കളയാനാവില്ല. ഞങ്ങൾ പിന്നീട് ഈ രീതിയിലേക്ക് മടങ്ങും, എന്നാൽ ഇപ്പോൾ ഞങ്ങൾ മറ്റ് ഇതരമാർഗങ്ങൾ ചുരുക്കമായി പരിഗണിക്കും, ഒരുപക്ഷേ ലളിതമായ എന്തെങ്കിലും ഉണ്ടാകും.

• git ലോക്കൽ പ്രോട്ടോക്കോൾ sshfs-മായി സംയോജിപ്പിച്ച് ഉപയോഗിക്കാം, ഒന്നിലധികം ഉപയോക്താക്കൾ ഉപയോഗിക്കാം, പക്ഷേ മുമ്പത്തെ കേസിന് സമാനമാണ്
• http - വായിക്കാൻ മാത്രം
• git വായിക്കാൻ മാത്രം
• https - ഇൻസ്റ്റാൾ ചെയ്യാൻ പ്രയാസമാണ്, നിങ്ങൾക്ക് അധിക സോഫ്‌റ്റ്‌വെയർ ആവശ്യമാണ്, ഉപയോക്തൃ ആക്‌സസ് ഓർഗനൈസുചെയ്യുന്നതിന് ചില നിയന്ത്രണ പാനൽ... ഇത് സാധ്യമാണെന്ന് തോന്നുന്നു, പക്ഷേ എങ്ങനെയെങ്കിലും എല്ലാം സങ്കീർണ്ണമാണ്.

Git സെർവറിലേക്കുള്ള മൾട്ടി-യൂസർ ആക്‌സസ് ക്രമീകരിക്കുന്നതിന് ssh പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നു

നമുക്ക് ssh പ്രോട്ടോക്കോളിലേക്ക് മടങ്ങാം.

നിങ്ങൾ ജിറ്റിനായി ssh ആക്‌സസ് ഉപയോഗിക്കുന്നതിനാൽ, സെർവർ ഡാറ്റയുടെ സുരക്ഷ നിങ്ങൾ ഉറപ്പാക്കേണ്ടതുണ്ട്. ssh വഴി കണക്ട് ചെയ്യുന്ന ഉപയോക്താവ് Linux സെർവറിൽ സ്വന്തം ലോഗിൻ ഉപയോഗിക്കുന്നു, അതിനാൽ അവർക്ക് ssh ക്ലയന്റ് വഴി കണക്റ്റുചെയ്യാനും സെർവറിന്റെ കമാൻഡ് ലൈൻ ആക്സസ് ചെയ്യാനും കഴിയും.
അത്തരം പ്രവേശനത്തിനെതിരെ പൂർണ്ണമായ പരിരക്ഷയില്ല.

എന്നാൽ ഉപയോക്താവിന് Linux ഫയലുകളിൽ താൽപ്പര്യമുണ്ടാകരുത്. പ്രധാനപ്പെട്ട വിവരങ്ങൾ 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" പ്രോജക്റ്റ് 1, പ്രോജ് 2 എന്നിവയിലും "ഡെവലപ്പർ 2" പ്രോജക്റ്റ് 2, പ്രോജ് 3 എന്നിവയിലും പ്രവർത്തിക്കുന്നു.

ഏതെങ്കിലും ഡെവലപ്പർമാർ കമാൻഡ് ലൈൻ വഴി ssh വഴി കണക്റ്റുചെയ്യുകയാണെങ്കിൽ, അവർ പങ്കെടുക്കാത്ത പ്രോജക്റ്റ് ഡയറക്ടറികളുടെ ഉള്ളടക്കം കാണാൻ പോലും അവരുടെ അവകാശങ്ങൾ പര്യാപ്തമല്ല. ഇത് സ്വയം മാറ്റാൻ അദ്ദേഹത്തിന് കഴിയില്ല.

ഈ തത്വത്തിന്റെ അടിസ്ഥാനം ലിനക്സ് അവകാശങ്ങളുടെ അടിസ്ഥാന സുരക്ഷയായതിനാൽ, ഈ സ്കീം വിശ്വസനീയമാണ്. കൂടാതെ, സ്കീം കൈകാര്യം ചെയ്യാൻ വളരെ എളുപ്പമാണ്.

നമുക്ക് പരിശീലനത്തിലേക്ക് പോകാം.

ഒരു ലിനക്സ് സെർവറിൽ 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 എന്ന ഉപയോക്താവിന് കഴിയില്ല, ഇത് പ്രവർത്തനക്ഷമതയിൽ തകർച്ചയിലേക്ക് നയിച്ചേക്കാം.

Linux chown - ഒരു സാധാരണ ഉപയോക്താവ് ഫയലിന്റെ ഉടമയെ മാറ്റുന്നു

ഒരു ഫയലിന്റെ ഉടമസ്ഥന് അതിന്റെ ഉടമസ്ഥാവകാശം മാറ്റാൻ കഴിയില്ല. എന്നാൽ അയാൾക്ക് അവന്റെ ഉടമസ്ഥതയിലുള്ള ഒരു ഫയലിന്റെ ഗ്രൂപ്പ് മാറ്റാൻ കഴിയും, തുടർന്ന് അതേ ഗ്രൂപ്പിലുള്ള മറ്റ് ഉപയോക്താക്കൾക്ക് ഈ ഫയൽ പരിഷ്കരിക്കാനാകും. അതാണ് നമുക്ക് വേണ്ടത്.

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

ലേഖനത്തിൽ നിങ്ങൾക്ക് ചെറിയ ഉപയോഗപ്രദമായ കാര്യങ്ങളിൽ ഇടറിവീഴാം:

• ലിനക്സിൽ ഒരു ഡയറക്ടറി ട്രീ എങ്ങനെ നിർമ്മിക്കാം
• ഒരു നിശ്ചിത വരിയിൽ നിന്ന് ഫയലിന്റെ അവസാനത്തിലേക്ക് sed-ൽ വിലാസങ്ങളുടെ ഒരു ശ്രേണി എങ്ങനെ കൈമാറാം, അതായത്, ആദ്യ വരി ഒഴികെയുള്ള എല്ലാ വരികളിലും sed-ൽ പകരം വയ്ക്കുന്നത് എങ്ങനെ
• Linux ഫൈൻഡിൽ ഒരു തിരയൽ അവസ്ഥ എങ്ങനെ വിപരീതമാക്കാം
• Linux ഷെല്ലിലെ ഒരു വൺ-ലൈനർ ഉപയോഗിച്ച് ഒരു ലൂപ്പിലേക്ക് ഒന്നിലധികം ലൈനുകൾ എങ്ങനെ കടത്തിവിടാം
• ബാഷിലെ ഒറ്റ ഉദ്ധരണികളിൽ നിന്ന് എങ്ങനെ രക്ഷപ്പെടാം
• വിൻഡോസ് കമാൻഡ് ലൈനിലെ എല്ലാ ഉള്ളടക്കങ്ങളുമുള്ള ഒരു ഡയറക്ടറി എങ്ങനെ ഇല്ലാതാക്കാം
• ഒരു ഫയൽ വീണ്ടും വീണ്ടും എഴുതാതെ തന്നെ പേരുമാറ്റാൻ ബാഷ് എംവി എങ്ങനെ ഉപയോഗിക്കാം

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി.

അവലംബം: www.habr.com