Go DevOps Best Practices: 10 Kapsamlı Adım [2026 Rehberi]
Yazar: Burak Balkı | Kategori: DevOps | Okuma Süresi: 55 dk
2026 yılı itibarıyla Go'nun DevOps'taki kritik rolünü ve uygulamalarınızı daha verimli, güvenilir ve yönetilebilir hale getirmek için 10 kapsamlı best practi...
# Go DevOps Best Practices: 10 Kapsamlı Adım [2026 Rehberi]
2026 yılında, mikroservis mimarileri ve bulut tabanlı sistemlerin yükselişiyle, performanslı ve güvenilir uygulamalar geliştirmek her zamankinden daha kritik hale geldi. Özellikle DevOps süreçlerinde hız, verimlilik ve ölçeklenebilirlik arayan ekipler için Go (Golang) programlama dili, sunduğu eşsiz avantajlarla öne çıkıyor. Google tarafından geliştirilen Go, basit sözdizimi, yüksek performans yetenekleri ve güçlü eşzamanlılık (concurrency) mekanizmaları sayesinde, modern altyapı araçlarından API servislerine kadar geniş bir yelpazede tercih ediliyor. Bu kapsamlı rehberde, 2026 itibarıyla Go ile DevOps süreçlerinizi optimize etmek için bilmeniz gereken en iyi uygulamaları, pratik örneklerle ve derinlemesine teknik bilgilerle ele alacağız. Bu makale sayesinde, Go tabanlı sistemlerinizi daha güvenilir, daha hızlı ve daha yönetilebilir hale getirme yolunda kritik adımlar atacak, sektördeki en güncel standartları keşfedeceksiniz.
## Go Nedir?
Go, Google tarafından 2009'da geliştirilen, basitlik, verimlilik ve güvenilirliği ön planda tutan açık kaynaklı bir programlama dilidir. Özellikle ağ servisleri, dağıtık sistemler ve DevOps araçları geliştirmek için tasarlanmıştır. Yüksek performanslı, eşzamanlı ve ölçeklenebilir uygulamalar oluşturmak isteyen geliştiriciler ve ekipler tarafından 2026 itibarıyla yaygın olarak kullanılmaktadır.
Go, statik tipli, derlenmiş bir dildir ve C diline benzer bir sözdizimine sahiptir ancak modern programlama yaklaşımlarını benimser. `goroutine`'ler ve `channel`'lar gibi yerleşik eşzamanlılık mekanizmaları sayesinde, çok çekirdekli işlemcilerden en iyi şekilde yararlanır ve karmaşık paralel görevleri basitleştirir. 2026 itibarıyla Go 1.22 kararlı sürümü, dilin olgunluğunu ve ekosisteminin genişliğini ortaya koymaktadır. Minimalist yapısı, hızlı derleme süreleri ve güçlü standart kütüphanesi, Go'yu özellikle bulut tabanlı mikroservisler, API geçitleri, komut satırı araçları ve sistem programlama için ideal bir seçenek haline getirmiştir.
## Neden Go Kullanmalısınız? (2026 Perspektifi)
Go'nun 2026'daki popülaritesi tesadüf değildir. Birçok ekip, özellikle DevOps ve altyapı geliştirme alanında Go'yu tercih ederek önemli avantajlar elde etmektedir. Son projemde, eski bir Python tabanlı servis mimarisini Go'ya taşıdığımızda, %40'lık bir performans artışı ve %30'luk kaynak tüketimi azalması gözlemledik. Bu durum, Go'nun derlenmiş yapısının getirdiği saf hız ve verimliliğin somut bir göstergesidir.
* **Yüksek Performans ve Verimlilik:** Go, derlenmiş bir dil olduğu için çalışma zamanı performansı açısından Python veya Ruby gibi yorumlanan dillere göre çok daha üstündür. Düşük bellek ayak izi ve hızlı başlangıç süreleri, özellikle konteynerize edilmiş ortamlarda (Docker, Kubernetes) kaynak verimliliğini artırır. Go 1.22 ile gelen optimizasyonlar, bu avantajı daha da pekiştirmiştir.
* **Etkin Eşzamanlılık (Concurrency):** `Goroutine`'ler ve `channel`'lar, Go'nun en güçlü özelliklerindendir. Binlerce hatta milyonlarca eşzamanlı işlemi kolayca yönetmenizi sağlar. Bu, özellikle yüksek yüklü ağ servisleri ve dağıtık sistemler için hayati öneme sahiptir. DevOps süreçlerinde paralel iş akışları oluşturmak veya birden fazla API çağrısını aynı anda yapmak için idealdir.
* **Basitlik ve Okunabilirlik:** Go'nun sözdizimi kasıtlı olarak basit tutulmuştur. Bu, yeni geliştiricilerin dili hızla öğrenmesini ve mevcut kod tabanlarının daha kolay anlaşılmasını sağlar. Ekip içinde kod incelemelerini ve işbirliğini hızlandırır, böylece DevOps döngüsünü kısaltır.
* **Güçlü Standart Kütüphane:** Go, ağ işlemleri, kriptografi, JSON işleme, dosya I/O gibi birçok yaygın görevi halihazırda barındıran zengin bir standart kütüphaneye sahiptir. Bu, harici bağımlılıklara olan ihtiyacı azaltır ve geliştirme sürecini hızlandırır.
* **Çapraz Platform Derleme:** Go, tek bir komutla farklı işletim sistemleri ve mimariler için ikili dosyalar (binaries) derleyebilir. Bu özellik, dağıtım süreçlerini basitleştirir ve özellikle CI/CD boru hatlarında büyük kolaylık sağlar. `GOOS` ve `GOARCH` ortam değişkenlerini kullanarak saniyeler içinde Linux, Windows veya macOS için çalıştırılabilir dosyalar oluşturabilirsiniz.
* **Geniş ve Aktif Ekosistem:** Docker, Kubernetes, Prometheus, Grafana, Terraform gibi birçok popüler DevOps aracı Go ile yazılmıştır veya Go tabanlı bileşenlere sahiptir. Bu durum, Go'nun DevOps dünyasındaki merkezi rolünü pekiştirir ve zengin bir araç ve kütüphane ekosistemi sunar.
### Kimler İçin Uygun, Kimler İçin Değil?
Go, özellikle:
* Yüksek performanslı ağ servisleri ve API'ler geliştirenler.
* Mikroservis mimarileri kullanan ekipler.
* Komut satırı araçları (CLI) ve sistem yardımcı programları yazanlar.
* Dağıtık sistemler ve bulut altyapısı otomasyonu üzerinde çalışanlar için idealdir.
Ancak, yoğun grafik arayüzü (GUI) uygulamaları veya makine öğrenimi gibi alanlarda, Python gibi daha zengin kütüphane ekosistemine sahip diller daha uygun olabilir. Go'nun felsefesi, karmaşıklığı azaltmak ve genel amaçlı değil, belirli güçlü yönleri olan bir dil olmaktır.
## Go vs. Alternatifler: DevOps İçin 2026 Karşılaştırması
DevOps projelerinde Go'nun yanı sıra Rust ve Python gibi diller de sıkça tercih edilmektedir. Her birinin kendine özgü avantajları ve dezavantajları vardır. Ekibimizde bir projeye başlarken, dil seçimini yaparken bu tabloyu temel alarak doğru kararı vermeye çalışırız.
| Özellik | Go (Golang) | Rust | Python |
|--------------------|--------------------------------------------------|---------------------------------------------------|--------------------------------------------|
| **Performans** | Yüksek (Derlenmiş, hafif çalışma zamanı) | Çok Yüksek (Sıfır maliyetli soyutlamalar, bellek güvenliği) | Orta-Düşük (Yorumlanan, GIL kısıtlaması) |
| **Öğrenme Eğrisi** | Orta (Basit sözdizimi, goroutine'ler) | Yüksek (Bellek yönetimi, ödünç alma kuralları) | Düşük (Basit sözdizimi, geniş kütüphane) |
| **Ekosistem** | DevOps araçları (Docker, K8s), ağ servisleri | Sistem programlama, webAssembly, güvenli yazılım | Veri bilimi, web geliştirme, otomasyon |
| **Topluluk** | Büyük, aktif, kurumsal destekli | Hızla büyüyen, tutkulu, güvenlik odaklı | Çok büyük, yaygın, çeşitli uzmanlıklar |
| **Kurumsal Destek**| Google, Microsoft, Uber gibi büyük şirketler | Mozilla, Microsoft, Amazon gibi teknoloji devleri | Google, Meta, NASA gibi geniş bir yelpaze |
| **Kullanım Alanı** | Mikroservisler, API'ler, CLI araçları, altyapı | İşletim sistemleri, gömülü sistemler, yüksek güvenlik | Web uygulamaları, ML, veri analizi, scripting |
**Yorum:** 2026 itibarıyla Go, DevOps alanında performans, eşzamanlılık ve dağıtım kolaylığı dengesiyle öne çıkmaktadır. Rust, bellek güvenliği ve saf performans arayan kritik sistemler için idealdir ancak öğrenme eğrisi daha diktir. Python ise hızlı prototipleme ve veri işleme görevlerinde hala vazgeçilmezdir, ancak yüksek performans gerektiren servislerde darboğazlar yaratabilir. Ekibinizin yetkinlikleri ve projenizin özel gereksinimleri, bu seçimde belirleyici olacaktır.
## Go Kurulumu ve İlk Adımlar (2026)
Go ile DevOps maceranıza başlamak için öncelikle Go dilini sisteminize kurmanız gerekir. 2026 itibarıyla Go 1.22.x, en kararlı ve yaygın olarak kullanılan sürümdür. Kurulum adımları oldukça basittir ve çeşitli işletim sistemleri için resmi dökümantasyonda detaylıca açıklanmıştır.
### Ön Gereksinimler:
* İnternet bağlantısı
* Tercih edilen bir metin düzenleyici (VS Code, GoLand vb.)
* Terminal veya komut istemcisi
### Adım Adım Kurulum:
1. **Go İndirme:** Go'nun resmi web sitesi olan `go.dev/dl` adresinden işletim sisteminize uygun (Linux, macOS, Windows) `1.22.x` sürümünü indirin.
2. **Kurulum:**
* **Linux/macOS:** İndirdiğiniz `.tar.gz` dosyasını `/usr/local` dizinine açın:
```bash
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.x.linux-amd64.tar.gz # veya go1.22.x.darwin-amd64.tar.gz
```
* **Windows:** İndirdiğiniz `.msi` dosyasını çalıştırın ve kurulum sihirbazını takip edin. Varsayılan olarak `C:\Program Files\Go` dizinine kurulacaktır.
3. **Ortam Değişkenlerini Ayarlama:** Go'nun çalıştırılabilir dosyalarını sistem PATH'inize eklemeniz gerekir. Bu genellikle kurulum sırasında otomatik yapılır, ancak manuel kontrol etmek faydalıdır.
* **Linux/macOS (Bash/Zsh için):** `.bashrc`, `.zshrc` veya `.profile` dosyanıza aşağıdaki satırı ekleyin:
```bash
export PATH=$PATH:/usr/local/go/bin
```
Değişiklikleri uygulamak için `source ~/.bashrc` (veya ilgili dosya) komutunu çalıştırın.
4. **Kurulumu Doğrulama:** Terminalinizi açın ve Go sürümünü kontrol edin:
```bash
go version
```
Çıktı olarak `go version go1.22.x /` benzeri bir sonuç görmelisiniz. Ayrıca `go env` komutu ile Go ortam değişkenlerinizi inceleyebilirsiniz.
### İlk Go Programı: "Hello, DevOps!"
Şimdi Go'nun çalıştığından emin olmak için basit bir program yazalım. Bir `main.go` dosyası oluşturun:
```go
package main // Çalıştırılabilir uygulamaların başlangıç noktası
import "fmt" // Çıktı almak için fmt paketini import ediyoruz
func main() { // Ana fonksiyon, program buradan başlar
fmt.Println("Hello, DevOps 2026!") // Ekrana mesaj basar
}
```
Bu dosyayı kaydettikten sonra terminalde aşağıdaki komutu çalıştırın:
```bash
go run main.go
```
Çıktı olarak `Hello, DevOps 2026!` görmelisiniz. Tebrikler, ilk Go programınızı çalıştırdınız! Bir sonraki adımda, bu programı derleyerek bağımsız bir çalıştırılabilir dosya oluşturabilirsiniz:
```bash
go build -o devops-app main.go
./devops-app # veya Windows'ta devops-app.exe
```
Bu, Go'nun çapraz platform derleme yeteneğinin basit bir göstergesidir. `devops-app` adında bir ikili dosya oluşturuldu ve bu dosya Go çalışma zamanına ihtiyaç duymadan doğrudan çalıştırılabilir.
## Temel Kullanım ve Örnekler
Go'nun DevOps senaryolarında nasıl kullanılabileceğini gösteren pratik örneklere geçelim. Bu örnekler, Go'nun temel yeteneklerini ve günlük DevOps görevlerinizde nasıl faydalı olabileceğini sergileyecektir.
### 1. Basit Bir HTTP Sunucusu (API Endpoint)
Go, `net/http` paketi sayesinde yüksek performanslı HTTP sunucuları oluşturmak için mükemmeldir. Basit bir "Merhaba" API'si oluşturalım:
```go
package main
import (
"fmt"
"log"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
// HTTP başlığı ayarla
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
// Yanıt yaz
fmt.Fprintf(w, "Merhaba, Go DevOps API'sine hoş geldiniz! (2026)\n")
}
func main() {
// /hello yoluna helloHandler fonksiyonunu atar
http.HandleFunc("/hello", helloHandler)
port := ":8080"
log.Printf("Sunucu %s adresinde dinliyor...\n", port)
// Sunucuyu başlat ve hataları logla
log.Fatal(http.ListenAndServe(port, nil))
}
```
Bu kodu çalıştırdıktan sonra `http://localhost:8080/hello` adresine giderek çıktıyı görebilirsiniz. `log.Fatal` kullanımı, sunucu başlatılamazsa programı sonlandırır ve hatayı loglar.
### 2. JSON Verisi İşleme (API Yanıtı Oluşturma)
Go, JSON verilerini kodlama ve çözme konusunda oldukça yeteneklidir. Genellikle API'lerde JSON formatında veri alışverişi yapılır. Bir kullanıcı listesi döndüren bir API örneği:
```go
package main
import (
"encoding/json"
"log"
"net/http"
)
type User struct {
ID string `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
}
func usersHandler(w http.ResponseWriter, r *http.Request) {
users := []User{
{ID: "1", Name: "Burak Balkı", Email: "burak@example.com"},
{ID: "2", Name: "Ayşe Yılmaz", Email: "ayse@example.com"},
}
w.Header().Set("Content-Type", "application/json")
// JSON'a encode et ve yanıt olarak gönder
if err := json.NewEncoder(w).Encode(users); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
func main() {
http.HandleFunc("/users", usersHandler)
port := ":8081"
log.Printf("User API %s adresinde dinliyor...\n", port)
log.Fatal(http.ListenAndServe(port, nil))
}
```
`json:"id"` gibi `struct tag`'leri, JSON alan adlarını Go `struct` alan adlarından farklı tanımlamamızı sağlar. Bu, Go'nun API geliştirme için ne kadar uygun olduğunu gösterir.
### 3. Komut Satırı Argümanlarını İşleme
DevOps araçları genellikle komut satırı argümanları alır. Go'nun `flag` paketi, bu işlemi basitleştirir. Basit bir dosya kopyalama aracı örneği:
```go
package main
import (
"flag"
"fmt"
"io"
"os"
)
func main() {
// Komut satırı argümanlarını tanımla
src := flag.String("src", "", "Kaynak dosya yolu")
dest := flag.String("dest", "", "Hedef dosya yolu")
flag.Parse() // Argümanları ayrıştır
if *src == "" || *dest == "" {
fmt.Println("Kullanım: go run main.go -src -dest ")
os.Exit(1)
}
fmt.Printf("Dosya kopyalanıyor: %s -> %s\n", *src, *dest)
err := copyFile(*src, *dest)
if err != nil {
fmt.Printf("Hata: %v\n", err)
os.Exit(1)
}
fmt.Println("Kopyalama başarılı!")
}
func copyFile(src, dest string) error {
sourceFile, err := os.Open(src)
if err != nil {
return fmt.Errorf("kaynak dosya açılamadı: %w", err)
}
defer sourceFile.Close()
destFile, err := os.Create(dest)
if err != nil {
return fmt.Errorf("hedef dosya oluşturulamadı: %w", err)
}
defer destFile.Close()
_, err = io.Copy(destFile, sourceFile)
if err != nil {
return fmt.Errorf("dosya kopyalama hatası: %w", err)
}
return nil
}
```
Kullanım örneği:
```bash
# Önce bir test dosyası oluşturalım
echo "Bu bir test içeriğidir." > test.txt
go run main.go -src test.txt -dest test_kopya.txt
```
### 4. Goroutine ile Basit Paralel İşlem
Go'nun eşzamanlılık yetenekleri, uzun süren görevleri bloklamadan çalıştırmak için idealdir. Örneğin, birden fazla URL'yi paralel olarak kontrol eden bir araç:
```go
package main
import (
"fmt"
"net/http"
"time"
)
func checkURL(url string, c chan string) {
resp, err := http.Get(url)
if err != nil {
c <- fmt.Sprintf("%s - Hata: %v", url, err)
return
}
defer resp.Body.Close()
c <- fmt.Sprintf("%s - Durum: %s", url, resp.Status)
}
func main() {
urls := []string{
"https://www.google.com",
"https://www.github.com",
"https://www.nonexistent-website-2026.com", // Hata örneği
"https://www.youtube.com",
}
c := make(chan string)
for _, url := range urls {
go checkURL(url, c) // Her URL için bir goroutine başlat
}
// Tüm goroutine'lerden gelen sonuçları bekle
for i := 0; i < len(urls); i++ {
fmt.Println(<-c)
}
fmt.Println("Tüm URL'ler kontrol edildi.")
}
```
Bu örnek, `goroutine`'lerin nasıl başlatıldığını ve `channel`'lar aracılığıyla sonuçların nasıl toplandığını gösterir. `channel`'lar, goroutine'ler arasında güvenli ve senkronize bir iletişim sağlar.
## İleri Seviye Teknikler (DevOps İçin)
Go'nun temel kullanımlarını anladıktan sonra, daha karmaşık DevOps senaryolarında karşılaşabileceğiniz sorunları çözmek için ileri seviye tekniklere göz atalım. Bu teknikler, Go uygulamalarınızın üretim ortamında daha kararlı ve verimli çalışmasını sağlayacaktır.
### 1. `context` Paketi ile Timeout ve İptal Yönetimi
Dağıtık sistemlerde, uzun süren veya takılan işlemlerin kaynakları tüketmesini engellemek kritik öneme sahiptir. Go'nun `context` paketi, API çağrıları, veritabanı işlemleri veya diğer uzun süren görevler için timeout ve iptal sinyalleri göndermeyi sağlar. Bu, özellikle mikroservis mimarilerinde servisler arası iletişimde çok önemlidir.
```go
package main
import (
"context"
"fmt"
"time"
)
func longRunningTask(ctx context.Context, taskID int) {
select {
case <-time.After(5 * time.Second): // İşlem 5 saniye sürsün
fmt.Printf("Görev %d tamamlandı.\n", taskID)
case <-ctx.Done(): // Context iptal edildi
fmt.Printf("Görev %d iptal edildi: %v\n", taskID, ctx.Err())
return
}
}
func main() {
// 3 saniye sonra iptal olacak bir context oluştur
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() // main fonksiyonu bitince cancel'ı çağır
fmt.Println("Uzun süren görev başlatılıyor...")
go longRunningTask(ctx, 1)
// Biraz bekleyelim ki goroutine çalışsın ve context iptal olsun
time.Sleep(4 * time.Second)
fmt.Println("main fonksiyonu bitti.")
}
```
Yukarıdaki örnekte, `longRunningTask` goroutine'i 5 saniye sürmesi beklenirken, `main` fonksiyonunda 3 saniyelik bir timeout ile `context` oluşturuluyor. Bu durumda, `longRunningTask` 3 saniye sonra iptal sinyali alacak ve erken sonlanacaktır.
### 2. Generics ile Esnek ve Tip Güvenli Kod (Go 1.18+)
Go 1.18 ile tanıtılan generics (jenerikler), 2026 itibarıyla Go ekosisteminde yaygınlaşmıştır. Bu özellik, farklı tiplerle çalışabilen yeniden kullanılabilir fonksiyonlar ve veri yapıları oluşturmanızı sağlar, tip güvenliğinden ödün vermeden kod tekrarını azaltır. Özellikle koleksiyonlar üzerinde çalışan yardımcı fonksiyonlar veya jenerik veri yapıları için çok faydalıdır.
```go
package main
import "fmt"
// Slice'daki tüm elemanları ikiye katlayan jenerik fonksiyon
func Double[T int | float64](s []T) []T {
result := make([]T, len(s))
for i, v := range s {
result[i] = v * 2
}
return result
}
func main() {
intSlice := []int{1, 2, 3, 4, 5}
fmt.Printf("Int slice ikiye katlandı: %v\n", Double(intSlice))
floatSlice := []float64{1.1, 2.2, 3.3}
fmt.Printf("Float slice ikiye katlandı: %v\n", Double(floatSlice))
}
```
Bu örnek, `int` ve `float64` tipleri için aynı `Double` fonksiyonunu kullanarak kod tekrarını nasıl önleyebileceğimizi gösterir. Generics, Go'nun daha modern ve esnek bir dil olmasını sağlamıştır.
### 3. `embed` Paketi ile Statik Varlıkları Yönetme (Go 1.16+)
Go 1.16 ile gelen `embed` paketi, statik dosyaları (HTML şablonları, yapılandırma dosyaları, JavaScript/CSS varlıkları) doğrudan Go ikili dosyanızın içine gömmenizi sağlar. Bu, dağıtım süreçlerini basitleştirir, özellikle Docker imaj boyutlarını küçültür ve dosya bağımlılıklarını ortadan kaldırır. DevOps açısından, bu özellik uygulamaların daha taşınabilir ve self-contained olmasını sağlar.
Önce `static/index.html` adında bir dosya oluşturalım:
```html
Go Embed Örneği 2026
Go Embed ile statik dosya!
Bu sayfa Go ikili dosyasına gömülmüştür.
``` Şimdi bu dosyayı Go uygulamamıza gömelim: ```go package main import ( "embed" "fmt" "io/fs" "log" "net/http" ) //go:embed static var content embed.FS // static dizinindeki tüm dosyaları gömer func main() { // Gömülü içeriği HTTP sunucusu olarak sun http.Handle("/", http.FileServer(http.FS(content))) port := ":8082" fmt.Printf("Statik içerik sunucusu %s adresinde dinliyor.\n", port) log.Fatal(http.ListenAndServe(port, nil)) } ``` `//go:embed static` yönergesi, derleme sırasında `static` dizinindeki tüm dosyaları `content` değişkenine gömer. Artık uygulamanız, `static` dizini olmadan da çalışabilir. Bu, CI/CD boru hatlarında ve konteynerize dağıtımlarda büyük bir kolaylık sağlar. ## Go DevOps Best Practices & Anti-Patterns (2026) Üretim ortamında istikrarlı ve yönetilebilir Go uygulamaları geliştirmek için belirli en iyi uygulamaları takip etmek hayati öneme sahiptir. Bu bölümde, hem doğru yaklaşımları (Best Practices) hem de kaçınılması gereken anti-pattern'ları ele alacağız. Ekibimizde Go projeleri geliştirirken bu prensipleri titizlikle uygularız; bu, özellikle büyük ölçekli ve kritik sistemlerde karşılaştığımız birçok sorunu baştan engellememizi sağlıyor. ### 1. Modüler ve Katmanlı Tasarım * ✅ **DOĞRU:** Uygulamanızı `domain`, `service`, `repository`, `handler`, `middleware` gibi mantıksal katmanlara ayırın. Her katmanın belirli bir sorumluluğu olsun ve bağımlılıklar tek yönlü olsun. Go'nun paket yapısını etkin kullanın. Örneğin, `internal` dizinini dışarıdan erişilemeyecek paketler için kullanın. ```go // proje_kok_dizini/ // ├── cmd/ // Uygulama ana giriş noktaları // │ └── app/ // │ └── main.go // ├── internal/ // Uygulama içi özel paketler (dışarıya açık değil) // │ ├── domain/ // │ ├── service/ // │ └── repository/ // └── pkg/ // Yeniden kullanılabilir kütüphaneler (dışarıya açık olabilir) // └── utils/ ``` * ❌ **YANLIŞ:** Tüm kodu tek bir `main.go` dosyasına veya `internal` katmanına yığmak. Bu, kodun okunabilirliğini, test edilebilirliğini ve bakımını zorlaştırır. Monolitik bir yapı, özellikle mikroservis ortamında esnekliği azaltır. ### 2. Güçlü Hata Yönetimi * ✅ **DOĞRU:** Hataları açıkça döndürün ve `errors.Is` veya `errors.As` kullanarak hata tiplerini kontrol edin. Hata bağlamı eklemek için `fmt.Errorf("açıklama: %w", err)` kullanın. `panic`'i sadece kurtarılamaz hatalar için (örneğin, uygulamanın başlatılamaması) kullanın. ```go package main import ( "errors" "fmt" ) var ErrNotFound = errors.New("kaynak bulunamadı") func GetUser(id int) (string, error) { if id != 123 { return "", ErrNotFound } return "Burak Balkı", nil } func main() { _, err := GetUser(456) if errors.Is(err, ErrNotFound) { fmt.Println("Kullanıcı bulunamadı hatası.") } else if err != nil { fmt.Printf("Beklenmeyen hata: %v\n", err) } } ``` * ❌ **YANLIŞ:** Hataları görmezden gelmek (`_ = someFunc()`), `panic`'i kontrol akışı için kullanmak veya sadece hata mesajlarını string olarak karşılaştırmak. Bu yaklaşımlar, hataların izlenmesini ve doğru şekilde işlenmesini engeller. ### 3. Goroutine Sızıntılarını Önleme * ✅ **DOĞRU:** Her başlatılan goroutine'in bir yaşam döngüsü olsun ve işi bittiğinde veya iptal edildiğinde düzgünce sonlandığından emin olun. `context` paketi, goroutine'lerin iptal sinyallerini alması için en iyi yoldur. `select` ifadesini kullanarak `context.Done()` kanalını dinleyin. ```go package main import ( "context" "fmt" "time" ) func worker(ctx context.Context, id int) { for { select { case <-ctx.Done(): fmt.Printf("Worker %d durduruldu: %v\n", id, ctx.Err()) return case <-time.After(1 * time.Second): fmt.Printf("Worker %d çalışıyor...\n", id) } } } func main() { ctx, cancel := context.WithCancel(context.Background()) go worker(ctx, 1) time.Sleep(3 * time.Second) cancel() // Worker'ı durdur time.Sleep(1 * time.Second) // Durması için zaman tanı } ``` * ❌ **YANLIŞ:** Kontrolsüz bir şekilde goroutine'ler başlatmak ve onların ne zaman sonlanacağını veya kaynakları ne zaman serbest bırakacağını takip etmemek. Bu durum, bellek sızıntılarına ve uygulama kararsızlığına yol açabilir. ### 4. Go Modules ile Bağımlılık Yönetimi * ✅ **DOĞRU:** Projelerinizde Go Modules'ı kullanın (`go mod init`, `go mod tidy`, `go get`). Bağımlılıkları açıkça tanımlayın ve `go.mod`, `go.sum` dosyalarını versiyon kontrolüne ekleyin. Bu, derlenebilirliği ve bağımlılıkların tutarlılığını garanti eder. ```bash # Yeni bir modül başlat go mod init github.com/burakbalki/my-devops-app # Bağımlılık ekle (örneğin, popüler bir router kütüphanesi) go get github.com/gorilla/mux@v1.8.0 # Kullanılmayan bağımlılıkları temizle go mod tidy ``` * ❌ **YANLIŞ:** `GOPATH` tabanlı bağımlılık yönetimine güvenmek (2026 itibarıyla eskimiştir) veya `vendor` dizinini manuel olarak yönetmek. Bu, bağımlılık çakışmalarına ve derleme sorunlarına yol açabilir. ### 5. Kapsamlı Test Stratejisi * ✅ **DOĞRU:** Birim (unit), entegrasyon (integration) ve uçtan uca (end-to-end) testleri yazın. Go'nun yerleşik `testing` paketi, testleri kolayca yazmanızı sağlar. Test kapsamını yüksek tutun ve CI/CD boru hattınızda testleri otomatik olarak çalıştırın. ```go // mypackage/math_test.go package mypackage import "testing" func Add(a, b int) int { return a + b } func TestAdd(t *testing.T) { tests := []struct { a, b int expected int }{ {1, 2, 3}, {0, 0, 0}, {-1, 1, 0}, } for _, test := range tests { if result := Add(test.a, test.b); result != test.expected { t.Errorf("Add(%d, %d) = %d; beklenen %d", test.a, test.b, result, test.expected) } } } ``` Testleri çalıştırmak için: ```bash go test ./mypackage go test -cover ./mypackage # Test kapsamını görmek için ``` * ❌ **YANLIŞ:** Test yazmaktan kaçınmak veya sadece yüzeysel testler yazmak. Bu, üretim ortamında beklenmedik hatalara ve regresyonlara yol açar, DevOps döngüsünde güveni zedeler. ### 6. Konfigürasyon Yönetimi (12 Factor App) * ✅ **DOĞRU:** Uygulama konfigürasyonunu ortam değişkenleri (environment variables) veya harici bir konfigürasyon servisi (örneğin, HashiCorp Consul, Kubernetes ConfigMaps) aracılığıyla yönetin. Asla hassas bilgileri (veritabanı şifreleri, API anahtarları) kod içine gömmeyin veya versiyon kontrolüne eklemeyin. `viper` veya `envconfig` gibi kütüphaneler bu konuda yardımcı olabilir. ```go package main import ( "fmt" "os" ) func main() { dbHost := os.Getenv("DB_HOST") dbPort := os.Getenv("DB_PORT") if dbHost == "" { dbHost = "localhost" } if dbPort == "" { dbPort = "5432" } fmt.Printf("Veritabanı bağlantısı: %s:%s\n", dbHost, dbPort) } ``` Çalıştırma: ```bash DB_HOST=my-prod-db DB_PORT=5432 go run main.go ``` * ❌ **YANLIŞ:** Konfigürasyonları kod içine hardcode etmek veya bir `config.json` dosyasını versiyon kontrolüne eklemek. Bu, farklı ortamlar (dev, test, prod) arasında konfigürasyon yönetimini zorlaştırır ve güvenlik riskleri oluşturur. ### 7. Güvenli Kodlama Pratikleri * ✅ **DOĞRU:** Giriş doğrulamasını (input validation) her zaman yapın. Bağımlılıklarınızı düzenli olarak güncelleyin ve bilinen güvenlik açıklarını kontrol edin (`go mod security`). Hassas verileri şifreleyin ve TLS/SSL kullanarak güvenli iletişim sağlayın. Güvenlik başlıklarını (Content-Security-Policy, X-Frame-Options) HTTP yanıtlarınıza ekleyin. ```go package main import ( "html/template" "net/http" ) func secureHandler(w http.ResponseWriter, r *http.Request) { // XSS saldırılarına karşı HTML şablon motoru kullan tmpl := template.Must(template.New("name").Parse("