Özel Go Modüllerini Kendi Projenizde Kullanma Rehberi

Özel Go Modüllerini Kendi Projenizde Kullanma Rehberi

Go dili, basitliği, performansı ve güçlü eşzamanlılık yetenekleriyle modern yazılım geliştirmede hızla popülerlik kazanmıştır. Go ekosisteminin temel taşlarından biri de modüllerdir. Modüller, kodun yeniden kullanılabilirliğini artıran, bağımlılıkları yönetmeyi kolaylaştıran ve projeleri daha düzenli hale getiren bir mekanizmadır. Çoğu zaman açık kaynaklı modülleri kullanırız, ancak kurumsal ortamlarda veya özel projelerde kendi geliştirdiğimiz veya erişimi kısıtlı olan özel (private) Go modüllerine ihtiyaç duyarız. Bu özel modüller, fikri mülkiyetimizi korumak, dahili araçları paylaşmak veya belirli güvenlik gereksinimlerini karşılamak için vazgeçilmezdir.

Ancak, özel Go modüllerini kendi projelerinize dahil etmek, açık kaynaklı modülleri kullanmaktan biraz daha karmaşık olabilir. Go’nun varsayılan bağımlılık yönetim sistemi, modüllere genellikle genel internet üzerinden erişilebileceğini varsayar. Bu makale, özel Go modüllerini kendi projelerinizde sorunsuz bir şekilde kullanabilmeniz için gerekli adımları, yapılandırmaları ve en iyi uygulamaları ayrıntılı olarak ele alacaktır. Kimlik doğrulama mekanizmalarından ortam değişkenlerinin doğru yapılandırılmasına, sık karşılaşılan sorunlardan CI/CD entegrasyonuna kadar her yönüyle bu konuyu inceleyeceğiz.

Go Modülleri ve Bağımlılık Yönetimine Genel Bakış

Go 1.11 ile birlikte tanıtılan Go Modülleri, Go projelerinde bağımlılık yönetiminin standart yolu haline gelmiştir. Bir Go modülü, sürüm kontrolü altında olan ve birlikte versiyonlanan bir paket koleksiyonudur. Her modülün kök dizininde bir go.mod dosyası bulunur ve bu dosya modülün yolunu, gerektirdiği bağımlılıkları ve Go sürümünü tanımlar.

* go.mod: Modülün kendisini ve doğrudan bağımlılıklarını tanımlayan ana dosyadır. Modül yolu (örneğin, github.com/myuser/mymodule), require (gerektirilen modüller ve versiyonları), exclude (hariç tutulan modüller) ve replace (bir modülün başka bir modülle değiştirilmesi) direktiflerini içerir.
* go.sum: Modül bağımlılıklarının kriptografik özetlerini (checksum) içerir. Bu, indirilen bağımlılıkların bütünlüğünü ve değişmediğini doğrulamak için kullanılır ve güvenlik açısından kritik öneme sahiptir.
* go get: Belirtilen bir paketi veya modülü indirir ve go.mod dosyasına ekler.
* go mod tidy: go.mod dosyasını temizler, kullanılmayan bağımlılıkları kaldırır ve eksik olanları ekler.
* go build / go run: Projeyi derler veya çalıştırır. Bu komutlar, bağımlılıkları otomatik olarak çözer ve indirir (eğer önbellekte yoksa).

Go, modülleri genellikle bir Go modül proxy’si (varsayılan olarak proxy.golang.org) aracılığıyla indirir. Bu proxy’ler, modülleri önbelleğe alarak indirme hızını artırır ve kararlılık sağlar. Ancak özel modüller, proxy’ler tarafından erişilemez olduğundan, bu mekanizmanın nasıl atlatılacağını bilmek gerekir.

Özel Go Modüllerinin Barındırılması

Özel Go modülleri, genellikle Git tabanlı bir sürüm kontrol sisteminde barındırılır. En yaygın seçenekler şunlardır:

1. GitHub Private Repositories: En popüler seçeneklerden biridir. Özel depolar, belirli kullanıcılara veya ekiplere erişim izni verir.
2. GitLab Private Repositories: GitHub’a benzer şekilde, GitLab da özel depolar sunar ve genellikle şirket içi kurulumlar için tercih edilir.
3. Bitbucket Private Repositories: Atlassian ekosisteminin bir parçası olarak, Bitbucket da özel depolar için güçlü seçenekler sunar.
4. Şirket İçi (Self-Hosted) Git Sunucuları: Gitea, Gogs veya GitLab Community Edition gibi çözümlerle şirket içinde kendi Git sunucunuzu barındırabilirsiniz. Bu, veri egemenliği ve özel ağ entegrasyonu için idealdir.

Bu platformlar, modüllerinize erişimi kontrol etmek için SSH anahtarları veya HTTPS tabanlı kişisel erişim belirteçleri (Personal Access Tokens – PATs) gibi farklı kimlik doğrulama yöntemleri sunar. Go’nun bu modüllere erişebilmesi için doğru kimlik doğrulama mekanizmasının yapılandırılması hayati önem taşır.

Kimlik Doğrulama Mekanizmaları

Go’nun özel modüllere erişebilmesi için, temel alınan Git aracı aracılığıyla kimlik doğrulaması yapması gerekir. Bu genellikle iki ana yöntemle gerçekleştirilir: SSH veya HTTPS.

SSH ile Kimlik Doğrulama

SSH (Secure Shell) anahtarları, sunuculara veya Git depolarına güvenli bir şekilde bağlanmak için yaygın olarak kullanılan bir yöntemdir. Eğer Git depolarınıza zaten SSH ile erişiyorsanız, Go modüllerini kullanırken de bu yöntemi tercih edebilirsiniz.

1. SSH Anahtarlarının Yapılandırılması:
* Bir SSH anahtar çiftiniz (genellikle ~/.ssh/id_rsa ve ~/.ssh/id_rsa.pub) olmalıdır.
* Genel anahtarınızı (id_rsa.pub) Git barındırma hizmetinize (GitHub, GitLab vb.) eklemiş olmalısınız.
* SSH aracısı (ssh-agent) çalışıyor olmalı ve özel anahtarınızı yüklemiş olmalıdır (ssh-add ~/.ssh/id_rsa).

2. Go’nun SSH Kullanımını Sağlama:
Go, varsayılan olarak git komutunu kullanarak depoları klonlamaya çalışır. Eğer modül yolunuz SSH protokolünü kullanacak şekilde yapılandırılmışsa (örneğin, git@github.com:myuser/mymodule.git), Go otomatik olarak SSH’i kullanır. Ancak, Go modül yolları genellikle HTTPS formatındadır (örneğin, github.com/myuser/mymodule). Bu durumda, Git’in belirli bir ana bilgisayar için SSH kullanmasını sağlamak için ~/.gitconfig dosyasını yapılandırmanız gerekir:

# ~/.gitconfig
    [url "git@github.com:"]
        insteadOf = https://github.com/

Bu yapılandırma, https://github.com/ ile başlayan tüm URL’leri git@github.com: ile değiştirecek ve böylece Git, GitHub’a SSH üzerinden bağlanmaya çalışacaktır. Benzer şekilde, GitLab veya diğer Git hizmetleri için de aynı yapılandırmayı uygulayabilirsiniz.

Avantajları:
* Tek bir anahtar çifti ile birden fazla depoya erişim.
* PAT’lere göre genellikle daha güvenli kabul edilir (anahtarın özel kısmı asla ağ üzerinden gönderilmez).
* CI/CD ortamlarında sır yönetimi daha kolay olabilir (SSH anahtarı bir sır olarak eklenebilir).

Dezavantajları:
* Windows ortamında yapılandırması bazen zorlayıcı olabilir.
* Bazı ortamlarda (örneğin, Docker kapsayıcıları) ssh-agent yönetimi ek adımlar gerektirebilir.

HTTPS ile Kimlik Doğrulama

HTTPS ile kimlik doğrulama, genellikle kullanıcı adı/şifre veya kişisel erişim belirteçleri (Personal Access Tokens – PATs) kullanılarak yapılır. Git, bu kimlik bilgilerini çeşitli yollarla alabilir. Go bağlamında, PAT’ler en yaygın ve güvenli yöntemdir.

1. Kişisel Erişim Belirteçleri (PATs):
* PAT’ler, şifreniz yerine kullanılabilecek uzun, rastgele dizelerdir.
* Her Git hizmeti (GitHub, GitLab, Bitbucket) kendi arayüzünden PAT oluşturma imkanı sunar.
* PAT oluştururken, modüllerinize erişim için gerekli en düşük izinleri (örneğin, “repo” veya “read_repository”) vermeye dikkat edin.
* PAT’ler genellikle bir son kullanma tarihine sahip olabilir ve belirli IP adresleriyle sınırlanabilir.

2. PAT’lerin Go Tarafından Kullanımı:
Go, HTTPS tabanlı modüllere erişirken kimlik doğrulaması yapmak için çeşitli yöntemler kullanabilir:

* Ortam Değişkenleri ile: En basit yöntemlerden biridir. PAT’i doğrudan URL’ye ekleyerek veya GIT_ASKPASS gibi ortam değişkenleri kullanarak kimlik doğrulaması yapabilirsiniz. Ancak URL’ye eklemek güvenlik açısından önerilmez.

# Örneğin, GitHub için
        export GITHUB_TOKEN="ghp_YOUR_PAT_HERE"
        # Git'i bu token'ı kullanmaya zorlamak için ~/.gitconfig'i yapılandırın
        # Bu, Go'nun dolaylı olarak token'ı kullanmasını sağlar.

* ~/.netrc Dosyası: Unix benzeri sistemlerde, ~/.netrc dosyası, otomatik FTP veya HTTP kimlik doğrulaması için kimlik bilgilerini depolamak için kullanılır. Git de bu dosyayı kullanabilir.

# ~/.netrc
        machine github.com
            login 
            password 

~/.netrc dosyasının izinlerinin 600 (sadece sahip okuyabilir/yazabilir) olarak ayarlandığından emin olun: chmod 600 ~/.netrc.

* Git Credential Helper: Git, kimlik bilgilerini güvenli bir şekilde depolamak için kimlik bilgisi yardımcıları (credential helpers) kullanabilir. Örneğin, git config --global credential.helper store (kimlik bilgilerini düz metin olarak depolar, önerilmez) veya git config --global credential.helper cache (kimlik bilgilerini belirli bir süre için önbelleğe alır) veya platforma özgü yardımcılar (örneğin, macOS için osxkeychain, Windows için wincred). Bu yardımcılar, bir kez kimlik doğrulaması yaptıktan sonra PAT’i tekrar tekrar girmenizi engeller.

Avantajları:
* Kurulumu genellikle SSH’den daha basittir.
* Güvenlik duvarı kısıtlamaları olan ortamlarda SSH’den daha iyi çalışabilir.
* CI/CD ortamlarında sır yönetimi kolaydır.

Dezavantajları:
* PAT’ler sızdırılırsa kötüye kullanılabilir.
* Belirli bir depoya veya kuruluşa özgü olabilirler.

Ortam Değişkenlerinin Yapılandırılması (Vazgeçilmez Adım)

Go’nun özel modüllerle doğru şekilde çalışabilmesi için birkaç kritik ortam değişkeninin ayarlanması gerekir. Bu değişkenler, Go’ya hangi modüllerin özel olduğunu, Go modül proxy’sini ne zaman atlaması gerektiğini ve checksum veritabanını ne zaman kullanmaması gerektiğini söyler.

1. GOPRIVATE:
* Amaç: Go’ya, hangi modül yollarının özel olduğunu ve dolayısıyla internet üzerinden erişilemediğini bildirir. Go, bu yolları içeren modülleri Go modül proxy’si aracılığıyla indirmeye çalışmaz.
Değer: Virgülle ayrılmış bir modül yolu listesidir. Joker karakterler () kullanılabilir.
* Örnek:

export GOPRIVATE="github.com/myorg/,internal.mycompany.com/"

Bu örnek, github.com/myorg/ ile başlayan tüm modüllerin ve internal.mycompany.com/ ile başlayan tüm modüllerin özel olduğunu belirtir.

2. GONOPROXY:
* Amaç: Go’ya, GOPRIVATE içinde listelenen modüller için Go modül proxy’sini kullanmamasını söyler. Bu, Go’nun doğrudan Git deposundan indirme yapmasını sağlar.
* Değer: GOPRIVATE ile aynı değerleri alabilir. Genellikle GOPRIVATE ile aynı şekilde ayarlanır.
* Örnek:

export GONOPROXY="github.com/myorg/,internal.mycompany.com/"

Go 1.13’ten itibaren, GONOPROXY açıkça ayarlanmazsa, GOPRIVATE‘ın değeri varsayılan olarak GONOPROXY için kullanılır. Ancak, açıkça ayarlamak iyi bir uygulamadır.

3. GONOSUMDB:
* Amaç: Go’ya, GOPRIVATE içinde listelenen modüller için Go checksum veritabanı (sum.golang.org) hizmetini kullanmamasını söyler. Özel modüllerin checksum’ları genellikle kamuya açık değildir ve bu hizmete gönderilmemelidir.
* Değer: GOPRIVATE ile aynı değerleri alabilir. Genellikle GOPRIVATE ile aynı şekilde ayarlanır.
* Örnek:

export GONOSUMDB="github.com/myorg/,internal.mycompany.com/"

Go 1.13’ten itibaren, GONOSUMDB açıkça ayarlanmazsa, GOPRIVATE‘ın değeri varsayılan olarak GONOSUMDB için kullanılır. Ancak, açıkça ayarlamak iyi bir uygulamadır.

Neden Üçü Birlikte Kullanılmalı?

Bu üç ortam değişkeni, özel modüllerle çalışırken bir bütün olarak işlev görür:

* GOPRIVATE: Go’ya hangi modüllerin özel olduğunu bildirir.
* GONOPROXY: Go’nun özel modüller için proxy’yi atlamasını sağlar, böylece doğrudan kaynak kontrol sisteminden (Git) indirme yapabilir.
* GONOSUMDB: Go’nun özel modüller için checksum veritabanını atlamasını sağlar, bu da güvenlik ve gizlilik sağlar.

Bu değişkenleri doğru bir şekilde ayarlamak, “module not found” veya “authentication required” gibi yaygın hataları önlemek için kritik öneme sahiptir. Bu ayarları, genellikle kullanıcının .bashrc, .zshrc veya sistem genelindeki bir yapılandırma dosyasında kalıcı hale getirmek en iyisidir.

Go env Komutu ile Ayarlama:

Go 1.15 ve sonrası sürümlerde, go env -w komutunu kullanarak bu ayarları kalıcı olarak yapabilirsiniz. Bu ayarlar, Go’nun kendi yapılandırma dosyasında saklanır ve kabuk ortam değişkenlerinden bağımsız olarak çalışır.

go env -w GOPRIVATE="github.com/myorg/,internal.mycompany.com/"
go env -w GONOPROXY="github.com/myorg/,internal.mycompany.com/"
go env -w GONOSUMDB="github.com/myorg/,internal.mycompany.com/"

Bu komutlar, kullanıcının ev dizinindeki Go yapılandırma dosyasında (örneğin, ~/.config/go/env veya ~/Library/Application Support/go/env macOS’ta) ayarları kalıcı hale getirir.

Gerçek Dünya Senaryoları ve Pratik Uygulamalar

Şimdi bu teorik bilgileri pratik senaryolara uygulayalım.

GitHub ile Özel Modül Kullanımı

Farz edelim ki github.com/myorg/my-private-lib adında özel bir Go modülünüz var ve bunu github.com/myorg/my-app projenizde kullanmak istiyorsunuz.

1. GitHub Kişisel Erişim Belirteci (PAT) Oluşturma:
* GitHub hesabınıza giriş yapın.
* Ayarlar -> Geliştirici ayarları -> Kişisel erişim belirteçleri -> Belirteçler (klasik) -> Yeni belirteç oluştur’a gidin.
* Belirtecinize açıklayıcı bir ad verin (örneğin, “go-mod-access”).
* repo kapsamını (veya daha spesifik olarak repo:status, repo_deployment, public_repo, repo:invite gibi alt kapsamları) seçin. Sadece okuma erişimi için read:packages veya repo yeterli olabilir.
* Belirteci oluşturun ve gördüğünüz PAT’i kopyalayın. Bu belirteci bir daha göremeyeceksiniz, bu yüzden güvenli bir yere kaydedin.

2. Ortam Değişkenlerini Ayarlama:

export GOPRIVATE="github.com/myorg/*"
    export GONOPROXY="github.com/myorg/*" # Go 1.13+ için GOPRIVATE ile aynı varsayılan
    export GONOSUMDB="github.com/myorg/*" # Go 1.13+ için GOPRIVATE ile aynı varsayılan

Bu ayarları kalıcı hale getirmek için ~/.bashrc veya go env -w kullanın.

3. Kimlik Doğrulama (HTTPS/PAT ile):
* ~/.netrc ile:

# ~/.netrc
        machine github.com
            login 
            password 

chmod 600 ~/.netrc komutunu unutmayın.
* Git Credential Helper ile:

git config --global credential.helper store # İlk kez kimlik bilgilerinizi girmenizi ister, sonra depolar.
        # veya
        git config --global credential.helper osxkeychain # macOS için
        # veya
        git config --global credential.helper wincred # Windows için

Ardından, bir kez git clone https://github.com/myorg/my-private-lib.git komutunu çalıştırın ve PAT’inizi girdiğinizde, kimlik bilgisi yardımcısı bunu kaydedecektir.

4. Projeye Dahil Etme:
my-app projenizin kök dizininde:

cd my-app
    go get github.com/myorg/my-private-lib@latest # veya belirli bir versiyon

Bu komut, my-private-lib modülünü indirecek ve go.mod dosyanıza ekleyecektir. Artık kodunuzda import "github.com/myorg/my-private-lib" yapabilirsiniz.

GitLab ile Özel Modül Kullanımı

GitLab için süreç GitHub’a çok benzer.

1. GitLab PAT veya Deploy Token Oluşturma:
* PAT: Kullanıcı Ayarları -> Erişim Belirteçleri bölümünden oluşturulur. read_repository veya api kapsamı gerekebilir.
* Deploy Token: Proje Ayarları -> Depo -> Dağıtım Belirteçleri bölümünden oluşturulur. Bu, projeniz için özel bir belirteçtir ve belirli bir depoya erişim sağlar.

2. Ortam Değişkenlerini Ayarlama:

export GOPRIVATE="gitlab.com/myorg/*"
    export GONOPROXY="gitlab.com/myorg/*"
    export GONOSUMDB="gitlab.com/myorg/*"

3. Kimlik Doğrulama:
* ~/.netrc ile:

# ~/.netrc
        machine gitlab.com
            login  # Veya deploy token adı
            password  # Veya deploy token değeri

* SSH ile (eğer tercih ediyorsanız): ~/.gitconfig dosyasında URL yeniden yazma kuralını ayarlayın:

# ~/.gitconfig
        [url "git@gitlab.com:"]
            insteadOf = https://gitlab.com/

4. Projeye Dahil Etme:

go get gitlab.com/myorg/my-private-lib@latest

Şirket İçi (Self-Hosted) Git Sunucuları

Şirket içi sunucular için süreç, barındırma platformuna göre değişebilir, ancak temel prensipler aynıdır.

1. Modül Yolu: Şirket içi sunucular için genellikle özel bir alan adı kullanılır (örneğin, internal.mycompany.com/go/mymodule). Go’nun bu yolu tanıması için .gitconfig dosyasında bir insteadOf kuralı veya go get komutunda tam URL kullanımı gerekebilir.

2. Ortam Değişkenleri:

export GOPRIVATE="internal.mycompany.com/*"
    export GONOPROXY="internal.mycompany.com/*"
    export GONOSUMDB="internal.mycompany.com/*"

3. Kimlik Doğrulama:
* SSH: En yaygın yöntemdir. SSH anahtarınızı sunucuya ekleyin ve ~/.gitconfig dosyasında insteadOf kuralını kullanın:

# ~/.gitconfig
        [url "ssh://git@internal.mycompany.com:port/"] # Veya sadece git@internal.mycompany.com:
            insteadOf = https://internal.mycompany.com/

* HTTPS/PAT: Eğer şirket içi Git sunucunuz PAT’leri destekliyorsa, ~/.netrc dosyasını veya Git kimlik bilgisi yardımcılarını kullanabilirsiniz.

4. Projeye Dahil Etme:

go get internal.mycompany.com/go/mymodule@latest

Go Modüllerini Bir Projeye Dahil Etme

Özel modülünüzü projenize dahil etmek için temel Go komutlarını kullanırsınız:

1. go get Komutu:

go get @

Örneğin: go get github.com/myorg/my-private-lib@v1.0.0
@latest kullanarak en son kararlı sürümü çekebilirsiniz. Bu komut, modülü indirir, önbelleğe alır ve go.mod dosyanızdaki require bölümüne ekler.

2. go mod tidy Komutu:
go mod tidy komutu, go.mod dosyanızı güncelleyerek gereksiz bağımlılıkları kaldırır ve eksik olanları ekler. go get sonrası veya kodunuzda import yollarını değiştirdikten sonra çalıştırmak iyi bir alışkanlıktır.

3. replace Direktifi:
go.mod dosyasındaki replace direktifi, bir modülün başka bir modülle değiştirilmesini sağlar. Bu, özellikle geliştirme sırasında yerel bir kopyayı test etmek veya bir modülün çatalını kullanmak istediğinizde çok kullanışlıdır.

// go.mod dosyanızda
    module github.com/myorg/my-app

    go 1.20

    require (
        github.com/myorg/my-private-lib v1.0.0
    )

    replace github.com/myorg/my-private-lib v1.0.0 => ../my-private-lib // Yerel yol
    // veya
    // replace github.com/myorg/my-private-lib v1.0.0 => github.com/myfork/my-private-lib v1.0.0 // Çatal

replace direktifi, Go’nun modülü belirtilen yoldan (yerel dizin veya farklı bir uzak depo) almasını sağlar. Üretime dağıtım yaparken bu replace direktifini kaldırmanız veya doğru uzak depoya işaret ettiğinden emin olmanız gerekir.

CI/CD Ortamlarında Özel Modüllerin Yönetimi

Sürekli Entegrasyon/Sürekli Dağıtım (CI/CD) boru hatlarında özel Go modüllerini kullanmak, yerel geliştirme ortamınızdan biraz farklı bir yaklaşım gerektirir. Temel zorluk, kimlik bilgilerini (SSH anahtarları veya PAT’ler) güvenli bir şekilde sağlamak ve ortam değişkenlerini doğru bir şekilde ayarlamaktır.

1. Sır Yönetimi (Secret Management):
* PAT’ler: Çoğu CI/CD sistemi (GitHub Actions, GitLab CI, Jenkins, CircleCI vb.), sırları (secrets) güvenli bir şekilde saklama ve boru hattı adımlarına ortam değişkenleri olarak enjekte etme yeteneğine sahiptir. PAT’inizi bu sır yöneticilerine ekleyin.

# GitHub Actions örneği
        env:
          GOPRIVATE: "github.com/myorg/*"
          GONOPROXY: "github.com/myorg/*"
          GONOSUMDB: "github.com/myorg/*"
          GIT_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }} # GitHub'ın yerleşik PAT'i veya kendi oluşturduğunuz
        run: |
          git config --global url."https://oauth2:${GIT_AUTH_TOKEN}@github.com".insteadOf "https://github.com"
          go mod tidy
          go build ./...

* SSH Anahtarları: Özel SSH anahtarınızı CI/CD sisteminin sır yöneticisine ekleyin. Ardından, boru hattınızda bir ssh-agent başlatın ve anahtarı ekleyin.

# GitLab CI örneği
        before_script:
          - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
          - eval $(ssh-agent -s)
          - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
          - mkdir -p ~/.ssh
          - chmod 700 ~/.ssh
          - ssh-keyscan github.com >> ~/.ssh/known_hosts
          - chmod 644 ~/.ssh/known_hosts
          - git config --global url."git@github.com:".insteadOf "https://github.com/"
          - export GOPRIVATE="github.com/myorg/*"
          - export GONOPROXY="github.com/myorg/*"
          - export GONOSUMDB="github.com/myorg/*"
        script:
          - go mod tidy
          - go build ./...

Burada SSH_PRIVATE_KEY bir CI/CD sırrı olarak saklanan özel SSH anahtarınızdır.

2. Kapsayıcı Tabanlı Ortamlar (Docker):
Docker konteynerleri içinde Go uygulamaları geliştiriyorsanız, Dockerfile içinde veya derleme sırasında bu ortam değişkenlerini ve kimlik bilgilerini sağlamanız gerekir.
* Dockerfile içinde ARG ve ENV komutlarını kullanabilirsiniz. PAT’leri doğrudan Dockerfile içine yazmaktan kaçının; derleme argümanları (--build-arg) veya CI/CD sırları aracılığıyla geçirin.
* Çok aşamalı derlemeler (multi-stage builds) kullanarak nihai imajda kimlik bilgilerinin kalmamasını sağlayın.

# Dockerfile örneği
    FROM golang:1.20 AS builder

    ARG GITHUB_TOKEN # Build arg olarak token al
    ENV GOPRIVATE="github.com/myorg/*"
    ENV GONOPROXY="github.com/myorg/*"
    ENV GONOSUMDB="github.com/myorg/*"

    WORKDIR /app

    # Git'e kimlik doğrulaması için PAT'ı kullan
    RUN git config --global url."https://oauth2:${GITHUB_TOKEN}@github.com".insteadOf "https://github.com"

    COPY go.mod go.sum ./
    RUN go mod download

    COPY . .
    RUN go build -o myapp .

    FROM alpine:latest
    WORKDIR /root/
    COPY --from=builder /app/myapp .
    CMD ["./myapp"]

Bu Dockerfile’ı docker build --build-arg GITHUB_TOKEN=$MY_PAT -t myapp . komutuyla derleyebilirsiniz.

Sık Karşılaşılan Sorunlar ve Çözümleri

Özel Go modülleriyle çalışırken karşılaşabileceğiniz bazı yaygın sorunlar ve çözümleri:

1. “go: module not found” veya “authentication required” hataları:
* Çözüm: GOPRIVATE, GONOPROXY, GONOSUMDB ortam değişkenlerinin doğru ayarlandığından emin olun. Modül yolunun joker karakterlerle bile eşleştiğini kontrol edin.
* Kimlik doğrulama bilgilerinizin (SSH anahtarları veya PAT’ler) doğru ve erişilebilir olduğundan emin olun. git clone komutunu manuel olarak çalıştırarak Git’in kimlik doğrulaması yapıp yapamadığını test edin.
* ~/.netrc dosyasının izinlerinin 600 olduğundan emin olun.
* SSH kullanıyorsanız, ssh-agent‘ın çalıştığından ve anahtarınızın yüklü olduğundan emin olun (ssh-add -l).

2. “proxy: unrecognized scheme” veya “malformed module path” hataları:
* Çözüm: Genellikle GOPRIVATE veya GONOPROXY ayarlarının yanlış olduğunu gösterir. Go, özel modülü hala bir proxy aracılığıyla indirmeye çalışıyor olabilir. Ortam değişkenlerini tekrar kontrol edin.

3. “checksum mismatch” veya “go.sum: verify: checksum mismatch” hataları:
* Çözüm: GONOSUMDB ortam değişkeninin doğru ayarlandığından emin olun. Özel modüllerin checksum’ları genel veritabanında bulunmayacağı için bu hatayı alırsınız.
* Eğer modülün içeriği gerçekten değiştiyse, go mod tidy veya go get -u komutlarını kullanarak go.sum dosyasını güncelleyebilirsiniz.

4. Önbellek sorunları:
* Çözüm: Go modül önbelleğini temizlemek için go clean -modcache komutunu kullanın. Bu, Go’yu tüm modülleri yeniden indirmeye zorlar.

5. Git URL’si ile Go modül yolu uyuşmazlığı:
* Çözüm: Go modül yolu, genellikle Git deposunun HTTPS URL’sine benzer (örneğin, github.com/user/repo). Eğer SSH kullanıyorsanız, ~/.gitconfig dosyasındaki insteadOf kuralının doğru yapılandırıldığından emin olun. Go, modül yolunu kullanarak depoyu bulmaya çalışır.

Gelişmiş Konular (Kısa Bahsetme)

* Go Module Proxy (GOPROXY) ve Özel Proxy’ler: Büyük kuruluşlar, kendi özel Go modül proxy’lerini çalıştırabilirler. Bu proxy’ler, hem açık kaynaklı hem de özel modülleri önbelleğe alarak bağımlılık yönetimini merkezileştirir ve hızlandırır. Bu durumda, GOPROXY ortam değişkeni, bu özel proxy’ye işaret edecek şekilde ayarlanır ve proxy, özel modüller için kimlik doğrulamasını kendisi yönetir.
* Vendoring: Go modülleri, go mod vendor komutuyla bağımlılıkları projenin vendor dizinine kopyalama imkanı sunar. Bu, özellikle bağımlılıkların tamamen izole edilmesi gereken veya internet erişiminin kısıtlı olduğu ortamlarda kullanışlıdır. Ancak, modern Go modül yönetimiyle genellikle daha az ihtiyaç duyulur.

Sonuç

Özel Go modüllerini kendi projelerinizde kullanmak, başlangıçta biraz yapılandırma gerektirse de, Go’nun güçlü bağımlılık yönetimi özellikleri sayesinde oldukça yönetilebilir bir süreçtir. Doğru kimlik doğrulama yöntemini seçmek (SSH veya HTTPS/PAT), GOPRIVATE, GONOPROXY ve GONOSUMDB ortam değişkenlerini eksiksiz ve doğru bir şekilde yapılandırmak bu sürecin temel taşlarıdır.

Bu adımları takip ederek, fikri mülkiyetinizi koruyabilir, şirket içi kod paylaşımını kolaylaştırabilir ve geliştirme süreçlerinizi daha verimli hale getirebilirsiniz. CI/CD ortamlarında sır yönetimine dikkat etmek ve Docker gibi kapsayıcı teknolojilerle entegrasyonu doğru yapmak, projelerinizin güvenli ve ölçeklenebilir kalmasını sağlayacaktır. Unutmayın, iyi yapılandırılmış bir bağımlılık yönetimi, her Go projesinin başarısı için hayati öneme sahiptir.