Gitolite ile Ubuntu 12.04 VPS Üzerinde Git Sunucusuna Erişimi Kontrol Etme

Gitolite ile Ubuntu 12.04 VPS Üzerinde Git Sunucusuna Erişimi Kontrol Etme

Git, modern yazılım geliştirme süreçlerinin vazgeçilmez bir parçası haline gelmiş, dağıtık bir versiyon kontrol sistemidir. Ekiplerin kod üzerinde işbirliği yapmasını kolaylaştırırken, projelerin geçmişini takip etme ve farklı sürümler arasında geçiş yapma imkanı sunar. Büyük veya küçük ölçekli projelerde, birden fazla geliştiricinin aynı kod tabanı üzerinde çalışması gerektiğinde, merkezi bir Git sunucusu kurmak yaygın bir yaklaşımdır. Ancak, bu merkezi sunucuya kimlerin erişebileceği, hangi depolara hangi yetkilerle erişebileceği gibi konular, güvenlik ve yönetim açısından kritik öneme sahiptir. İşte tam bu noktada Gitolite devreye girer.

Gitolite, SSH üzerinden Git depolarına erişimi kontrol etmek için tasarlanmış basit ama güçlü bir yetkilendirme katmanıdır. SSH anahtar tabanlı kimlik doğrulama üzerine inşa edilmiş olup, kullanıcıların SSH anahtarları aracılığıyla kimliklerini doğrulamalarını sağlar. Gitolite, merkezi bir yapılandırma dosyası (gitolite.conf) ve kullanıcıların SSH genel anahtarlarını içeren bir dizin (keydir) kullanarak, hangi kullanıcının hangi depoya okuma, yazma veya daha spesifik yetkilerle erişebileceğini detaylı bir şekilde tanımlamanıza olanak tanır. Bu makalede, Ubuntu 12.04 yüklü bir VPS (Sanal Özel Sunucu) üzerinde Gitolite’ı nasıl kuracağınızı, yapılandıracağınızı ve kullanarak Git depolarına erişimi nasıl yöneteceğinizi adım adım açıklayacağız. Ubuntu 12.04 her ne kadar “End of Life” (EOL) bir sürüm olsa da, Gitolite’ın temel kurulum ve çalışma prensipleri bu sürümde de geçerlidir ve konseptleri anlamak için iyi bir başlangıç noktası sunar. Güvenlik nedeniyle, üretim ortamlarında her zaman güncel ve desteklenen işletim sistemi sürümlerinin kullanılması şiddetle tavsiye edilir.

Gitolite Neden Kullanılmalı?

Gitolite, özellikle birden fazla depo ve kullanıcıya sahip Git sunucularında erişim kontrolünü basitleştirmek ve güvenliği artırmak için birçok avantaj sunar:

* Merkezi Yetkilendirme: Tüm erişim kuralları tek bir yapılandırma dosyasında (gitolite.conf) toplanır. Bu, yönetimi kolaylaştırır ve tutarlılık sağlar.
* SSH Anahtar Tabanlı Güvenlik: Kullanıcılar parola yerine SSH anahtarları ile kimlik doğrulaması yapar. Bu, genellikle daha güvenli ve otomatize edilebilir bir yöntemdir.
* Detaylı Erişim Kontrolü: Depo bazında, kullanıcı bazında ve hatta dal (branch) veya etiket (tag) bazında okuma/yazma izinleri tanımlanabilir. Force push (zorla gönderme) gibi hassas operasyonlar da kontrol altına alınabilir.
* Düşük Kaynak Tüketimi: Gitolite, hafif bir yapıya sahiptir ve sunucu üzerinde minimum kaynak harcar.
* Yönetim Kolaylığı: Gitolite’ın yönetimi, Git depoları gibi gitolite-admin adlı özel bir depo üzerinden yapılır. Bu, yapılandırma değişikliklerinin versiyonlanmasını ve geri alınabilmesini sağlar.
* Esneklik: Kullanıcı grupları tanımlama, wildcard depolar oluşturma ve özel kancalar (hooks) entegre etme gibi gelişmiş özellikler sunar.

Ön Gereksinimler

Kuruluma başlamadan önce aşağıdaki ön gereksinimlerin karşılandığından emin olmalısınız:

* Ubuntu 12.04 VPS: SSH erişimi olan ve root veya sudo yetkilerine sahip bir kullanıcı hesabınız olmalı.
* Git: VPS üzerinde Git’in kurulu olması gerekir. Eğer kurulu değilse sudo apt-get install git komutu ile kurabilirsiniz.
* SSH İstemcisi: Yerel makinenizde bir SSH istemcisi ve ssh-keygen aracı bulunmalı.
* Temel Linux Bilgisi: Komut satırı kullanımı ve dosya izinleri hakkında temel bilgiye sahip olmanız faydalı olacaktır.
* Yönetici SSH Anahtarı: Gitolite’ı yönetecek olan kullanıcının (yerel makinenizdeki kullanıcının) bir SSH genel anahtarına ihtiyacı olacaktır. Eğer yoksa, yerel makinenizde aşağıdaki komutla bir anahtar çifti oluşturabilirsiniz:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Bu komut, genellikle ~/.ssh/id_rsa (özel anahtar) ve ~/.ssh/id_rsa.pub (genel anahtar) dosyalarını oluşturur. Kurulum sırasında bu genel anahtarı kullanacağız.

Adım 1: Gitolite İçin Bir Kullanıcı Oluşturma

Gitolite, genellikle kendi özel sistem kullanıcısı altında çalışır. Bu, güvenlik açısından iyi bir uygulamadır, çünkü Gitolite’ın yetkileri bu kullanıcıyla sınırlı kalır ve diğer sistem hizmetlerinden izole edilir.

1.1. git Kullanıcısı Oluşturma

VPS’inize SSH ile bağlanın ve git adında yeni bir sistem kullanıcısı oluşturun. Bu kullanıcıya parola vermeyeceğiz, çünkü kimlik doğrulama SSH anahtarları üzerinden yapılacak. Ayrıca, bu kullanıcının oturum açma kabuğunu (login shell) git-shell olarak ayarlayacağız. git-shell, Git depolarına SSH üzerinden erişimi kısıtlayan ve sadece Git komutlarının çalıştırılmasına izin veren kısıtlı bir kabuktur. Bu, yetkisiz kullanıcıların sunucuda rastgele komutlar çalıştırmasını engeller.

sudo adduser --system --shell /usr/bin/git-shell --gecos 'git version control' --disabled-password --group git

Bu komut:
* --system: git kullanıcısını bir sistem kullanıcısı olarak oluşturur (genellikle daha düşük UID’ye sahiptir ve varsayılan olarak home dizini oluşturulmaz).
* --shell /usr/bin/git-shell: Kullanıcının kabuğunu git-shell olarak ayarlar.
* --gecos 'git version control': GECOS alanını doldurur.
* --disabled-password: Kullanıcıya parola atanmasını engeller.
* --group git: git adında birincil bir grup oluşturur ve kullanıcıyı bu gruba ekler.

adduser komutu genellikle kullanıcının ana dizinini de oluşturur. Eğer oluşturmazsa, manuel olarak oluşturmanız gerekebilir:

sudo mkdir /home/git
sudo chown git:git /home/git
sudo chmod 755 /home/git

Ubuntu 12.04’te --system ile kullanıcı oluşturulduğunda varsayılan olarak /home/git yerine /var/lib/git gibi bir dizin oluşturulabilir. Gitolite’ın kurulum betiği bu durumu otomatik olarak yönetecektir, ancak ana dizinin /home/git olduğundan emin olmak daha doğru olacaktır. Eğer /home/git dizini yoksa ve git kullanıcısının ana dizini başka bir yerdeyse, sudo usermod -d /home/git git komutu ile değiştirebilirsiniz.

1.2. Git Kullanıcısının SSH Dizinini Hazırlama

Gitolite, yönetici kullanıcının SSH genel anahtarını git kullanıcısının ana dizinindeki .ssh dizinine yerleştirerek kurulur. Bu dizinin ve içindeki dosyaların doğru izinlere sahip olması kritik öneme sahiptir.

sudo mkdir /home/git/.ssh
sudo chown git:git /home/git/.ssh
sudo chmod 700 /home/git/.ssh

Adım 2: Gitolite Kurulumu

Şimdi Gitolite yazılımını sunucuya kurma zamanı. Gitolite’ı kurmanın en yaygın yolu, projenin kendi Git deposunu klonlamak ve ardından kurulum betiğini çalıştırmaktır.

2.1. Gitolite Deposunu Klonlama

git kullanıcısı olarak, Gitolite’ın resmi deposunu klonlayın. Bu işlemi git kullanıcısının ana dizininde yapmalısınız.

sudo su - git
git clone https://github.com/sitaramc/gitolite.git bin

Yukarıdaki komutla git kullanıcısına geçiş yaptık ve Gitolite deposunu bin adında bir dizine klonladık. Bu dizin, Gitolite’ın çalıştırılabilir betiklerini içerecektir.

2.2. Gitolite’ı Kurma

Depoyu klonladıktan sonra, gitolite-admin deposunu ve ~/.gitolite dizinini oluşturan kurulum betiğini çalıştırmanız gerekir. Bu adımda, yerel makinenizdeki yönetici SSH genel anahtarını sunucuya kopyalamanız gerekecektir.

Öncelikle, yerel makinenizden yönetici genel anahtarınızı (örneğin ~/.ssh/id_rsa.pub) sunucuya kopyalayın. scp komutunu kullanabilirsiniz:

# Yerel makinenizde
scp ~/.ssh/id_rsa.pub your_user@your_vps_ip:/tmp/admin.pub

Ardından, VPS’e geri dönün ve git kullanıcısı olarak kurulumu tamamlayın. git kullanıcısı olarak bin dizininde olduğunuzdan emin olun.

# VPS'te, hala 'git' kullanıcısı olarak
cd bin
./install -ln

Bu komut, Gitolite’ın çalıştırılabilir dosyalarını ~git/bin dizinine yükler ve PATH’e ekler.

Şimdi, Gitolite’ı ilk yönetici anahtarınızla başlatın:

./src/gitolite setup -pk /tmp/admin.pub

Bu komut:
* ~git/.gitolite dizinini oluşturur.
* ~git/.gitolite/conf/gitolite.conf ve ~git/.gitolite/keydir/admin.pub dosyalarını oluşturur.
* gitolite-admin deposunu başlatır.

setup komutunu çalıştırdıktan sonra /tmp/admin.pub dosyasını silebilirsiniz:

rm /tmp/admin.pub

Artık git kullanıcısı oturumundan çıkabilirsiniz:

exit

Adım 3: Yönetici Anahtarını Kopyalama ve İlk Yapılandırma

Gitolite’ın yönetimi, özel bir Git deposu olan gitolite-admin aracılığıyla yapılır. Bu depoyu yerel makinenize klonlayarak, Gitolite yapılandırma dosyasını ve kullanıcı anahtarlarını yönetebilirsiniz.

3.1. gitolite-admin Deposunu Klonlama

Yerel makinenizde, Gitolite sunucunuzdan gitolite-admin deposunu klonlayın:

# Yerel makinenizde
git clone git@your_vps_ip:gitolite-admin

Bu komut, gitolite-admin adında yeni bir dizin oluşturacaktır. Bu dizinin içine girdiğinizde iki önemli alt dizin göreceksiniz:
* conf/: Gitolite yapılandırma dosyasını (gitolite.conf) içerir.
* keydir/: Kullanıcıların SSH genel anahtarlarını içerir. Kurulum sırasında sağladığınız admin.pub dosyası burada olmalıdır.

Bu adım başarılı olursa, Gitolite kurulumunuzun temel olarak doğru çalıştığını gösterir. Eğer bir hata alırsanız (örneğin “Permission denied (publickey)”), SSH anahtarınızın doğru yüklendiğinden ve sunucuda git kullanıcısının ana dizinindeki .ssh/authorized_keys dosyasında bulunduğundan emin olun.

Adım 4: Kullanıcı Ekleme ve Depo Oluşturma

Şimdi Gitolite’ın gücünü kullanmaya başlayabiliriz: yeni kullanıcılar eklemek ve onlara belirli depolara erişim yetkisi vermek.

4.1. Yeni Kullanıcı İçin SSH Anahtarı Oluşturma

İlk olarak, yeni bir kullanıcı (örneğin kullanici1) için bir SSH anahtar çifti oluşturun. Bu anahtar, kullanici1‘in kendi yerel makinesinde oluşturulmalıdır.

# Kullanici1'in yerel makinesinde (veya sizin makinenizde test için)
ssh-keygen -t rsa -b 4096 -C "kullanici1@example.com" -f ~/.ssh/id_rsa_kullanici1

Bu komut ~/.ssh/id_rsa_kullanici1 (özel anahtar) ve ~/.ssh/id_rsa_kullanici1.pub (genel anahtar) dosyalarını oluşturacaktır.

4.2. Kullanıcı Anahtarını gitolite-admin Deposuna Ekleme

Şimdi kullanici1‘in genel anahtarını gitolite-admin deponuzun keydir/ dizinine kopyalamanız gerekiyor.

# Yerel makinenizde (yönetici olarak)
cd gitolite-admin
cp ~/.ssh/id_rsa_kullanici1.pub keydir/kullanici1.pub

keydir içindeki dosya isimleri, Gitolite’ın kullanıcıları tanımasında kullanılır. Bu nedenle kullanici1.pub gibi anlamlı isimler vermek önemlidir.

4.3. gitolite.conf Dosyasını Düzenleme

Şimdi conf/gitolite.conf dosyasını açın ve yeni bir depo oluşturun, kullanici1‘e bu depoya erişim yetkisi verin.

# Yerel makinenizde (yönetici olarak)
nano conf/gitolite.conf

Dosyanın içeriği başlangıçta şuna benzer olabilir:

repo gitolite-admin
    RW+ = admin

repo testing
    RW+ = @all

testing deposunun RW+ = @all kuralı, tüm kullanıcılara bu depoya tam erişim sağlar. Bu genellikle test amaçlıdır. Biz kendi özel depomuzu oluşturalım:

repo gitolite-admin
    RW+ = admin

repo my_project
    RW = kullanici1
    R = admin # admin sadece okuyabilir, yazamaz (varsayılanı değiştirdik)

@developers = kullanici1 kullanici2
repo another_project
    RW+ = @developers
    R = anon_user

Yukarıdaki örnekte:
* repo my_project: my_project adında yeni bir Git deposu tanımlar.
* RW = kullanici1: kullanici1‘e my_project deposuna okuma ve yazma yetkisi verir.
* R = admin: admin kullanıcısına my_project deposuna sadece okuma yetkisi verir.
* @developers = kullanici1 kullanici2: developers adında bir kullanıcı grubu tanımlar.
* repo another_project: another_project adında yeni bir depo tanımlar.
* RW+ = @developers: developers grubundaki tüm kullanıcılara another_project deposuna tam (okuma, yazma, force push) yetki verir.
* R = anon_user: anon_user özel anahtarı olmayan herkesin (genellikle git daemon veya gitweb üzerinden) depoyu okuyabileceğini belirtir. Bu genelde herkese açık depolar için kullanılır.

Değişiklikleri kaydedin ve dosyayı kapatın.

4.4. Değişiklikleri Gitolite Sunucusuna Gönderme

gitolite-admin deposunda yaptığınız değişiklikleri commit edin ve sunucuya push edin:

# Yerel makinenizde (yönetici olarak)
git add keydir/kullanici1.pub conf/gitolite.conf
git commit -m "Add kullanici1 and my_project repo"
git push

Bu git push komutu, Gitolite sunucusundaki yapılandırmayı güncelleyecektir. Gitolite, bu değişiklikleri otomatik olarak algılar ve yeni kullanıcıları ve depoları yapılandırır.

Adım 5: Yeni Kullanıcıların Depolara Erişimi

Şimdi kullanici1‘in my_project deposuna erişip erişemediğini test edelim.

5.1. my_project Deposunu Klonlama

kullanici1‘in makinesinde (veya test için kendi makinenizde kullanici1‘in özel anahtarını kullanarak):

# Kullanici1'in yerel makinesinde (veya kendi makinenizde)
Eğer farklı bir anahtar kullanıyorsanız, SSH agent'a eklemeniz veya -i parametresiyle belirtmeniz gerekebilir.
ssh-add ~/.ssh/id_rsa_kullanici1
git clone git@your_vps_ip:my_project

Eğer her şey doğru yapılandırıldıysa, my_project deposu başarıyla klonlanacaktır. Bu, kullanici1‘in kimlik doğrulamasının başarılı olduğu ve my_project deposuna erişim izni olduğu anlamına gelir.

kullanici1 şimdi bu depoya commit yapabilir ve push edebilir:

# Kullanici1'in yerel makinesinde
cd my_project
echo "Hello from kullanici1" > README.md
git add README.md
git commit -m "Initial commit from kullanici1"
git push origin master

Bu işlem de sorunsuz gerçekleşmelidir.

Gitolite Yapılandırma Dosyasının Detayları (gitolite.conf)

gitolite.conf dosyası, Gitolite’ın kalbidir ve erişim kontrol kurallarını tanımlar. Dosyanın yapısını ve yaygın kullanılan kuralları anlamak, etkili bir yönetim için kritik öneme sahiptir.

6.1. Depo Tanımları

Her depo, repo anahtar kelimesiyle başlar.

repo 
    

Depo adları, yolu içerebilir (örn. team/project-a). Gitolite, bu yolu otomatik olarak oluşturur.

6.2. Grup Tanımları

Kullanıcı grupları tanımlayarak erişim kurallarını basitleştirebilirsiniz. Grup adları @ işaretiyle başlar.

@ =   ...

Örnek:

@devs = alice bob charlie
@managers = dave eve

Daha sonra bu grupları erişim kurallarında kullanabilirsiniz: RW+ = @devs.

6.3. Erişim İzinleri

Erişim izinleri, R, RW, RW+ ve RW C gibi anahtar kelimelerle tanımlanır.

* R (Read-only): Salt okunur erişim. Kullanıcılar depoyu klonlayabilir ve çekebilir (pull), ancak değişiklik gönderemez (push).

R = anon_user

* RW (Read-Write): Okuma ve yazma erişimi. Kullanıcılar depoyu klonlayabilir, çekebilir ve değişiklik gönderebilir. Ancak, geçmişi değiştiren (rewriting history) force push işlemlerine izin verilmez.

RW = developer1

* RW+ (Read-Write-Rewind): Okuma, yazma ve geçmişi geri sarma (rewind) erişimi. Bu, force push işlemlerine izin verir. Dikkatli kullanılmalıdır, çünkü başkalarının çalışmalarını üzerine yazabilir.

RW+ = lead_developer

* RW C (Read-Write-Create): Okuma, yazma ve yeni dal (branch) veya etiket (tag) oluşturma erişimi. Bu, RW‘ye benzer ancak özellikle yeni referanslar oluşturma yeteneğini vurgular. Genellikle RW ile aynı anlamda kullanılır, çünkü RW zaten yeni referans oluşturmaya izin verir.

6.4. Referans Tabanlı İzinler (Refexes)

Gitolite’ın en güçlü özelliklerinden biri, erişim izinlerini belirli dallara veya etiketlere göre kısıtlama yeteneğidir. Buna “refex” (reference expression) denir.

repo my_project
    RW master = alice        # Alice sadece 'master' dalına yazabilir
    RW dev/ = bob            # Bob 'dev/' ile başlayan tüm dallara yazabilir (örn. dev/feature-a, dev/bugfix-b)
    RW+ = charlie            # Charlie her yere force push yapabilir
    R = @all                 # Herkes depoyu okuyabilir

* refs/heads/master: Sadece master dalı.
* refs/heads/dev/: dev/ ile başlayan tüm dallar (örn. dev/feature, dev/bugfix).
* refs/tags/: Tüm etiketler.
refs/heads/foo.: foo ile başlayan ve herhangi bir karakterle devam eden dallar.
* refs/heads/master|develop: master veya develop dalları.

Refex’ler, daha karmaşık ve granular erişim kontrolü sağlamak için çok kullanışlıdır. Örneğin, master dalına sadece bir CI/CD sistemi veya belirli bir yönetici grubunun push yapmasına izin verebilirsiniz.

6.5. Özel Kurallar ve Konfigürasyonlar

gitolite.conf içinde bazı özel anahtar kelimeler de bulunur:

* config: Depo bazında Git yapılandırma ayarları tanımlamanıza olanak tanır.

repo my_project
        config gitweb.owner = "My Team"

* daemon ve gitweb: git-daemon ve gitweb hizmetleri aracılığıyla depolara erişimi kontrol eder. Genellikle public_read = yes veya public_read = no gibi değerler alırlar.

repo public_repo
        daemon = R
        gitweb = R

Bu, public_repo‘nun anonim olarak okunabilir olduğunu belirtir.

6.6. Kalıtım (Inheritance)

Gitolite, depo adları hiyerarşik olduğunda kalıtım kurallarını da uygular. Örneğin:

repo foo
    RW = alice

repo foo/bar
    RW = bob

Bu durumda foo/bar deposuna erişim için hem foo hem de foo/bar kuralları geçerli olur. Daha spesifik kurallar (alt dizinler için) daha genel kurallardan (üst dizinler için) önceliklidir.

Gelişmiş Gitolite Özellikleri

Gitolite, temel erişim kontrolünün ötesinde birçok gelişmiş özellik sunar:

7.1. VHOOK’lar (Veritabanı Kancaları)

Gitolite, Git kancalarını (hooks) kullanarak çeşitli olaylar üzerinde özel betikler çalıştırmanıza olanak tanır. Gitolite, bu kancaların yönetimini de kolaylaştırır. VREF kancaları, push işleminden önce veya sonra belirli kontrolleri yapmanızı sağlar. Örneğin, bir commit mesajının belirli bir formata uyup uymadığını kontrol edebilir veya bir dalın silinmesini engelleyebilirsiniz. Bu, CI/CD süreçleriyle entegrasyon için güçlü bir araçtır.

7.2. Wildcard Depolar

Dinamik olarak depo oluşturmanız gerektiğinde wildcard depolar çok kullanışlıdır. Örneğin, her kullanıcıya kendi kişisel deposunu oluşturma yetkisi vermek isteyebilirsiniz:

repo users/%
    RW+ = @all

Bu kural, users/alice, users/bob gibi tüm depoları kapsar. % işareti, kullanıcı adı veya herhangi bir dizeyle eşleşir.

7.3. Yansılama (Mirroring)

Gitolite, depoları başka sunuculara otomatik olarak yansıtma (mirroring) yeteneğine sahiptir. Bu, yedekleme veya coğrafi olarak dağıtılmış geliştirme ekipleri için faydalıdır.

repo my_project
    mirror = git@backup_server:my_project.git

7.4. Gitolite Yönetimini Devretme

Büyük ekiplerde, Gitolite yönetimini tek bir kişiye bırakmak yerine, belirli kullanıcılara gitolite-admin deposuna erişim yetkisi vererek yönetimi devredebilirsiniz.

repo gitolite-admin
    RW+ = admin
    RW+ = team_lead

Bu, team_lead kullanıcısının da gitolite.conf ve keydir dosyalarını düzenleyebileceği ve Gitolite yapılandırmasını yönetebileceği anlamına gelir.

Sorun Giderme ve İpuçları

Gitolite ile çalışırken karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

* Permission denied (publickey) hatası:
* Yönetici veya kullanıcı SSH genel anahtarının git kullanıcısının ~/.ssh/authorized_keys dosyasında doğru bir şekilde bulunduğundan emin olun.
* Yerel makinenizde doğru özel anahtarı kullandığınızdan ve SSH agent’a eklediğinizden emin olun (ssh-add ~/.ssh/id_rsa).
* Sunucudaki ~git/.ssh dizininin ve authorized_keys dosyasının doğru izinlere sahip olduğundan emin olun (chmod 700 ~/.ssh, chmod 600 ~/.ssh/authorized_keys).
* ssh -v git@your_vps_ip komutu ile detaylı hata ayıklama çıktısı alabilirsiniz.
* Depo klonlanamıyor veya push yapılamıyor:
* gitolite.conf dosyasındaki erişim kurallarını kontrol edin. Kullanıcının ilgili depoya doğru yetkilere sahip olduğundan emin olun (RW, RW+).
* gitolite-admin deposuna değişiklikleri push etmeyi unutup unutmadığınızı kontrol edin.
* GL_LOGLEVEL=DEBUG: Gitolite’ın daha detaylı günlük kaydı tutmasını sağlamak için GL_LOGLEVEL=DEBUG ortam değişkenini kullanabilirsiniz. Örneğin, ssh GL_LOGLEVEL=DEBUG git@your_vps_ip info komutu, Gitolite’ın çalışma anındaki detaylı bilgilerini gösterecektir.
* Yanlış anahtar dosyası isimleri: keydir/ dizinindeki genel anahtar dosyalarının adları (örn. kullanici1.pub), gitolite.conf dosyasında kullanılan kullanıcı adlarıyla eşleşmelidir.

Güvenlik Hususları

Gitolite, Git sunucunuzun güvenliğini artırmak için tasarlanmış olsa da, bazı önemli güvenlik noktalarına dikkat etmek önemlidir:

* git-shell Kabuğu: git kullanıcısının kabuğunun git-shell olarak ayarlandığından emin olun. Bu, yetkisiz kullanıcıların sunucuda rastgele komutlar çalıştırmasını engeller.
* SSH Anahtarlarının Güvenliği: Hem sunucu hem de istemci tarafında SSH özel anahtarlarınızı güvende tutun. Güçlü parolalar (passphrases) kullanın ve anahtarlarınızı yetkisiz erişime karşı koruyun.
* En Az Ayrıcalık Prensibi: gitolite.conf dosyasını yapılandırırken, kullanıcılara sadece ihtiyaç duydukları minimum yetkileri verin. Özellikle RW+ (force push) yetkisini dikkatli kullanın.
* Ubuntu 12.04 EOL Durumu: Bu makale Ubuntu 12.04 üzerinde Gitolite kurulumunu anlatsa da, bu işletim sistemi sürümü artık Canonical tarafından desteklenmemektedir (End of Life). Bu, güvenlik güncellemeleri almadığı anlamına gelir ve üretim ortamlarında kullanılması ciddi güvenlik riskleri taşır. Mümkünse, Gitolite’ı daha güncel ve desteklenen bir Ubuntu (veya başka bir Linux dağıtımı) sürümüne kurmayı düşünmelisiniz. Temel Gitolite prensipleri yeni sürümlerde de aynı kalacaktır.

Sonuç

Gitolite, Ubuntu 12.04 VPS üzerinde Git sunucularına erişimi yönetmek için basit, güvenli ve esnek bir çözümdür. SSH anahtar tabanlı kimlik doğrulama, merkezi yapılandırma ve detaylı erişim kontrolü yetenekleri sayesinde, geliştirme ekiplerinin işbirliğini güvenli bir şekilde sürdürmelerini sağlar. Bu makalede adım adım kurulum sürecini, temel yapılandırmayı, kullanıcı ve depo yönetimini ve gitolite.conf dosyasının detaylarını ele aldık. Ayrıca, Gitolite’ın sunduğu gelişmiş özelliklere ve karşılaşabileceğiniz sorun giderme ipuçlarına da değindik. Güvenlik hususlarını göz önünde bulundurarak ve en iyi uygulamaları takip ederek, Gitolite ile sağlam ve yönetilebilir bir Git altyapısı kurabilirsiniz. Unutmayın, üretim ortamlarında her zaman güncel ve desteklenen yazılım sürümlerini kullanmak en iyi güvenlik uygulamasıdır.