Go ile Mikroservisler Oluşturmaya Pratik Bir Giriş: GoFr ile Tanışın

Go ile Mikroservisler Oluşturmaya Pratik Bir Giriş: GoFr ile Tanışın

Modern yazılım geliştirme dünyasında ölçeklenebilirlik, esneklik ve hızlı dağıtım giderek daha kritik hale gelmektedir. Monolitik uygulamaların getirdiği zorluklar karşısında mikroservis mimarisi, geliştiricilere daha modüler ve yönetilebilir sistemler inşa etme olanağı sunar. Bu kapsamlı rehberde, Go programlama dilinin gücünü ve GoFr framework’ünün pratikliğini birleştirerek mikroservis dünyasına adım atacağız. Performanslı, bakımı kolay ve ölçeklenebilir uygulamalar geliştirmek hiç bu kadar basit olmamıştı. GoFr ile mikroservislerin temel prensiplerini anlamak, ilk servisinizi oluşturmak ve gerçek dünya senaryolarında nasıl kullanabileceğinizi keşfetmek için hazırsanız, bu yolculuğa başlayalım.

Mikroservis Mimarisi Neden Önemli ve Go Neden İdeal Bir Seçimdir?

Yazılım geliştirme süreçleri, özellikle büyük ve karmaşık sistemlerde, sürekli olarak yeni zorluklarla karşılaşmaktadır. Geleneksel monolitik (bütünleşik) mimarilerde, tüm uygulamanın tek bir büyük kod tabanı içinde yer alması, zamanla geliştirme hızını yavaşlatabilir, yeni özelliklerin eklenmesini zorlaştırabilir ve sistemin tamamını etkileyen hatalara yol açabilir. Tek bir bileşendeki bir değişiklik, tüm uygulamanın yeniden derlenmesini ve dağıtılmasını gerektirebilir ki bu da ciddi operasyonel yükler anlamına gelir. Ölçeklenebilirlik açısından da monolitikler, uygulamanın yalnızca belirli bir bölümü aşırı yüklense bile tüm sistemin ölçeklendirilmesini gerektirdiği için kaynak israfına neden olabilir.

İşte tam da bu noktada mikroservis mimarisi devreye girer. Mikroservisler, bir uygulamayı bağımsız, küçük ve kendi kendine yeten servisler koleksiyonu olarak tasarlama yaklaşımıdır. Her servis, belirli bir iş alanına odaklanır ve kendi veritabanına, iş mantığına ve API’sine sahip olabilir. Bu yapı, birçok önemli avantajı beraberinde getirir. Öncelikle, servisler birbirinden bağımsız olduğu için, bir serviste yapılan değişiklikler diğer servisleri doğrudan etkilemez, bu da geliştirme ve dağıtım süreçlerini hızlandırır. İkincisi, her servis kendi teknolojisini (programlama dili, veritabanı vb.) seçebilir, bu da ekibin en uygun araçları kullanmasına olanak tanır. Üçüncüsü, servisler bağımsız olarak ölçeklendirilebilir, yani yalnızca ihtiyacı olan servislerin kaynakları artırılarak maliyet etkinliği sağlanır. Son olarak, hata yalıtımı (fault isolation) sayesinde, bir servisteki bir hata tüm sistemin çökmesine neden olmaz, bu da sistemin genel direncini artırır.

Peki, mikroservis geliştirmek için neden Go (Golang) programlama dili bu kadar popüler bir tercih haline geldi? Go, Google tarafından geliştirilmiş, derlenmiş, eşzamanlılık (concurrency) odaklı, statik tipli bir dildir. Mikroservisler için ideal olmasını sağlayan başlıca özellikleri şunlardır:

• Performans: Go, C/C++ gibi dillere yakın bir performans sunarken, Python veya JavaScript gibi dillere göre çok daha hızlı çalışır. Bu, yüksek trafikli mikroservisler için kritik bir avantajdır.
• Eşzamanlılık (Concurrency): Go’nun goroutine’leri ve channel’ları, eşzamanlı programlamayı son derece kolay ve verimli hale getirir. Bu, aynı anda birden fazla isteği işleyebilen ve I/O yoğun operasyonları sorunsuz bir şekilde yönetebilen mikroservisler için biçilmiş kaftandır.
• Küçük Bellek Ayak İzi: Go ile yazılan uygulamalar genellikle düşük bellek tüketimine sahiptir, bu da bulut ortamlarında maliyet tasarrufu sağlar.
• Hızlı Derleme Süresi: Go projeleri çok hızlı derlenir, bu da geliştirme döngülerini kısaltır.
• Statik Bağlantı (Static Linking): Go, tüm bağımlılıkları tek bir çalıştırılabilir dosyaya derleyebilir, bu da dağıtımı (deployment) son derece basitleştirir (tek bir dosya kopyalamak yeterlidir).
• Güçlü Standart Kütüphane: Go’nun standart kütüphanesi, HTTP sunucuları, JSON işleme, veritabanı sürücüleri gibi birçok temel mikroservis ihtiyacını karşılayacak zengin özellikler sunar.

GoFr ise, Go’nun bu güçlü yönlerini alıp mikroservis geliştirme sürecini daha da kolaylaştıran, hafif ve modüler bir framework (yazılım çerçevesidir). Yapılandırma yönetimi, bağımlılık enjeksiyonu, HTTP yönlendirme ve hata işleme gibi tekrarlayan görevleri basitleştirerek geliştiricilerin iş mantığına odaklanmasını sağlar. Bu sayede, Go ile performanslı ve ölçeklenebilir mikroservisler oluşturmak, GoFr’ın sunduğu kolaylıklarla birlikte çok daha erişilebilir hale gelir.

GoFr Nedir ve Mikroservis Geliştirmeyi Nasıl Basitleştirir?

Go programlama dilinin mikroservisler için sunduğu avantajları ele aldık. Ancak, her ne kadar Go güçlü bir dil olsa da, sıfırdan bir mikroservis inşa etmek; HTTP yönlendirme, yapılandırma yönetimi, bağımlılık enjeksiyonu, loglama, hata yönetimi ve veritabanı entegrasyonu gibi birçok temel bileşenin manuel olarak kurulmasını ve yapılandırılmasını gerektirebilir. İşte GoFr, tam da bu noktada devreye girerek geliştiricilerin hayatını kolaylaştıran, hafif ve modüler bir Go framework’ü olarak öne çıkar.

GoFr, “opinionated” (belirli bir yaklaşımı benimsemiş) bir framework olmaktan ziyade, geliştiricilere esneklik sunan, ancak aynı zamanda mikroservisler için en iyi uygulamaları teşvik eden bir yapıda tasarlanmıştır. Temel amacı, Go ile mikroservis geliştirmeyi daha hızlı, daha güvenilir ve daha az tekrarlayan bir süreç haline getirmektir. Bunu yaparken, Go’nun kendi felsefesine sadık kalır: basitlik ve performans.

GoFr’ın mikroservis geliştirmede çözdüğü başlıca sorunlar ve sunduğu kolaylıklar şunlardır:

• Yapılandırma Yönetimi: Mikroservisler genellikle farklı ortamlar (geliştirme, test, üretim) için farklı yapılandırmalara ihtiyaç duyar. GoFr, ortam değişkenleri, dosya tabanlı yapılandırmalar veya komut satırı argümanları aracılığıyla kolay ve merkezi bir yapılandırma yönetimi sağlar. Bu sayede, servislerinizin ayarlarını dinamik olarak yönetebilirsiniz.
• HTTP Yönlendirme (Routing): Bir API servisi oluştururken farklı URL yollarına (path) ve HTTP metotlarına (GET, POST, PUT, DELETE) istekleri yönlendirmek temel bir gereksinimdir. GoFr, sezgisel ve performansı yüksek bir yönlendirme mekanizması sunarak, API endpoint’lerinizi kolayca tanımlamanızı sağlar.
• Bağımlılık Enjeksiyonu (Dependency Injection – DI): Büyük uygulamalarda bileşenler arası bağımlılıkları yönetmek karmaşık olabilir. GoFr, bağımlılık enjeksiyonunu destekleyerek kodunuzu daha modüler, test edilebilir ve sürdürülebilir hale getirir. Bu, özellikle test yazarken veya bileşenleri değiştirirken büyük kolaylık sağlar.
• Hata Yönetimi: Sağlam bir mikroservis, hataları düzgün bir şekilde ele almalı ve istemciye anlamlı yanıtlar döndürmelidir. GoFr, merkezi bir hata işleme mekanizması sunarak, uygulamanızdaki hataları standart bir şekilde yakalamanıza ve yönetmenize olanak tanır.
• Loglama: Uygulamaların çalışma zamanındaki davranışlarını izlemek ve sorunları gidermek için etkili loglama kritik öneme sahiptir. GoFr, yapılandırılabilir ve performanslı bir loglama çözümü sunar, böylece servislerinizin ne yaptığını kolayca takip edebilirsiniz.
• Veritabanı Entegrasyonu: Çoğu mikroservis, verileri kalıcı olarak depolamak için bir veritabanına ihtiyaç duyar. GoFr, popüler veritabanlarıyla (PostgreSQL, MySQL vb.) kolay entegrasyon sağlayarak veri erişim katmanını basitleştirir.
• Middleware Desteği: İstek işleme zincirine ek işlevsellik (kimlik doğrulama, yetkilendirme, CORS, sıkıştırma vb.) eklemek için middleware’ler vazgeçilmezdir. GoFr, esnek bir middleware yapısı sunarak bu tür işlevleri kolayca entegre etmenizi sağlar.

Diğer Go framework’leri (örneğin Gin, Echo, Fiber) genellikle sadece HTTP yönlendirme ve istek işleme katmanına odaklanırken, GoFr daha kapsamlı bir çözüm sunar. Yapılandırma, DI, loglama gibi mikroservislerin temel ihtiyaçlarını tek bir çatıda birleştirerek, geliştiricilerin farklı kütüphaneleri bir araya getirme yükünü azaltır. Modüler yapısı sayesinde, sadece ihtiyacınız olan bileşenleri kullanabilir, gereksiz şişkinlikten kaçınabilirsiniz. Kısacası, GoFr, Go ile mikroservis geliştirmek isteyenler için hızlı başlangıç yapmalarını sağlayan, iyi düşünülmüş ve pratik bir araç setidir.

GoFr ile İlk Mikroservisinizi Oluşturma Rehberi

GoFr’ın ne olduğunu ve neden mikroservis geliştirmede faydalı olduğunu öğrendik. Şimdi sıra geldi ilk GoFr mikroservisimizi oluşturmaya. Bu bölümde, Go’nun kurulu olduğu bir ortamda sıfırdan basit bir HTTP API servisi nasıl yazılır, adım adım göreceğiz. Bu örnek, GoFr’ın temel yapısını ve bir endpoint’i nasıl tanımladığınızı anlamanıza yardımcı olacaktır.

Ön Gereksinimler

Başlamadan önce sisteminizde Go programlama dilinin kurulu olduğundan emin olmalısınız. Go’nun resmi web sitesinden (go.dev) işletim sisteminize uygun sürümü indirip kurabilirsiniz. Kurulumu doğrulama için terminalinizde go version komutunu çalıştırabilirsiniz.

Proje Klasörü Oluşturma ve Go Modülünü Başlatma

İlk olarak, projemiz için yeni bir klasör oluşturalım ve bu klasörün içine girelim. Ardından, Go modülünü başlatarak projemizin bağımlılıklarını yönetecek bir go.mod dosyası oluşturalım:

mkdir my-first-gofr-service
cd my-first-gofr-service
go mod init my-first-gofr-service
  

Yukarıdaki komutlar, projeniz için my-first-gofr-service adında bir dizin oluşturacak ve bu dizini bir Go modülü olarak başlatacaktır. go.mod dosyası, projenizin ihtiyaç duyduğu kütüphaneleri ve onların sürümlerini takip etmenizi sağlar.

Basit Bir “Hello World” API Endpoint’i Oluşturma

Şimdi projemizin ana dosyası olan main.go dosyasını oluşturalım ve içine GoFr ile basit bir “Hello World” API endpoint’i tanımlayan kodu yazalım:

// main.go
package main

import (
	"my-first-gofr-service/app" // Kendi uygulama paketimizi içe aktarıyoruz
)

func main() {
	// GoFr uygulamasını başlatıyoruz
	app.New().Run()
}

// app/app.go
package app

import (
	"github.com/gofr-dev/gofr"
)

func New() *gofr.App {
	app := gofr.New()

	// GET /hello endpoint'ini tanımlıyoruz
	app.GET("/hello", func(c *gofr.Context) (interface{}, error) {
		name := c.Param("name") // URL parametresini alıyoruz
		if name == "" {
			name = "Dünya"
		}
		return "Merhaba, " + name + "!", nil // JSON yanıtı döndürüyoruz
	})

	return app
}
  

Yukarıdaki kodda iki önemli dosya bulunmaktadır: main.go ve app/app.go. Bu ayrım, Go projelerinde genellikle uygulamanın ana başlatma mantığını ve iş mantığını ayrı tutmak için kullanılan iyi bir uygulamadır. İlk olarak, projenizin kök dizininde main.go dosyasını oluşturun. Ardından, app adında yeni bir dizin oluşturun ve içine app.go dosyasını yerleştirin.

Kodun açıklamasını yapalım:

• package main: Go’da çalıştırılabilir programların ana paketi budur.
• import "my-first-gofr-service/app": Kendi uygulama mantığımızı içeren app paketini içe aktarıyoruz.
• func main(): Go programlarının başlangıç noktasıdır. Burada app.New().Run() çağrısı ile GoFr uygulamasını başlatıyoruz.
• app/app.go dosyasında package app ile ayrı bir paket tanımlıyoruz.
• import "github.com/gofr-dev/gofr": GoFr framework’ünü içe aktarıyoruz.
• func New() *gofr.App: Bu fonksiyon, yeni bir GoFr uygulaması (*gofr.App) örneği oluşturur ve yapılandırır.
• app := gofr.New(): Yeni bir GoFr uygulama nesnesi oluşturulur.
• app.GET("/hello", func(c *gofr.Context) (interface{}, error) { ... }): Bu satır, HTTP GET metodu ile /hello yoluna gelen istekleri işleyecek bir yönlendirici (router) tanımlar. İçindeki anonim fonksiyon (handler), isteği işler.
  • c *gofr.Context: GoFr, her istek için bir Context (bağlam) nesnesi sağlar. Bu nesne, istekle ilgili bilgilere (parametreler, başlıklar, gövde vb.) erişmek ve yanıt döndürmek için kullanılır.
  • c.Param("name"): URL’den “name” adında bir parametre almaya çalışır. Örneğin, /hello?name=Ali isteğinde “Ali” değerini alır.
  • return "Merhaba, " + name + "!", nil: İstemciye bir string yanıtı döndürür. nil ise hatanın olmadığını belirtir. GoFr, bu string’i otomatik olarak bir JSON yanıtına dönüştürecektir.

Uygulamayı Çalıştırma ve Test Etme

Kodumuzu yazdıktan sonra, GoFr bağımlılıklarını indirmemiz gerekiyor. Terminalinizde proje klasörünüzde iken şu komutu çalıştırın:

go mod tidy
  

Bu komut, go.mod dosyanızdaki eksik bağımlılıkları indirir ve gereksiz olanları kaldırır. Şimdi uygulamamızı çalıştırabiliriz:

go run main.go
  

Uygulama başarıyla başlatıldığında, terminalinizde GoFr’ın varsayılan olarak :8000 portunda dinlemeye başladığını belirten bir mesaj görmelisiniz. Şimdi bir web tarayıcısı veya cURL gibi bir araç kullanarak API’mizi test edebiliriz:

• Tarayıcınızda veya cURL ile: http://localhost:8000/hello adresine gidin. Yanıt olarak "Merhaba, Dünya!" görmelisiniz.
• Tarayıcınızda veya cURL ile: http://localhost:8000/hello?name=GofrKullanicisi adresine gidin. Yanıt olarak "Merhaba, GofrKullanicisi!" görmelisiniz.

Tebrikler! İlk GoFr mikroservisinizi başarıyla oluşturdunuz ve çalıştırdınız. Bu basit örnek, GoFr’ın ne kadar hızlı ve kolay bir şekilde bir HTTP API oluşturmanıza olanak tanıdığını göstermektedir. İlerleyen bölümlerde, bu temelin üzerine daha karmaşık özellikler inşa etmeyi öğreneceğiz.

Veritabanı Entegrasyonu ve CRUD Operasyonları: GoFr ile Veri Yönetimi

Modern mikroservislerin çoğu, verileri kalıcı olarak depolamak ve yönetmek için bir veritabanına ihtiyaç duyar. GoFr, çeşitli veritabanlarıyla (PostgreSQL, MySQL, SQLite, MongoDB gibi) kolay entegrasyon sağlayarak bu süreci basitleştirir. Bu bölümde, GoFr kullanarak bir veritabanına nasıl bağlanacağımızı, veri modellerini nasıl tanımlayacağımızı ve temel CRUD (Create, Read, Update, Delete) operasyonlarını nasıl gerçekleştireceğimizi adım adım inceleyeceğiz. Basit bir “Görev Yönetimi” mikroservisi üzerinden bu kavramları pekiştireceğiz.

Veritabanı Seçimi ve Bağlantı

Bu örnek için popüler ve güçlü bir ilişkisel veritabanı olan PostgreSQL’i kullanacağız. GoFr, veritabanı bağlantılarını yapılandırma dosyaları üzerinden veya ortam değişkenleri aracılığıyla kolayca yönetmenizi sağlar. İlk olarak, projemizin kök dizininde bir config.dev.toml dosyası oluşturalım ve veritabanı bağlantı bilgilerini buraya ekleyelim:

# config.dev.toml
[DB]
HOST="localhost"
PORT="5432"
USER="postgres"
PASSWORD="mysecretpassword"
DBNAME="gofr_tasks"
SSLMODE="disable"
  

Bu yapılandırma, GoFr’ın veritabanı bağlantısını otomatik olarak kurmasını sağlayacaktır. Veritabanı bağlantısını test etmek için app/app.go dosyamızı güncelleyelim:

// app/app.go (güncellenmiş)
package app

import (
	"database/sql"
	"fmt"
	"github.com/gofr-dev/gofr"
	_ "github.com/lib/pq" // PostgreSQL sürücüsü
)

// Task veri modelimiz
type Task struct {
	ID          int    json:"id"
	Title       string json:"title"
	Description string json:"description"
	Completed   bool   json:"completed"
}

func New() *gofr.App {
	app := gofr.New()

	// Veritabanı bağlantısını kontrol ediyoruz
	app.GET("/db-check", func(c *gofr.Context) (interface{}, error) {
		_, err := c.DB.Query("SELECT 1")
		if err != nil {
			return nil, fmt.Errorf("veritabanı bağlantı hatası: %w", err)
		}
		return "Veritabanı bağlantısı başarılı!", nil
	})

	// ... diğer endpoint'ler buraya gelecek ...

	return app
}
  

_ "github.com/lib/pq" satırı, PostgreSQL sürücüsünü GoFr’ın veritabanı modülü tarafından kullanılmak üzere içe aktarır. app.GET("/db-check", ...) endpoint’i, veritabanı bağlantısının başarılı olup olmadığını kontrol eder.

Veri Modeli Tanımlama ve CRUD Operasyonları

Şimdi Task adında bir veri modeli tanımlayalım ve bu model üzerinde CRUD operasyonları gerçekleştiren API endpoint’leri oluşturalım. Task struct’ımız, JSON etiketleri (json:"id" gibi) sayesinde HTTP yanıtlarında ve isteklerinde kolayca serileştirilip serileştirilebilir.

// app/app.go (CRUD operasyonları eklenmiş)
package app

import (
	"database/sql"
	"fmt"
	"github.com/gofr-dev/gofr"
	_ "github.com/lib/pq"
)

type Task struct {
	ID          int    json:"id"
	Title       string json:"title"
	Description string json:"description"
	Completed   bool   json:"completed"
}

func New() *gofr.App {
	app := gofr.New()

	// İlk olarak, veritabanında görevler tablosunun var olduğundan emin olalım
	// Bu genellikle bir migration aracı ile yapılır, ancak basitlik için burada yapıyoruz.
	_, err := app.DB.Exec(CREATE TABLE IF NOT EXISTS tasks (
			id SERIAL PRIMARY KEY,
			title VARCHAR(255) NOT NULL,
			description TEXT,
			completed BOOLEAN DEFAULT FALSE
		);)
	if err != nil {
		app.Logger.Errorf("Veritabanı tablosu oluşturulurken hata oluştu: %v", err)
	}

	app.GET("/db-check", func(c *gofr.Context) (interface{}, error) {
		_, err := c.DB.Query("SELECT 1")
		if err != nil {
			return nil, fmt.Errorf("veritabanı bağlantı hatası: %w", err)
		}
		return "Veritabanı bağlantısı başarılı!", nil
	})

	// CREATE: Yeni bir görev oluşturma
	app.POST("/tasks", func(c *gofr.Context) (interface{}, error) {
		var task Task
		// İstek gövdesinden JSON verisini Task struct'ına bind ediyoruz
		if err := c.Bind(&task); err != nil {
			return nil, fmt.Errorf("istek gövdesi okunamadı: %w", err)
		}

		// Veritabanına yeni görev ekliyoruz
		err := c.DB.QueryRow(
			"INSERT INTO tasks (title, description, completed) VALUES ($1, $2, $3) RETURNING id",
			task.Title, task.Description, task.Completed,
		).Scan(&task.ID) // Oluşturulan görevin ID'sini geri alıyoruz
		if err != nil {
			return nil, fmt.Errorf("görev oluşturulurken hata oluştu: %w", err)
		}
		return task, nil
	})

	// READ: Tüm görevleri listeleme
	app.GET("/tasks", func(c *gofr.Context) (interface{}, error) {
		rows, err := c.DB.Query("SELECT id, title, description, completed FROM tasks")
		if err != nil {
			return nil, fmt.Errorf("görevler sorgulanırken hata oluştu: %w", err)
		}
		defer rows.Close()

		var tasks []Task
		for rows.Next() {
			var task Task
			if err := rows.Scan(&task.ID, &task.Title, &task.Description, &task.Completed); err != nil {
				return nil, fmt.Errorf("görev verisi okunurken hata oluştu: %w", err)
			}
			tasks = append(tasks, task)
		}
		return tasks, nil
	})

	// READ: Belirli bir görevi ID ile getirme
	app.GET("/tasks/{id}", func(c *gofr.Context) (interface{}, error) {
		id := c.Param("id") // URL'den ID parametresini alıyoruz

		var task Task
		err := c.DB.QueryRow(
			"SELECT id, title, description, completed FROM tasks WHERE id = $1",
			id,
		).Scan(&task.ID, &task.Title, &task.Description, &task.Completed)

		if err == sql.ErrNoRows {
			return nil, fmt.Errorf("ID %s ile görev bulunamadı", id)
		}
		if err != nil {
			return nil, fmt.Errorf("görev sorgulanırken hata oluştu: %w", err)
		}
		return task, nil
	})

	// UPDATE: Bir görevi güncelleme
	app.PUT("/tasks/{id}", func(c *gofr.Context) (interface{}, error) {
		id := c.Param("id")
		var task Task
		if err := c.Bind(&task); err != nil {
			return nil, fmt.Errorf("istek gövdesi okunamadı: %w", err)
		}

		result, err := c.DB.Exec(
			"UPDATE tasks SET title = $1, description = $2, completed = $3 WHERE id = $4",
			task.Title, task.Description, task.Completed, id,
		)
		if err != nil {
			return nil, fmt.Errorf("görev güncellenirken hata oluştu: %w", err)
		}

		rowsAffected, _ := result.RowsAffected()
		if rowsAffected == 0 {
			return nil, fmt.Errorf("ID %s ile güncellenecek görev bulunamadı", id)
		}
		return "Görev başarıyla güncellendi", nil
	})

	// DELETE: Bir görevi silme
	app.DELETE("/tasks/{id}", func(c *gofr.Context) (interface{}, error) {
		id := c.Param("id")

		result, err := c.DB.Exec("DELETE FROM tasks WHERE id = $1", id)
		if err != nil {
			return nil, fmt.Errorf("görev silinirken hata oluştu: %w", err)
		}

		rowsAffected, _ := result.RowsAffected()
		if rowsAffected == 0 {
			return nil, fmt.Errorf("ID %s ile silinecek görev bulunamadı", id)
		}
		return "Görev başarıyla silindi", nil
	})

	return app
}
  

Bu kod bloğunda, app/app.go dosyamıza bir Task modeli ve bu model üzerinde çalışan beş farklı API endpoint’i ekledik:

• POST /tasks: Yeni bir görev oluşturur. İstek gövdesinden JSON olarak title, description ve completed bilgilerini alır.
• GET /tasks: Tüm görevleri listeler.
• GET /tasks/{id}: Belirli bir ID’ye sahip görevi getirir.
• PUT /tasks/{id}: Belirli bir ID’ye sahip görevi günceller. İstek gövdesinden güncel bilgileri alır.
• DELETE /tasks/{id}: Belirli bir ID’ye sahip görevi siler.

Kodun başında, GoFr uygulamasının başlatılması sırasında tasks tablosunun varlığını kontrol eden ve yoksa oluşturan bir SQL sorgusu bulunmaktadır. Bu, geliştirme aşamasında hızlı başlangıç için kullanışlıdır, ancak üretim ortamlarında genellikle veritabanı migration (göç) araçları tercih edilir.

Test Etme

Uygulamayı çalıştırmadan önce, sisteminizde bir PostgreSQL sunucusu kurulu ve yapılandırılmış olmalıdır. Ayrıca, gofr_tasks adında bir veritabanı oluşturduğunuzdan ve config.dev.toml dosyasındaki kullanıcı adı/şifre ile erişebildiğinizden emin olun.

Uygulamayı tekrar go run main.go ile çalıştırın. Şimdi cURL veya Postman gibi bir araç kullanarak API’yi test edebilirsiniz:

1. Veritabanı Bağlantısını Kontrol Etme:

   
   curl http://localhost:8000/db-check
             

   Beklenen Yanıt: "Veritabanı bağlantısı başarılı!"

2. Yeni Görev Oluşturma (POST):

   
   curl -X POST -H "Content-Type: application/json" -d '{"title": "GoFr Öğren", "description": "GoFr framework'ünü detaylı incele", "completed": false}' http://localhost:8000/tasks
             

   Beklenen Yanıt: Oluşturulan görevin ID’sini içeren JSON.

3. Tüm Görevleri Listeleme (GET):

   
   curl http://localhost:8000/tasks
             

   Beklenen Yanıt: Oluşturduğunuz görevleri içeren bir JSON dizisi.

4. Belirli Bir Görevi Getirme (GET): (ID’yi yukarıdaki POST yanıtından alın)

   
   curl http://localhost:8000/tasks/1
             

   Beklenen Yanıt: ID’si 1 olan görevin JSON’ı.

5. Görevi Güncelleme (PUT):

   
   curl -X PUT -H "Content-Type: application/json" -d '{"title": "GoFr Öğren", "description": "GoFr framework'ünü detaylı incele ve kullan", "completed": true}' http://localhost:8000/tasks/1
             

   Beklenen Yanıt: "Görev başarıyla güncellendi".

6. Görevi Silme (DELETE):

   
   curl -X DELETE http://localhost:8000/tasks/1
             

   Beklenen Yanıt: "Görev başarıyla silindi".

Bu bölümle birlikte, GoFr ile sadece basit bir API oluşturmakla kalmadık, aynı zamanda bir veritabanı ile entegrasyon kurarak kalıcı veri yönetimi sağlayan gerçek dünya senaryolarına bir adım atmış olduk. GoFr’ın sunduğu kolaylıklar sayesinde, veritabanı operasyonlarını API endpoint’lerine bağlamak oldukça basittir.

Güvenlik, Sağlamlık ve Servisler Arası İletişim: Middleware’ler ve Hata Yönetimi

Bir mikroservisin sadece iş mantığını doğru bir şekilde yerine getirmesi yeterli değildir; aynı zamanda güvenli, sağlam ve diğer servislerle etkileşim kurabilen bir yapıya sahip olması gerekir. GoFr, bu ihtiyaçları karşılamak için middleware (ara katman yazılımı) desteği ve gelişmiş hata yönetimi mekanizmaları sunar. Ayrıca, farklı mikroservislerin birbirleriyle nasıl iletişim kurduğunu da inceleyeceğiz.

Middleware’ler: İstek İşleme Zincirini Güçlendirme

Middleware’ler, bir HTTP isteği ana işleyici (handler) fonksiyona ulaşmadan önce veya ulaştıktan sonra belirli işlemlerin yapılmasını sağlayan fonksiyonlardır. Bu sayede, yetkilendirme, kimlik doğrulama, loglama, CORS (Cross-Origin Resource Sharing) başlıkları ekleme, sıkıştırma veya istek/yanıt formatlama gibi tekrarlayan görevleri merkezi bir yerde yönetebilirsiniz. GoFr, esnek bir middleware yapısına sahiptir.

Örnek olarak, basit bir kimlik doğrulama (authentication) middleware’i oluşturalım. Bu middleware, her isteğin bir Authorization başlığı içerip içermediğini kontrol edecek ve geçerli bir token (basit bir string kontrolü yapacağız) içermiyorsa isteği reddedecektir.

// app/app.go (Middleware ve hata yönetimi eklenmiş)
package app

import (
	"database/sql"
	"fmt"
	"github.com/gofr-dev/gofr"
	_ "github.com/lib/pq"
	"net/http"
)

// ... Task struct'ı ve diğer import'lar aynı kalacak ...

// AuthMiddleware: Basit bir kimlik doğrulama middleware'i
func AuthMiddleware(h gofr.Handler) gofr.Handler {
	return func(c *gofr.Context) (interface{}, error) {
		authToken := c.Request.Header.Get("Authorization")

		// Basit bir token kontrolü yapalım
		if authToken != "Bearer supersecrettoken" {
			// Hata döndürürken GoFr'ın hata yapısını kullanabiliriz
			return nil, gofr.NewError("Yetkilendirme hatası: Geçersiz token", http.StatusUnauthorized)
		}
		return h(c) // Token geçerliyse isteği bir sonraki işleyiciye aktar
	}
}

func New() *gofr.App {
	app := gofr.New()

	// ... (tablo oluşturma kodu aynı kalacak) ...

	// Global bir middleware ekleyelim (tüm endpoint'ler için geçerli)
	// app.Use(AuthMiddleware)

	// Sadece belirli bir endpoint için middleware ekleyelim
	app.GET("/protected-tasks", AuthMiddleware(func(c *gofr.Context) (interface{}, error) {
		// Bu endpoint sadece geçerli token ile erişilebilir
		return "Bu gizli görevler listesidir!", nil
	}))

	// ... (diğer CRUD endpoint'leri aynı kalacak, ancak isterseniz onlara da AuthMiddleware ekleyebilirsiniz) ...

	return app
}
  

Yukarıdaki örnekte AuthMiddleware fonksiyonu, bir gofr.Handler alıp başka bir gofr.Handler döndürür. Bu, GoFr’ın middleware zincirini oluşturma şeklidir. Middleware’i tüm uygulamaya uygulamak için app.Use(AuthMiddleware) kullanabilir veya belirli bir endpoint’e uygulamak için app.GET("/path", AuthMiddleware(handlerFunc)) şeklinde kullanabiliriz.

Şimdi /protected-tasks endpoint’ini test edelim:

• Yetkilendirme olmadan:

  
  curl http://localhost:8000/protected-tasks
            

  Beklenen Yanıt: {"error":"Yetkilendirme hatası: Geçersiz token"} ve HTTP 401 Unauthorized durumu.

• Geçerli token ile:

  
  curl -H "Authorization: Bearer supersecrettoken" http://localhost:8000/protected-tasks
            

  Beklenen Yanıt: "Bu gizli görevler listesidir!".

Hata Yönetimi: Sağlam Servisler İçin Kritik

Her uygulamanın hataları düzgün bir şekilde yönetmesi gerekir. GoFr, hataları standart bir şekilde döndürmenizi ve istemcilere anlamlı hata mesajları ile HTTP durum kodları göndermenizi sağlar. Yukarıdaki middleware örneğinde gofr.NewError("Mesaj", http.StatusUnauthorized) kullanımını gördük. Bu, GoFr’ın hata işleme mekanizmasına entegre olmanın bir yoludur. Kendi özel hata tiplerinizi tanımlayabilir ve GoFr’ın bunları nasıl işleyeceğini yapılandırabilirsiniz.

Örneğin, veritabanı bağlantısı koptuğunda veya bir kayıt bulunamadığında oluşan hataları daha anlaşılır hale getirmek için GoFr’ın hata yönetimi oldukça etkilidir. GoFr, varsayılan olarak dahili hatalar için HTTP 500, bulunamayan kaynaklar için HTTP 404 gibi uygun durum kodlarını döndürür. Bu, API tüketicileri için tutarlı bir deneyim sağlar.

Servisler Arası İletişim: Mikroservislerin Kalbi

Mikroservis mimarisinin temel taşlarından biri, farklı servislerin birbirleriyle iletişim kurabilmesidir. Genellikle bu iletişim HTTP REST API’leri aracılığıyla veya daha performanslı senaryolarda gRPC gibi protokollerle sağlanır. Mesaj kuyrukları (Kafka, RabbitMQ) da eşzamansız iletişim için kullanılır.

GoFr ile başka bir mikroservisle iletişim kurmak oldukça basittir. Go’nun standart net/http kütüphanesini kullanarak bir HTTP istemcisi (client) oluşturabilir ve diğer servisin API’sine istek gönderebilirsiniz. Örneğin, bir “Kullanıcı Servisi” ile “Görev Servisi” arasındaki iletişimi düşünelim:

// app/app.go (Başka bir servise HTTP isteği gönderme örneği)

// ... (mevcut kodlar) ...

func New() *gofr.App {
	app := gofr.New()

	// ... (tablo oluşturma, db-check, tasks CRUD endpoint'leri, protected-tasks endpoint'i aynı kalacak) ...

	// Başka bir servisten kullanıcı bilgisi alma endpoint'i
	app.GET("/users/{id}", func(c *gofr.Context) (interface{}, error) {
		userID := c.Param("id")
		
		// Varsayımsal bir Kullanıcı Servisi'ne istek gönderiyoruz
		// Gerçek bir senaryoda bu URL bir yapılandırma değişkeninden gelmelidir.
		userAPIURL := fmt.Sprintf("http://localhost:8001/api/users/%s", userID) 

		resp, err := http.Get(userAPIURL)
		if err != nil {
			return nil, fmt.Errorf("kullanıcı servisine bağlanılamadı: %w", err)
		}
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusOK {
			return nil, fmt.Errorf("kullanıcı servisi hata döndürdü: %s", resp.Status)
		}

		var userData interface{} // Kullanıcı verisini dinamik olarak alalım
		if err := json.NewDecoder(resp.Body).Decode(&userData); err != nil {
			return nil, fmt.Errorf("kullanıcı verisi çözümlenirken hata oluştu: %w", err)
		}

		return userData, nil
	})

	return app
}
  

Bu örnekte, /users/{id} endpoint’i, varsayımsal bir “Kullanıcı Servisi”nin http://localhost:8001/api/users/{id} adresine HTTP GET isteği gönderir ve yanıtı işler. GoFr’ın Context nesnesi, istekleri ve yanıtları kolayca yönetmenizi sağlarken, Go’nun standart kütüphanesi servisler arası iletişimi sağlamak için yeterli gücü sunar.

Güvenlik ve sağlamlık, mikroservislerin uzun ömürlü olması için temel unsurlardır. GoFr’ın middleware ve hata yönetimi özellikleri, bu alanlarda güçlü bir temel oluştururken, Go’nun yerleşik HTTP istemcisi diğer servislerle sorunsuz bir şekilde entegrasyon kurmanızı sağlar. Bu sayede, karmaşık ve dağıtık sistemleri daha güvenilir ve yönetilebilir bir şekilde inşa edebilirsiniz.

Ölçeklenebilirlik, İzleme ve Dağıtım Stratejileri

Bir mikroservis uygulaması geliştirmek sadece kodu yazmakla bitmez; aynı zamanda uygulamanın nasıl dağıtılacağı, performansının nasıl izleneceği ve gerektiğinde nasıl ölçekleneceği de büyük önem taşır. GoFr ile geliştirilen mikroservisler, Go’nun doğal avantajları sayesinde bu alanlarda güçlü bir temel sunar. Bu bölümde, GoFr uygulamalarınızı ölçeklendirme, izleme ve dağıtım için yaygın olarak kullanılan stratejilere ve araçlara göz atacağız.

Ölçeklenebilirlik: Yatay Ölçekleme ve Go

Go ile yazılmış mikroservisler, düşük bellek ayak izi ve yüksek eşzamanlılık kapasiteleri sayesinde doğal olarak ölçeklenebilirdir. “Yatay ölçekleme” (horizontal scaling), uygulamanızın daha fazla isteği işleyebilmesi için aynı servisin birden fazla kopyasını (instance) çalıştırmak anlamına gelir. Go uygulamaları, bu tür bir ölçeklendirme için mükemmel adaylardır çünkü her bir Go servisi, genellikle tek bir çalıştırılabilir dosya olarak dağıtılabilir ve minimum kaynak tüketir.

GoFr’ın stateless (durumsuz) yapısı da yatay ölçeklemeyi kolaylaştırır. Bir servisin herhangi bir kopyası, gelen isteği işleyebilmeli ve daha önceki bir kopyanın durumuna bağımlı olmamalıdır. Bu, yük dengeleyicilerin (load balancer) gelen istekleri mevcut herhangi bir servis kopyasına yönlendirmesini sağlar, böylece iş yükü eşit şekilde dağıtılır ve uygulamanızın performansı artar.

İzleme (Monitoring) ve Loglama (Logging)

Dağıtık sistemlerde, uygulamalarınızın ne yaptığını, nerede performans sorunları yaşadığını veya hangi hataların oluştuğunu anlamak hayati önem taşır. Bu nedenle, kapsamlı izleme ve loglama stratejileri geliştirmek gerekir.

• Loglama: GoFr, yerleşik bir loglama mekanizmasına sahiptir (app.Logger). Bu logger, farklı seviyelerde (Info, Warn, Error, Debug) log mesajları üretmenizi sağlar. Üretim ortamlarında, bu logları merkezi bir log toplama sistemine (örneğin, ELK Stack – Elasticsearch, Logstash, Kibana veya Grafana Loki) göndermek yaygın bir yaklaşımdır. Bu sayede, tüm servislerinizin loglarını tek bir yerden inceleyebilir, hata ayıklama süreçlerini hızlandırabilirsiniz.
• Metrikler ve İzleme: Uygulamanızın performansını (istek sayısı, yanıt süreleri, hata oranları, CPU/bellek kullanımı) izlemek için metrikler toplamak gerekir. Prometheus, bu alanda endüstri standardı haline gelmiş açık kaynaklı bir izleme sistemidir. Go uygulamaları, Prometheus metriklerini kolayca dışa aktarabilir. Grafana ise, Prometheus’tan toplanan metrikleri görselleştirmek için kullanılan güçlü bir gösterge paneli (dashboard) aracıdır. GoFr, Prometheus entegrasyonu için gerekli altyapıyı sağlayarak, servislerinizin metriklerini kolayca açığa çıkarmanıza olanak tanır.

Dağıtım Stratejileri: Docker ve Kubernetes

Mikroservislerin dağıtımı, karmaşık bir süreç olabilir. Ancak Docker ve Kubernetes gibi araçlar, bu süreci büyük ölçüde basitleştirir ve standartlaştırır.

• Docker ile Konteynerizasyon: Docker, uygulamanızı ve tüm bağımlılıklarını izole edilmiş bir ortamda (konteyner) paketlemenizi sağlar. Go’nun statik olarak derlenmiş tek bir çalıştırılabilir dosya üretme yeteneği, Docker imajlarını (image) son derece küçük ve verimli hale getirir. Bir GoFr uygulamasını Dockerize etmek için basit bir Dockerfile yeterlidir:

  
  # Dockerfile
  # Derleme aşaması
  FROM golang:1.22-alpine AS builder
  WORKDIR /app
  COPY go.mod go.sum ./
  RUN go mod download
  COPY . .
  RUN go build -o /app/main main.go
  
  # Çalıştırma aşaması
  FROM alpine:latest
  WORKDIR /app
  COPY --from=builder /app/main .
  COPY config.dev.toml . # Yapılandırma dosyasını da kopyalayalım
  EXPOSE 8000
  CMD ["/app/main"]
            

  Bu Dockerfile, çok aşamalı bir derleme (multi-stage build) kullanarak nihai imaj boyutunu minimumda tutar. İlk aşamada Go uygulaması derlenir, ikinci aşamada ise sadece derlenmiş çalıştırılabilir dosya ve yapılandırma dosyası minimalist bir Alpine Linux imajına kopyalanır.

• Kubernetes ile Orkestrasyon: Docker konteynerleri oluşturduktan sonra, bu konteynerleri büyük ölçekte yönetmek ve orkestrasyonunu sağlamak için Kubernetes devreye girer. Kubernetes, konteynerli uygulamaları otomatik olarak dağıtmak, ölçeklendirmek, yönetmek ve iyileştirmek için bir platformdur. Bir GoFr mikroservisini Kubernetes’e dağıtmak için, genellikle Deployment, Service ve Ingress gibi Kubernetes kaynaklarını tanımlayan YAML dosyaları kullanılır. Kubernetes, servislerinizin yüksek erişilebilirlik (high availability) ile çalışmasını sağlar, otomatik olarak yeniden başlatır ve yük dengeleme yapar.

Bu stratejiler ve araçlar, GoFr ile geliştirilen mikroservislerinizin sadece hızlı ve verimli olmasını sağlamakla kalmaz, aynı zamanda üretim ortamında güvenilir bir şekilde çalışmasını ve kolayca yönetilmesini de temin eder. Go’nun basitliği ve performansı, bu modern dağıtım ve izleme yaklaşımlarıyla birleştiğinde, geliştiricilere güçlü bir mikroservis ekosistemi kurma imkanı sunar.

Sonuç ve Sıkça Sorulan Sorular

Bu makale boyunca, mikroservis mimarisinin temel prensiplerinden, Go programlama dilinin bu mimari için neden ideal bir seçim olduğundan ve GoFr framework’ünün mikroservis geliştirme sürecini nasıl basitleştirdiğinden bahsettik. İlk “Hello World” mikroservisimizi oluşturmaktan, veritabanı entegrasyonu ve CRUD operasyonlarına, güvenlik için middleware kullanımına ve nihayetinde ölçeklenebilirlik, izleme ve dağıtım stratejilerine kadar geniş bir yelpazede konuları ele aldık.

GoFr, Go’nun eşzamanlılık, performans ve basitlik gibi güçlü özelliklerini alarak, geliştiricilere hızlı ve verimli mikroservisler oluşturmak için kapsamlı bir araç seti sunar. Yapılandırma yönetimi, HTTP yönlendirme, hata işleme ve bağımlılık enjeksiyonu gibi temel bileşenleri kutudan çıkar çıkmaz sunması, geliştiricilerin tekrarlayan görevler yerine iş mantığına odaklanmasına olanak tanır. Bu sayede, daha az kodla daha fazla iş yapabilir, uygulamalarınızı daha hızlı pazara sunabilir ve bakım maliyetlerini düşürebilirsiniz.

Mikroservis mimarisi, büyük ve karmaşık sistemlerin geliştirilmesi ve yönetilmesi için güçlü bir yaklaşım sunar. Go ve GoFr ikilisi ise, bu mimarinin sunduğu faydaları en üst düzeye çıkarmak için mükemmel bir kombinasyondur. Ölçeklenebilir, dayanıklı ve bakımı kolay mikroservisler inşa etmek isteyen her geliştirici için GoFr, kesinlikle değerlendirilmesi gereken bir framework’tür. Gelecekte, GoFr’ın topluluk desteğiyle daha da gelişmesi ve yeni entegrasyonlarla zenginleşmesi beklenmektedir. Bu rehber, GoFr ile mikroservis dünyasına adım atmanız için sağlam bir başlangıç noktası sunmayı amaçlamaktadır. Şimdi öğrendiklerinizi kendi projelerinizde uygulama zamanı!

Sıkça Sorulan Sorular

1. GoFr diğer Go web framework’lerinden (Gin, Echo vb.) farkı nedir?

GoFr, sadece bir web framework’ü olmanın ötesine geçerek, mikroservislerin tüm yaşam döngüsü için daha kapsamlı bir çözüm sunar. Gin veya Echo gibi framework’ler genellikle HTTP yönlendirme ve istek/yanıt işleme katmanına odaklanırken, GoFr; yapılandırma yönetimi, bağımlılık enjeksiyonu, loglama, hata yönetimi ve veritabanı entegrasyonu gibi mikroservislerin temel ihtiyaçlarını tek bir çatı altında birleştirir. Bu sayede, geliştiricilerin farklı kütüphaneleri manuel olarak entegre etme yükünü azaltır ve daha tutarlı bir geliştirme deneyimi sağlar.

2. GoFr’ı üretim ortamında kullanmak güvenli midir?

Evet, GoFr aktif olarak geliştirilen ve kullanılan bir framework’tür. Güvenilir Go standart kütüphaneleri ve kanıtlanmış tasarım desenleri üzerine inşa edilmiştir. Ancak her framework’te olduğu gibi, uygulamanızın güvenliği büyük ölçüde sizin kodlama pratiklerinize, bağımlılıklarınızı güncel tutmanıza ve güvenlik açıklarını düzenli olarak kontrol etmenize bağlıdır. GoFr, güvenli bir temel sunar, ancak uygulamanızın özel güvenlik ihtiyaçları için ek önlemler almanız gerekebilir (örneğin, daha gelişmiş kimlik doğrulama/yetkilendirme çözümleri, veri şifreleme vb.).

3. GoFr ile gRPC servisleri oluşturabilir miyim?

GoFr, öncelikli olarak HTTP/REST API’leri için tasarlanmış olsa da, Go’nun standart kütüphanesini kullanarak gRPC servisleri oluşturmanıza engel değildir. GoFr uygulamanızın yanında ayrı bir gRPC sunucusu çalıştırabilir ve bu iki servisi birlikte yönetebilirsiniz. GoFr’ın bağımlılık enjeksiyonu veya yapılandırma yönetimi gibi özelliklerini gRPC servisinizde de kullanmak isterseniz, bu bileşenleri GoFr’ın gofr.App nesnesinden alarak gRPC servisinizde de değerlendirebilirsiniz.

4. GoFr’da veritabanı migration (göç) yönetimi nasıl yapılır?

GoFr, kutudan çıkar çıkmaz yerleşik bir veritabanı migration aracı sunmaz. Ancak, Go ekosisteminde popüler olan golang-migrate/migrate veya pressly/goose gibi üçüncü taraf kütüphaneleri GoFr projenize kolayca entegre edebilirsiniz. Bu araçlar, veritabanı şemanızdaki değişiklikleri (tablo oluşturma, sütun ekleme vb.) sürüm kontrolü altında tutmanızı ve üretim ortamlarına güvenli bir şekilde uygulamanızı sağlar. Genellikle, uygulamanızın başlatılmasından önce migration’ları çalıştıran ayrı bir komut veya betik oluşturulur.

5. GoFr’ın performans açısından avantajları nelerdir?

GoFr, Go dilinin doğal performans avantajlarını devralır. Go, derlenmiş bir dil olduğu için yorumlanan dillere göre çok daha hızlı çalışır. Ayrıca, Go’nun goroutine’leri ve channel’ları sayesinde yüksek eşzamanlılık (concurrency) kapasitesine sahiptir, bu da GoFr servislerinin aynı anda binlerce isteği verimli bir şekilde işleyebilmesini sağlar. GoFr’ın kendisi de hafif ve minimalist bir tasarıma sahip olduğu için, gereksiz yük bindirmez ve uygulamanızın performansını olumsuz etkilemez. Bu özellikler, GoFr’ı yüksek performans gerektiren mikroservisler için ideal bir seçenek haline getirir.

#GoFr #GoLang #Mikroservis #WebGeliştirme #API #Teknoloji