Go Geliştiricisinin Araç Kutusu — Temel Araçlar ve Kütüphaneler

22 Ağustos 2026 · netologist · 16 dakika, 3331 kelime · #cli #devtools #go #golang #libraries #note #tooling

Go ekosisteminde en yaygın kullanılan komut satırı araçları ve kütüphaneler hakkında kapsamlı, görüş içeren bir rehber — ne oldukları, neden var oldukları, nasıl kurulup gerçek bir projede nasıl kullanıldıkları.

İçindekiler

Bu rehber nasıl okunur
Bölüm 1 — CLI / Geliştirme Araçları
Bölüm 2 — Kütüphaneler
Proje tipine göre önerilen “başlangıç kiti”

Bu rehber nasıl okunur

Her madde aynı yapıyı takip eder:

Nedir — tek cümlelik amaç
Neden popüler — çözdüğü problem
Kurulum — go install veya go get komutu
Kullanım — gerçekçi bir kod parçası veya CLI çağrısı
Notlar — tuzaklar, alternatifler, ne zaman kullanılmamalı

Aşağıdaki CLI araçlarının çoğu proje bağımlılığı olarak değil, geliştirme (dev) aracı olarak kurulmalıdır. Modern ve idiomatik yaklaşım (Go 1.24+), araç sürümlerini geliştiricinin $GOPATH/bin dizinindeki her neyse ona güvenmek yerine repo başına sabitleyen özel bir tools.go/tools dizini, ya da daha da iyisi go.mod tool direktifidir (go get -tool).

# Modern (Go 1.24+) yöntemle bir dev aracını modül bazında sabitleme
go get -tool github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go tool golangci-lint run

Bölüm 1 — CLI / Geliştirme Araçları

Derleme, Çalıştırma ve Canlı Yeniden Yükleme

`air` — Go uygulamaları için canlı yeniden yükleme

Repo: github.com/air-verse/air
Nedir: Kaynak dosyalar değiştiğinde Go binary’nizi otomatik olarak yeniden derleyip yeniden başlatan bir dosya izleyicisi — Go dünyasının nodemon‘u.
Neden popüler: Go hızlı derlenir ama backend/API geliştirirken her değişiklikten sonra go run‘ı elle tekrar çalıştırmak yorucudur. air bu geri bildirim döngüsünü kapatır.

Kurulum:

go install github.com/air-verse/air@latest

Kullanım:

air init          # .air.toml oluşturur
air               # izler, derler, yeniden başlatır

Minimal .air.toml:

[build]
cmd = "go build -o ./tmp/main ./cmd/api"
bin = "./tmp/main"
include_ext = ["go", "tpl", "tmpl", "html"]
exclude_dir = ["tmp", "vendor"]

Notlar: Alternatifler: wgo, reflex, CompileDaemon. air, Go web geliştirmede fiili standart olmaya devam ediyor.

`task` — Task runner / Makefile alternatifi

Repo: github.com/go-task/task/v3/cmd/task
Nedir: YAML tabanlı bir task runner (Taskfile.yml), make‘e göre daha basit ve platformlar arası bir alternatif olarak konumlanır.
Neden popüler: make sözdizimi (tab karakterleri, .PHONY, shell garaklıkları) kullanıcı dostu değildir ve Windows’a taşınabilir değildir. Task deklaratiftir; değişkenler, include’lar, bağımlılık grafikleri ve güncel task’ları atlamak için checksum desteği sunar.

Kurulum:

go install github.com/go-task/task/v3/cmd/task@latest

Kullanım:

# Taskfile.yml
version: '3'
tasks:
  build:
    cmds:
      - go build -o bin/app ./cmd/app
  test:
    cmds:
      - go test ./... -race -cover
  lint:
    cmds:
      - golangci-lint run ./...
  run:
    deps: [build]
    cmds:
      - ./bin/app

task build
task test

Notlar: Rakip araçlar: sıradan Makefile, mage (task’lar Go dilinde yazılır), just.

Kod Kalitesi: Linting, Formatlama ve Statik Analiz

`golangci-lint` — Linter toplayıcısı

Repo: github.com/golangci/golangci-lint/cmd/golangci-lint
Nedir: 50’den fazla ayrı linter’ı (govet, staticcheck, errcheck, unused, gosimple, revive vb.) önbellekleme ile paralel olarak çalıştıran bir meta-linter.
Neden popüler: CI pipeline’ları için standart araçtır — tek konfigürasyon dosyası, tek komut, hızlı ve linter başına yüksek derecede özelleştirilebilir.

Kurulum:

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

Kullanım:

golangci-lint run ./...
golangci-lint run --fix

.golangci.yml:

linters:
  enable:
    - govet
    - staticcheck
    - errcheck
    - gofmt
    - goimports
    - revive
    - gosec
issues:
  exclude-dirs:
    - vendor

Notlar: Neredeyse her ciddi Go repository’sinde bu, CI’a ve pre-commit hook’larına entegre edilmiştir.

`staticcheck` — Derinlemesine statik analiz

Repo: honnef.co/go/tools/cmd/staticcheck
Nedir: go vet‘in kaçırdığı hataları, performans sorunlarını ve stil problemlerini (örn. etkisiz atamalar, deprecated API kullanımı, gereksiz tip dönüşümleri) yakalayan gelişmiş bir statik analiz aracı.
Neden popüler: Mevcut linter’lar arasında en yüksek sinyal/gürültü oranına sahip olanlardan biri olarak kabul edilir; golangci-lint içinde varsayılan olarak bulunur ama bağımsız olarak da çalıştırılabilir.

Kurulum:

go install honnef.co/go/tools/cmd/staticcheck@latest

Kullanım:
```
staticcheck ./...
```

`goimports` — Formatlama + import yönetimi

Repo: golang.org/x/tools/cmd/goimports
Nedir: gofmt‘in bir üst kümesi; ayrıca import ifadelerini otomatik olarak ekler/kaldırır ve gruplar.
Neden popüler: Kimse import ( ... ) bloklarını elle yönetmek istemez; editörler (VS Code, GoLand) kaydetme sırasında bunu çalıştırır.

Kurulum:

go install golang.org/x/tools/cmd/goimports@latest

Kullanım:
```
goimports -w .
```
Notlar: gofumpt (mvdan.cc/gofumpt), gofmt‘in ötesinde ek formatlama kuralları uygulamak için birçok takımın tercih ettiği daha katı bir üst kümedir.

Test Araçları

`gotestsum` — İnsan dostu test çıktısı

Repo: gotest.tools/gotestsum
Nedir: go test etrafında, okunabilir, renkli özetler ve CI panoları için JUnit XML üreten bir wrapper.
Neden popüler: Büyük test paketlerinde ham go test -v çıktısı bir metin duvarıdır. gotestsum temiz bir başarılı/başarısız ağacı sunar ve CI test raporlayıcılarıyla (GitHub Actions, GitLab, Jenkins) entegre olur.

Kurulum:

go install gotest.tools/gotestsum@latest

Kullanım:

gotestsum --format testname ./...
gotestsum --junitfile unit-tests.xml -- ./... -race -cover

`ginkgo` / `gomega` (ekstra bilgi)

Nedir: BDD tarzı bir test framework’ü (Describe/It/Context) ve buna karşılık gelen bir matcher kütüphanesi (gomega).
Neden popüler: Kubernetes ekosistemindeki projelerde anlatımsal, spec tarzı testler için yoğun olarak kullanılır.

Kurulum:

go install github.com/onsi/ginkgo/v2/ginkgo@latest
go get github.com/onsi/gomega

Debugging ve Profiling

`delve` (`dlv`) — Go debugger’ı

Repo: github.com/go-delve/delve/cmd/dlv
Nedir: Özellikle Go için geliştirilmiş, goroutine’leri, kanalları ve Go runtime’ını anlayan (genel amaçlı gdb‘nin aksine) kaynak seviyesinde bir debugger.
Neden popüler: Her Go IDE’sinin (VS Code’un Go eklentisi, GoLand) arka planda kullandığı debugger’dır. Breakpoint ile debugging ve post-mortem analiz için vazgeçilmezdir.

Kurulum:

go install github.com/go-delve/delve/cmd/dlv@latest

Kullanım:

dlv debug ./cmd/api           # derle + debug et
dlv attach <pid>               # çalışan bir sürece bağlan
dlv test ./pkg/foo             # bir testi debug et

dlv REPL içinde:

(dlv) break main.go:42
(dlv) continue
(dlv) print myVar
(dlv) goroutines

Notlar: Production/uzaktan debugging için dlv --headless --listen=:2345, IDE’nizin bağlanabileceği bir debug sunucusu açar.

`pprof` — Profiling (standart kütüphanenin içinde)

Nedir: Ayrı bir kurulum değil — net/http/pprof ve go tool pprof, CPU, bellek, goroutine ve blok profiling için Go’nun kendisiyle birlikte gelir.

Kullanım:

import _ "net/http/pprof"
// sonra: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

go tool pprof -http=:8081 cpu.prof

Notlar: benchstat (golang.org/x/perf/cmd/benchstat), go test -bench sonuçlarını farklı çalıştırmalar arasında istatistiksel olarak karşılaştırır — bir performans optimizasyonunun gerçek olduğunu (gürültü olmadığını) doğrulamak için vazgeçilmezdir.

Veritabanı ve Migration Araçları

`goose` — Veritabanı migration’ları

Repo: github.com/pressly/goose/v3/cmd/goose
Nedir: Postgres, MySQL, SQLite ve daha fazlasını destekleyen, düz yukarı/aşağı SQL dosyaları kullanan bir SQL/Go tabanlı şema migration aracı.
Neden popüler: Basit, açık, ORM’e bağımlı değil; migration’lar sadece versiyonlanmış .sql dosyalarıdır (karmaşık veri migration’ları için Go fonksiyonları da olabilir).

Kurulum:

go install github.com/pressly/goose/v3/cmd/goose@latest

Kullanım:

goose create add_users_table sql
goose -dir ./migrations postgres "$DATABASE_URL" up
goose -dir ./migrations postgres "$DATABASE_URL" status

Notlar: Ana rakibi, daha geniş bir veritabanı sürücü setine sahip olan ve sadece CLI değil kütüphane olarak da kullanılabilen golang-migrate/migrate‘tir.

`sqlc` — SQL’den tip güvenli Go kodu üretme

Repo: github.com/sqlc-dev/sqlc/cmd/sqlc
Nedir: .sql şemanızı ve sorgularınızı okuyup tamamen tipli Go struct’ları ve sorgu fonksiyonları üretir — ORM yok, reflection yok, runtime büyüsü yok.
Neden popüler: Sıfır soyutlama maliyetiyle ham SQL üzerinde derleme zamanı güvenliği sağlar — SQL-öncelikli iş akışlarını tercih eden takımlar arasında bir gorm alternatifi olarak son derece popülerdir.

Kurulum:

go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest

Kullanım: sqlc.yaml:

version: "2"
sql:
  - engine: "postgresql"
    queries: "queries.sql"
    schema: "schema.sql"
    gen:
      go:
        package: "db"
        out: "internal/db"

sqlc generate

-- name: GetUserByID :one
SELECT * FROM users WHERE id = $1;

bu, func (q *Queries) GetUserByID(ctx context.Context, id int64) (User, error) şeklinde bir Go fonksiyonu üretir.

Kod Üretimi (API, GraphQL, SQL, Mock)

`oapi-codegen` — OpenAPI → Go

Repo: github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen
Nedir: Bir OpenAPI (Swagger) 3.0 spesifikasyonundan doğrudan Go sunucu iskeletleri, istemci SDK’ları ve tip tanımları üretir.
Neden popüler: API sözleşmenizi ve Go tiplerinizi senkronize tutar; chi, echo, gin, net/http ve strict-server modlarını destekler.

Kurulum:

go install github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen@latest

Kullanım:

oapi-codegen -generate types,chi-server -package api openapi.yaml > api/server.gen.go

Notlar: Ters yön için (Go → OpenAPI), swaggo/swag kod içi açıklamalardan (annotation) dokümantasyon üretir.

`gqlgen` — GraphQL sunucu üretici

Repo: github.com/99designs/gqlgen
Nedir: Şema-öncelikli bir GraphQL sunucu üretici: bir .graphql SDL şeması yazarsınız, o da resolver’ları, modelleri ve çalıştırılabilir şemayı üretir.
Neden popüler: Go’daki en olgun, aktif olarak geliştirilen ve tip-güvenli GraphQL kütüphanesi — eski kütüphanelerin reflection ağırlıklı, daha az tipli yaklaşımından kaçınır.

Kurulum:

go install github.com/99designs/gqlgen@latest

Kullanım:
```
go run github.com/99designs/gqlgen init
go run github.com/99designs/gqlgen generate
```
Ardından üretilen Resolver arayüzünü kendi iş mantığınızla uygularsınız.

`buf` — Protobuf araçları

Repo: github.com/bufbuild/buf/cmd/buf
Nedir: Ham protoc CLI’sinin modern bir yerine geçeni: linting, breaking-change (kırıcı değişiklik) tespiti, bağımlılık yönetimi (BSR — Buf Schema Registry) ve .proto dosyaları için daha hızlı kod üretimi.
Neden popüler: Tek başına protoc‘un bağımlılık/import yönetimi sıkıntılıdır; buf bunu buf.yaml/buf.gen.yaml iş akışıyla çözer ve artık gRPC ağırlıklı Go firmalarında standarttır.

Kurulum:

go install github.com/bufbuild/buf/cmd/buf@latest

Kullanım:

buf lint
buf breaking --against '.git#branch=main'
buf generate

`mockery` — Interface’ler için mock üretimi

Repo: github.com/vektra/mockery/v2
Nedir: Go interface’lerinizi tarar ve testify uyumlu mock implementasyonlarını otomatik olarak üretir.
Neden popüler: Mock’ları elle yazmak yorucu ve hataya açıktır; mockery bir konfigürasyon dosyası veya go generate direktifleri aracılığıyla mock’ları interface değişiklikleriyle otomatik olarak senkronize tutar.

Kurulum:

go install github.com/vektra/mockery/v2@latest

Kullanım:

# .mockery.yaml
with-expecter: true
packages:
  myapp/internal/repo:
    interfaces:
      UserRepository:

mockery

//go:generate mockery --name=UserRepository

Notlar: Standart kütüphaneye en yakın alternatif, artık kullanımdan kaldırılan (deprecated) golang/mock‘un ardılı olan go.uber.org/mock‘tur.

Task Runner’lar ve Git Hook’ları

`lefthook` — Hızlı Git hook yöneticisi

Repo: github.com/evilmartians/lefthook/v2
Nedir: Git hook’larını (pre-commit, pre-push, commit-msg) basit bir YAML konfigürasyonu ile yöneten, kontrolleri paralel çalıştıran tek ve hızlı bir binary (Go ile yazılmış).
Neden popüler: Dilden bağımsızdır, shell script tabanlı hook yöneticilerinden veya Husky’den (Node tabanlı) çok daha hızlıdır ve herhangi bir repoya (Go, JS, Python, monorepo) eklemesi çok kolaydır.

Kurulum:

go install github.com/evilmartians/lefthook/v2@latest

Kullanım: lefthook.yml:

pre-commit:
  parallel: true
  commands:
    lint:
      glob: "*.go"
      run: golangci-lint run {staged_files}
    format:
      glob: "*.go"
      run: gofmt -l {staged_files}

lefthook install

Güvenlik ve Zafiyet Taraması

`govulncheck` — Resmi Go zafiyet tarayıcısı

Repo: golang.org/x/vuln/cmd/govulncheck
Nedir: Go ekibinin kendi geliştirdiği, bağımlılık grafiğinizi (ve sadece import’ları değil, çağrı grafiğinizi de) Go zafiyet veritabanıyla karşılaştıran bir araç.
Neden popüler: Sadece zafiyetli bir paketin import edilip edilmediğini değil, zafiyetli kod yollarının gerçekten erişilebilir olup olmadığını kontrol ettiği için düşük yanlış pozitif oranına sahiptir. CI/CD ve SOC2/tedarik zinciri denetimlerinde giderek daha fazla zorunlu hale gelmektedir.

Kurulum:

go install golang.org/x/vuln/cmd/govulncheck@latest

Kullanım:
```
govulncheck ./...
```
Notlar: gosec (github.com/securego/gosec), bilinen CVE’ler yerine güvensiz kodlama kalıplarını (SQL injection, sabit kodlanmış kimlik bilgileri, zayıf kriptografi) tarayarak onu tamamlar.

Release ve Paketleme

`goreleaser` — Otomatik release pipeline’ı

Repo: github.com/goreleaser/goreleaser
Nedir: Platformlar arası binary’ler oluşturur, changelog üretir, GitHub/GitLab release’leri oluşturur, Docker imajları derler ve paket yöneticilerine (Homebrew, Scoop, apt) tek bir YAML konfigürasyonundan yayınlar.
Neden popüler: Go CLI’ları göndermek için fiili standarttır; neredeyse her popüler açık kaynak Go CLI aracı (k9s, hugo, gh) bunu kullanır.

Kurulum:

go install github.com/goreleaser/goreleaser/v2@latest

Kullanım:

goreleaser init
goreleaser release --clean
goreleaser release --snapshot --clean   # yerel deneme çalıştırması

Bölüm 2 — Kütüphaneler

Validasyon (Doğrulama)

`go-playground/validator`

Repo: github.com/go-playground/validator
Nedir: Go’da en yaygın kullanılan struct-tag tabanlı validasyon kütüphanesi.
Neden popüler: Struct tag’leri (validate:"required,email") aracılığıyla deklaratif validasyon sağlar, request body validasyonu için gin ve echo ile derinlemesine entegredir, özel validatörleri ve alanlar arası kuralları destekler.

Kurulum:

go get github.com/go-playground/validator/v10

Kullanım:

type CreateUserRequest struct {
    Name  string `validate:"required,min=2,max=50"`
    Email string `validate:"required,email"`
    Age   int    `validate:"gte=0,lte=130"`
}

validate := validator.New()
if err := validate.Struct(req); err != nil {
    for _, e := range err.(validator.ValidationErrors) {
        fmt.Println(e.Field(), e.Tag())
    }
}

Test ve Assertion

`stretchr/testify`

Repo: github.com/stretchr/testify
Nedir: Go’nun yerleşik testing paketi için en çok kullanılan assertion/mocking araç seti: assert, require, mock ve suite.
Neden popüler: Sıradan if got != want { t.Errorf(...) } kalıp kodu uzundur; testify okunabilir tek satırlık ifadeler ve zengin diff çıktısı sunar. testify/mock, mockery tarafından üretilen mock’ların hedeflediği interface’tir de aynı zamanda.
Kurulum:
```
go get github.com/stretchr/testify
```

Kullanım:

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    assert.Equal(t, 5, result, "eşit olmalılar")
    require.NoError(t, err) // hata durumunda testi hemen durdurur
}

type CalcSuite struct {
    suite.Suite
}
func (s *CalcSuite) TestAdd() {
    s.Equal(5, Add(2, 3))
}
func TestCalcSuite(t *testing.T) {
    suite.Run(t, new(CalcSuite))
}

HTTP Router’lar ve Web Framework’leri

`gin-gonic/gin`

Repo: github.com/gin-gonic/gin
Nedir: Go’daki en popüler, tam özellikli HTTP web framework’ü — routing, middleware, JSON binding/validasyon, render işlemleri.
Neden popüler: Son derece hızlıdır (radix ağacı router üzerine kurulu), devasa bir middleware ekosistemi vardır, yumuşak bir öğrenme eğrisi sunar ve herhangi bir Go web framework’ü arasında en çok GitHub yıldızına sahiptir.
Kurulum: go get github.com/gin-gonic/gin

Kullanım:

r := gin.Default()
r.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    c.JSON(200, gin.H{"id": id})
})
r.Run(":8080")

`labstack/echo`

Repo: github.com/labstack/echo/v4
Nedir: Minimalist, yüksek performanslı bir web framework’ü — Gin’in en yakın rakibi.
Neden popüler: Temiz bir API, birinci sınıf middleware desteği, HTTP/2, WebSocket’ler ve otomatik TLS için yerleşik destek.

Kullanım:

e := echo.New()
e.GET("/users/:id", func(c echo.Context) error {
    return c.JSON(200, map[string]string{"id": c.Param("id")})
})
e.Start(":8080")

`go-chi/chi`

Repo: github.com/go-chi/chi/v5
Nedir: net/http‘in http.Handler‘ıyla %100 uyumlu, hafif bir router — framework “büyüsü” yok, sadece birleştirilebilir (composable) middleware.
Neden popüler: Tam bir framework benimsemeden idiomatik, stdlib uyumlu kod isteyen takımlar tarafından tercih edilir; mikroservisler için çok popülerdir.

Kullanım:

r := chi.NewRouter()
r.Use(middleware.Logger)
r.Get("/users/{id}", getUserHandler)
http.ListenAndServe(":8080", r)

Notlar: Go 1.22’den itibaren net/http‘in kendi ServeMux‘ı metot bazlı routing ve wildcard desteği kazandı, bu da basit servislerde bir router kütüphanesine olan ihtiyacı azalttı — ama chi‘nin middleware ekosistemi hâlâ bir avantaj sağlıyor.

Konfigürasyon ve CLI

`spf13/cobra`

Repo: github.com/spf13/cobra
Nedir: Alt komutlar, bayraklar (flag) ve otomatik oluşturulan yardım metinleriyle CLI uygulamaları oluşturmak için kullanılan kütüphane — kubectl, hugo, gh, docker tarafından kullanılır.
Kurulum: go get github.com/spf13/cobra

Kullanım:

var rootCmd = &cobra.Command{Use: "app", Short: "Benim CLI'm"}
var greetCmd = &cobra.Command{
    Use:   "greet [name]",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("Merhaba,", args[0])
    },
}
func main() {
    rootCmd.AddCommand(greetCmd)
    rootCmd.Execute()
}

Notlar: spf13/cobra-cli, eşlik eden üretici (generator) aracıdır (cobra-cli init, cobra-cli add).

`spf13/viper`

Repo: github.com/spf13/viper
Nedir: JSON/YAML/TOML/ortam değişkenleri/flag’ler/uzak konfigürasyon (etcd/Consul) destekleyen, otomatik öncelik sırası ve canlı-yeniden-yükleme (live-reload) sunan konfigürasyon yönetim kütüphanesi.
Neden popüler: cobra ile doğal olarak eşleşir; “12-factor” tarzı konfigürasyon yüklemesi için varsayılan seçimdir.

Kullanım:

viper.SetConfigName("config")
viper.AddConfigPath(".")
viper.AutomaticEnv()
viper.ReadInConfig()
port := viper.GetInt("server.port")

Notlar: Birçok takımın basitlik için tercih ettiği daha hafif alternatifler: caarlos0/env (struct-tag tabanlı ortam değişkeni ayrıştırma) veya kelseyhightower/envconfig.

`joho/godotenv`

Repo: github.com/joho/godotenv
Nedir: .env dosyalarını ortam değişkenlerine yükler, Node’un dotenv‘ini yansıtır.

Kullanım:

godotenv.Load()
dbURL := os.Getenv("DATABASE_URL")

Loglama

`uber-go/zap`

Repo: go.uber.org/zap
Nedir: Neredeyse sıfır bellek tahsisi performansı için optimize edilmiş, yapılandırılmış, seviyeli (leveled) bir logger.
Neden popüler: Uber tarafından yüksek trafikli servisler için geliştirilmiştir; benchmark’lar onu Go’daki en hızlı yapılandırılmış logger’lardan biri olarak sürekli gösterir.

Kullanım:

logger, _ := zap.NewProduction()
defer logger.Sync()
logger.Info("kullanıcı oluşturuldu",
    zap.String("user_id", "123"),
    zap.Int("age", 30),
)

`rs/zerolog`

Repo: github.com/rs/zerolog
Nedir: Zincirlenebilir (chainable) bir API’ye sahip, sıfır tahsisli JSON yapılandırılmış logger.
Neden popüler: Karşılaştırılabilir performansı korurken daha basit, daha ergonomik API’si nedeniyle sıklıkla zap‘e tercih edilir.

Kullanım:

log.Info().Str("user_id", "123").Int("age", 30).Msg("kullanıcı oluşturuldu")

Notlar: Go 1.21’den itibaren standart kütüphanenin log/slog paketi, kutudan çıkar çıkmaz yapılandırılmış loglama sunar ve zap/zerolog‘un ekstra performansına ihtiyaç duymayan daha basit projelerde giderek daha fazla kullanılmaktadır.

Veritabanı Erişimi ve ORM

`jmoiron/sqlx`

Repo: github.com/jmoiron/sqlx
Nedir: database/sql üzerine struct scanning, isimlendirilmiş sorgular ve kullanışlı metotlar ekleyen ince bir uzantı — tam bir ORM’e dönüşmeden.
Neden popüler: Ham SQL kontrolü isteyen ama elle rows.Scan(&a, &b, &c) yazmaktan nefret eden takımlar için idealdir.

Kullanım:

var users []User
db.Select(&users, "SELECT * FROM users WHERE active = $1", true)

`go-gorm/gorm`

Repo: gorm.io/gorm
Nedir: Go’daki en popüler, tam özellikli ORM — ilişkiler (associations), migration’lar, hook’lar, transaction’lar, eager loading.
Neden popüler: SQL yazmadan CRUD ve ilişkileri çalışır hale getirmenin en hızlı yoludur; büyük bir eklenti ekosistemine sahiptir (soft delete, sharding, tracing).

Kullanım:

type User struct {
    gorm.Model
    Name string
    Age  int
}
db.AutoMigrate(&User{})
db.Create(&User{Name: "Alice", Age: 30})
var users []User
db.Where("age > ?", 18).Find(&users)

Notlar: Birçok takım, performans-kritik veya SQL-öncelikli kod tabanları için gorm yerine sqlc + sqlx/pgx‘i tercih eder; gorm‘u ise geliştirici hızının daha önemli olduğu CRUD ağırlıklı admin panelleri/internal araçlar için ayırır.

`jackc/pgx`

Repo: github.com/jackc/pgx/v5
Nedir: Artık bakım modunda olan lib/pq‘dan daha hızlı ve daha eksiksiz özelliklere sahip, doğrudan Postgres protokolünü destekleyen bir PostgreSQL sürücüsü ve araç seti.

Kullanım:

conn, _ := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
var name string
conn.QueryRow(context.Background(), "select name from users where id=$1", 1).Scan(&name)

Dependency Injection

`google/wire`

Repo: github.com/google/wire
Nedir: Derleme zamanı bağımlılık enjeksiyonu (dependency injection) kod üreticisi (runtime DI konteyneri/reflection tabanlı bir framework değil).
Neden popüler: Sade, debug edilebilir Go constructor kodu üretir — runtime reflection maliyeti yok, “sihirli” bir konteyner yok, hatalar derleme zamanında yakalanır.

Kullanım:

func InitializeApp() (*App, error) {
    wire.Build(NewDB, NewUserRepo, NewUserService, NewApp)
    return nil, nil // üretilen kod ile değiştirilir
}

go install github.com/google/wire/cmd/wire@latest
wire ./...

gRPC ve Protocol Buffers

`grpc/grpc-go`

Repo: google.golang.org/grpc
Nedir: HTTP/2 ve Protobuf üzerine kurulu, yüksek performanslı RPC framework’ü olan gRPC’nin resmi Go implementasyonu.

Kullanım:

s := grpc.NewServer()
pb.RegisterUserServiceServer(s, &userServer{})
lis, _ := net.Listen("tcp", ":50051")
s.Serve(lis)

Notlar: Genellikle şema yönetimi ve kod üretimi için ham protoc yerine buf (Bölüm 1’e bakınız) ile birlikte kullanılır.

`google.golang.org/protobuf`

Repo: google.golang.org/protobuf
Nedir: golang/protobuf‘un ardılı olan Go Protobuf runtime’ı (API v2).
Kullanım: Genellikle elle yazılmaz — .proto dosyalarından protoc/buf tarafından üretilir, ardından üretilen *.pb.go kodu tarafından import edilir.

Yardımcı (Utility) ve Generic Kütüphaneler

`samber/lo`

Repo: github.com/samber/lo
Nedir: Go 1.18+ generic’leri üzerine kurulu, Lodash tarzı bir generic yardımcı kütüphanesi (Map, Filter, Reduce, GroupBy, Uniq, Chunk vb.).
Neden popüler: Go’nun minimal slices/maps standart kütüphane paketlerinin bıraktığı boşluğu, çok daha zengin ve ergonomik bir API ile doldurur.

Kullanım:

evens := lo.Filter([]int{1, 2, 3, 4}, func(x int, _ int) bool { return x%2 == 0 })
doubled := lo.Map(evens, func(x int, _ int) int { return x * 2 })

`golang.org/x/sync`

Repo: golang.org/x/sync
Nedir: Resmi genişletilmiş eşzamanlılık (concurrency) ilkelleri: errgroup (hata yayılımlı goroutine grupları), singleflight (aynı çağrıların eşzamanlı tekrarını önleme), semaphore.

Kullanım:

g, ctx := errgroup.WithContext(context.Background())
for _, url := range urls {
    url := url
    g.Go(func() error { return fetch(ctx, url) })
}
if err := g.Wait(); err != nil { /* işle */ }

Hatalar, ID’ler, Zaman ve Diğerleri

`google/uuid`

Repo: github.com/google/uuid
Nedir: UUID (v1, v3, v4, v5, v6, v7) üretmek ve ayrıştırmak için standart kütüphane.

Kullanım:

id := uuid.New()
parsed, err := uuid.Parse("550e8400-e29b-41d4-a716-446655440000")

`pkg/errors` (eski) → standart `errors` + `fmt.Errorf("%w")`

Nedir: pkg/errors, Go 1.13’ün yerel %w sarmalamasını (wrapping) ve errors.Is/errors.As‘ı eklemesinden önce, stack trace’li hata sarmalamayı (error wrapping) popülerleştirdi. Artık büyük ölçüde standart kütüphanenin yerini almıştır, ama hâlâ eski kod tabanlarında görülür.

Modern kullanım:

if err != nil {
    return fmt.Errorf("kullanıcı %d getirilirken hata: %w", id, err)
}
if errors.Is(err, sql.ErrNoRows) { ... }

Notlar: Zengin stack-trace yakalayan hatalar için takımlar artık genellikle go.uber.org/multierr (birden fazla hatayı birleştirme) veya cockroachdb/errors‘a yöneliyor.

`golang-jwt/jwt`

Repo: github.com/golang-jwt/jwt/v5
Nedir: JSON Web Token oluşturmak/doğrulamak için standart kütüphane (arşivlenen dgrijalva/jwt-go‘nun ardılı).

Kullanım:

token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    "user_id": 42,
    "exp":     time.Now().Add(time.Hour).Unix(),
})
signed, _ := token.SignedString([]byte("secret"))

`robfig/cron`

Repo: github.com/robfig/cron/v3
Nedir: Süreç içi (in-process) zamanlanmış görevler için cron-ifadesi tabanlı bir görev zamanlayıcı.

Kullanım:

c := cron.New()
c.AddFunc("0 */1 * * *", func() { fmt.Println("her saat çalışır") })
c.Start()

Observability (Gözlemlenebilirlik)

`prometheus/client_golang`

Repo: github.com/prometheus/client_golang
Nedir: Resmi Prometheus metrik istemcisi — sayaçlar (counter), göstergeler (gauge), histogramlar ve bir HTTP /metrics endpoint dışa aktarıcısı.

Kullanım:

var requests = promauto.NewCounter(prometheus.CounterOpts{
    Name: "http_requests_total",
})
http.Handle("/metrics", promhttp.Handler())

`open-telemetry/opentelemetry-go`

Repo: go.opentelemetry.io/otel
Nedir: Servisler arasında dağıtık tracing, metrik ve log enstrümantasyonu için satıcıdan bağımsız (vendor-neutral) standart.
Neden popüler: Mikroservis observability için giderek varsayılan seçim haline geliyor; satıcıya özgü SDK’ların (Jaeger istemcisi, Datadog SDK’sı) yerini tek bir enstrümantasyon API’siyle alıyor.

Mesajlaşma, Önbellekleme ve Arka Plan İşleri

`redis/go-redis`

Repo: github.com/redis/go-redis/v9
Nedir: Go için en popüler Redis istemcisi; pipeline’ları, pub/sub’ı, cluster modunu ve Redis’e özgü veri yapılarını destekler.

Kullanım:

rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
rdb.Set(ctx, "key", "value", time.Hour)
val, _ := rdb.Get(ctx, "key").Result()

`hibiken/asynq`

Repo: github.com/hibiken/asynq
Nedir: Arka plan iş işleme (background job processing) için Redis destekli bir dağıtık görev kuyruğu (Sidekiq/Celery’ye benzer ama Go için).

Kullanım:

client := asynq.NewClient(asynq.RedisClientOpt{Addr: "localhost:6379"})
task := asynq.NewTask("email:send", payload)
client.Enqueue(task)

`segmentio/kafka-go`

Repo: github.com/segmentio/kafka-go
Nedir: (confluent-kafka-go‘nun aksine) librdkafka‘ya cgo bağımlılığı olmayan, saf Go ile yazılmış bir Kafka istemcisi.

Kullanım:

w := &kafka.Writer{Addr: kafka.TCP("localhost:9092"), Topic: "events"}
w.WriteMessages(ctx, kafka.Message{Value: []byte("hello")})

Proje tipine göre önerilen “başlangıç kiti”

Proje tipi	Önerilen yığın (stack)
REST API servisi	`chi` veya `gin` + `validator` + `zap`/`zerolog` + `sqlc` veya `sqlx`/`pgx` + `goose` + `testify` + `golangci-lint` + `air`
gRPC mikroservisi	`grpc-go` + `buf` + `opentelemetry-go` + `wire` + `sqlc`
CLI aracı	`cobra` + `viper` + `goreleaser`
GraphQL API	`gqlgen` + `sqlc`/`gorm` + `validator`
Arka plan worker’ı	`asynq` veya `kafka-go` + `zap` + `cron`
Tipinden bağımsız her repo	`golangci-lint`, `staticcheck`, `govulncheck`, `goimports`, `gotestsum`, `lefthook`, `testify`

Bu listeyi güncel tutma üzerine bir not

Go araç ekosistemi hızlı hareket ediyor — go.mod tool direktifleri, slog ve net/http‘in routing iyileştirmeleri, standart kütüphanenin eskiden üçüncü parti paketler gerektiren şeyleri kendi bünyesine katmasına örnektir. Bir bağımlılığın hâlâ en iyi seçim olup olmadığını, ya da standart kütüphanenin onu yakalayıp yakalamadığını periyodik olarak yeniden değerlendirin.

Go Geliştiricisinin Araç Kutusu — Temel Araçlar ve Kütüphaneler

İçindekiler

Bu rehber nasıl okunur

Bölüm 1 — CLI / Geliştirme Araçları

Derleme, Çalıştırma ve Canlı Yeniden Yükleme

air — Go uygulamaları için canlı yeniden yükleme

task — Task runner / Makefile alternatifi

Kod Kalitesi: Linting, Formatlama ve Statik Analiz

golangci-lint — Linter toplayıcısı

staticcheck — Derinlemesine statik analiz

goimports — Formatlama + import yönetimi

Test Araçları

gotestsum — İnsan dostu test çıktısı

ginkgo / gomega (ekstra bilgi)

Debugging ve Profiling

delve (dlv) — Go debugger’ı

pprof — Profiling (standart kütüphanenin içinde)

Veritabanı ve Migration Araçları

goose — Veritabanı migration’ları

sqlc — SQL’den tip güvenli Go kodu üretme

Kod Üretimi (API, GraphQL, SQL, Mock)

oapi-codegen — OpenAPI → Go

gqlgen — GraphQL sunucu üretici

buf — Protobuf araçları

mockery — Interface’ler için mock üretimi

Task Runner’lar ve Git Hook’ları

lefthook — Hızlı Git hook yöneticisi

Güvenlik ve Zafiyet Taraması

govulncheck — Resmi Go zafiyet tarayıcısı

Release ve Paketleme

goreleaser — Otomatik release pipeline’ı

Bölüm 2 — Kütüphaneler

Validasyon (Doğrulama)

go-playground/validator

Test ve Assertion

stretchr/testify

HTTP Router’lar ve Web Framework’leri

gin-gonic/gin

labstack/echo

go-chi/chi

Konfigürasyon ve CLI

spf13/cobra

spf13/viper

joho/godotenv

Loglama

uber-go/zap

rs/zerolog

Veritabanı Erişimi ve ORM

jmoiron/sqlx

go-gorm/gorm

jackc/pgx

Dependency Injection

google/wire

gRPC ve Protocol Buffers

grpc/grpc-go

google.golang.org/protobuf

Yardımcı (Utility) ve Generic Kütüphaneler

samber/lo

golang.org/x/sync

Hatalar, ID’ler, Zaman ve Diğerleri

google/uuid

pkg/errors (eski) → standart errors + fmt.Errorf("%w")

golang-jwt/jwt

robfig/cron

Observability (Gözlemlenebilirlik)

prometheus/client_golang

open-telemetry/opentelemetry-go

Mesajlaşma, Önbellekleme ve Arka Plan İşleri

redis/go-redis

hibiken/asynq

segmentio/kafka-go

Proje tipine göre önerilen “başlangıç kiti”

Bu listeyi güncel tutma üzerine bir not

`air` — Go uygulamaları için canlı yeniden yükleme

`task` — Task runner / Makefile alternatifi

`golangci-lint` — Linter toplayıcısı

`staticcheck` — Derinlemesine statik analiz

`goimports` — Formatlama + import yönetimi

`gotestsum` — İnsan dostu test çıktısı

`ginkgo` / `gomega` (ekstra bilgi)

`delve` (`dlv`) — Go debugger’ı

`pprof` — Profiling (standart kütüphanenin içinde)

`goose` — Veritabanı migration’ları

`sqlc` — SQL’den tip güvenli Go kodu üretme

`oapi-codegen` — OpenAPI → Go

`gqlgen` — GraphQL sunucu üretici

`buf` — Protobuf araçları

`mockery` — Interface’ler için mock üretimi

`lefthook` — Hızlı Git hook yöneticisi

`govulncheck` — Resmi Go zafiyet tarayıcısı

`goreleaser` — Otomatik release pipeline’ı

`go-playground/validator`

`stretchr/testify`

`gin-gonic/gin`

`labstack/echo`

`go-chi/chi`

`spf13/cobra`

`spf13/viper`

`joho/godotenv`

`uber-go/zap`

`rs/zerolog`

`jmoiron/sqlx`

`go-gorm/gorm`

`jackc/pgx`

`google/wire`

`grpc/grpc-go`

`google.golang.org/protobuf`

`samber/lo`

`golang.org/x/sync`

`google/uuid`

`pkg/errors` (eski) → standart `errors` + `fmt.Errorf("%w")`

`golang-jwt/jwt`

`robfig/cron`

`prometheus/client_golang`

`open-telemetry/opentelemetry-go`

`redis/go-redis`

`hibiken/asynq`

`segmentio/kafka-go`