SQL Server Desteği Ekleme: Çoklu Veritabanı Kurulumu Nasıl Yapılır?

Modern uygulamalar, değişen iş yüklerine ve ölçeklenebilirlik ihtiyaçlarına uyum sağlamak zorundadır. Peki, uygulamanızın farklı veritabanı sistemlerini, özellikle de SQL Server’ı desteklemesi gerektiğinde nasıl bir yol izlemelisiniz? Bu makalede, .NET tabanlı bir uygulamaya SQL Server desteğini nasıl ekleyeceğinizi ve çoklu veritabanı ortamını adım adım nasıl kuracağınızı keşfedeceksiniz. Bu rehber, sizi sıfırdan alıp karmaşık çoklu veritabanı mimarilerine kadar götürecektir.

Günümüzün dinamik yazılım dünyasında, bir uygulamanın tek bir veritabanı sistemiyle sınırlı kalması nadiren optimal bir çözümdür. Çoklu veritabanı desteği, yani uygulamanızın farklı veritabanı yönetim sistemleriyle (DBMS) konuşabilme yeteneği, birçok kritik avantaj sunar. Her şeyden önce, ölçeklenebilirlik ve performans açısından büyük bir esneklik sağlar. Örneğin, bir mikroservis mimarisinde, her servis kendi özelleştirilmiş veritabanı tipini kullanabilir. Bir servis kullanıcı bilgilerini depolamak için PostgreSQL tercih ederken, diğeri analitik veriler için bir NoSQL çözümü (örneğin MongoDB) veya kritik iş verileri için SQL Server kullanabilir. Bu yaklaşım, her servisin kendi veri depolama ihtiyacına en uygun teknolojiyi seçmesine olanak tanır ve böylece genel sistem performansını artırır. Böylece, uygulamanızın yükü dengeli bir şekilde dağıtılarak daha iyi bir kullanıcı deneyimi sunulabilir.

İkinci önemli bir faktör, vendor lock-in’den kaçınmaktır. Yani, belirli bir veritabanı sağlayıcısına tamamen bağımlı kalmamak. Eğer uygulamanız yalnızca tek bir veritabanı tipiyle çalışabiliyorsa, ileride daha iyi bir alternatif ortaya çıktığında veya mevcut sağlayıcının maliyetleri yükseldiğinde geçiş yapmak son derece zorlu ve maliyetli olabilir. Çoklu veritabanı desteği, bu riski azaltarak size teknoloji seçimi konusunda daha fazla özgürlük tanır ve maliyet optimizasyonu sağlar. Ayrıca, farklı müşterilerin veya projelerin farklı veritabanı tercihleri olabilir. Bir müşteriniz Oracle kullanırken, diğeri SQL Server’ı zorunlu tutabilir. Uygulamanızın bu farklı ihtiyaçlara cevap verebilmesi, pazar erişiminizi ve müşteri memnuniyetinizi artırır. Bu durum, özellikle danışmanlık veya SaaS (Software as a Service) firmaları için büyük önem taşır.

Üçüncü olarak, felaket kurtarma ve yüksek erişilebilirlik (High Availability) senaryolarında çoklu veritabanı stratejileri hayati rol oynar. Birincil veritabanı sisteminizde bir sorun yaşandığında, uygulamanızın otomatik olarak ikincil bir veritabanı sistemine (belki farklı bir coğrafi bölgede veya farklı bir sağlayıcıda) geçiş yapabilmesi, hizmet kesintilerini en aza indirir. Bu, özellikle finans, sağlık veya e-ticaret gibi kesintisiz hizmetin kritik olduğu sektörlerde vazgeçilmezdir. Bu tür bir mimari, iş sürekliliğini sağlamak adına stratejik bir yatırımdır. Son olarak, uyumluluk ve mevzuatlar da çoklu veritabanı kullanımını tetikleyebilir. Bazı sektörler veya ülkeler, verilerin belirli bir coğrafyada veya belirli bir tipteki veritabanında saklanmasını gerektirebilir (örneğin, GDPR uyumluluğu). Uygulamanızın bu gereksinimlere uyum sağlayabilmesi için birden fazla veritabanı teknolojisini desteklemesi gerekebilir.

Özetle, çoklu veritabanı desteği, modern, esnek, ölçeklenebilir ve geleceğe yönelik uygulamalar geliştirmek isteyen her yazılımcının ve mimarın göz önünde bulundurması gereken kritik bir mimari karardır. Bu yaklaşım, sadece mevcut ihtiyaçları karşılamakla kalmaz, aynı zamanda gelecekteki değişikliklere ve bilinmeyen gereksinimlere karşı uygulamanızı daha dirençli hale getirir, böylece uzun vadede yatırımınızın değerini korur.

Temel Kavramlar: Çoklu Veritabanı Mimarisi Nedir?

Çoklu veritabanı mimarisi, bir yazılım uygulamasının aynı anda veya duruma göre birden fazla farklı veritabanı yönetim sistemiyle (DBMS) etkileşim kurabilme yeteneğini ifade eder. Bu, SQL Server, PostgreSQL, MySQL, Oracle gibi ilişkisel veritabanlarını veya MongoDB, Cassandra gibi NoSQL veritabanlarını içerebilir. Bu mimarinin temelinde, veritabanı erişim katmanının soyutlanması ve genellikle bir Nesne İlişkisel Eşleyici (ORM) kullanılması yatar. Bu soyutlama, geliştiricinin veritabanı detaylarıyla doğrudan uğraşmasını en aza indirir.

Nesne İlişkisel Eşleyici (ORM): En popüler ORM’lerden biri olan Entity Framework Core (EF Core), .NET uygulamalarında veritabanı işlemlerini nesne tabanlı bir yaklaşımla kolaylaştırır. EF Core, geliştiricilerin SQL sorguları yazmak yerine C# nesneleriyle çalışmasına olanak tanır. Bu sayede, geliştirme süreci hızlanır ve kodun okunabilirliği artar. EF Core’un gücü, farklı veritabanı sağlayıcıları (SQL Server, PostgreSQL, MySQL vb.) için adaptörler sunmasıdır. Bu adaptörler sayesinde, aynı C# kodunu kullanarak farklı veritabanı türlerine bağlanabilir ve işlemlerinizi gerçekleştirebilirsiniz. Bu, kodunuzun veritabanı tipi konusunda agnostik olmasını sağlar, yani bir veritabanından diğerine geçiş yapmak, çoğunlukla sadece yapılandırma değişiklikleriyle mümkün olur.

Bağlantı Dizeleri (Connection Strings): Her veritabanı için bir bağlantı dizesi gereklidir. Bu dizeler, uygulamanızın veritabanına nasıl bağlanacağını (sunucu adresi, veritabanı adı, kimlik bilgileri, port numarası vb.) belirtir. Çoklu veritabanı kurulumlarında, her veritabanı için ayrı ve benzersiz bağlantı dizeleri tanımlanmalıdır. Bu dizeler genellikle uygulamanın yapılandırma dosyalarında (örneğin, appsettings.json) saklanır ve çalışma zamanında okunarak ilgili veritabanı bağlantıları kurulur. Güvenlik nedenleriyle, üretim ortamlarında bu dizelerin ortam değişkenleri veya güvenli anahtar yönetim sistemleri (örneğin Azure Key Vault, HashiCorp Vault) aracılığıyla sağlanması şiddetle tavsiye edilir. Bu yaklaşım, hassas verilerin kaynak kodda yer almasını engeller.

Dependency Injection (Bağımlılık Enjeksiyonu – DI): .NET Core’un merkezi bir özelliği olan DI, uygulamanın esnekliğini ve test edilebilirliğini artırır. Çoklu veritabanı senaryosunda, farklı DbContext nesneleri (her veritabanı için bir tane) DI konteynerine kaydedilir. Uygulamanın farklı katmanları, hangi veritabanına erişmeleri gerekiyorsa, ilgili DbContext‘i bağımlılık olarak talep eder. Bu, iş mantığının belirli bir veritabanı uygulamasına sıkı sıkıya bağlı kalmamasını sağlar. Örneğin, bir kullanıcının profil bilgilerini yöneten servis, kullanıcı veritabanının DbContext‘ini enjekte ederken, ürün kataloğunu yöneten servis ürün veritabanının DbContext‘ini enjekte edecektir. Böylece, her modül kendi verisine odaklanabilir.

Mimari Yaklaşımlar: Çoklu veritabanı kullanımında farklı yaklaşımlar mevcuttur. Bunlar genellikle uygulama karmaşıklığına ve ihtiyaçlarına göre seçilir:

• Tek DbContext, Çoklu Sağlayıcı (Nadiren): Teorik olarak mümkün olsa da, tek bir DbContext‘in dinamik olarak farklı veritabanı sağlayıcılarını kullanması karmaşıklığı artırır ve genellikle tercih edilmez. Genellikle aynı DbContext tipi, farklı ortamlar için farklı sağlayıcılarla (SQL Server test ortamında, PostgreSQL üretimde gibi) yapılandırılır. Bu durum daha çok ortam geçişleri için uygundur.
• Çoklu DbContext, Aynı Sağlayıcı: Uygulama içinde birden fazla bağımsız veritabanı (örneğin, kullanıcılar için bir SQL Server VT, siparişler için başka bir SQL Server VT) gerektiğinde bu yaklaşım kullanılır. Her veritabanı için ayrı bir DbContext sınıfı tanımlanır ve bunlar DI konteynerine kaydedilir. Bu, aynı teknoloji yığını içinde veri ayrıştırması sağlar.
• Çoklu DbContext, Farklı Sağlayıcılar: En esnek ve karmaşık senaryo budur. Her veritabanı tipi (SQL Server, PostgreSQL) için ayrı bir DbContext sınıfı tanımlanır ve her biri kendi özel sağlayıcı paketiyle yapılandırılır. Bu, bir mikroservis mimarisinde sıkça görülür ve servislerin en uygun veritabanı çözümünü seçmelerine olanak tanır.

Bu temel kavramları anlamak, çoklu veritabanı mimarisini başarıyla uygulamanın ilk adımıdır. Sonraki bölümlerde, bu kavramları kullanarak .NET uygulamanıza SQL Server desteğini nasıl entegre edeceğimizi ve çoklu veritabanı kurulumunu adım adım nasıl gerçekleştireceğimizi göreceğiz. Bu sayede, güçlü ve esnek bir altyapı inşa edebilirsiniz.

.NET Uygulamanıza SQL Server Desteği Nasıl Eklenir? Adım Adım Rehber

Bir .NET Core uygulamasını SQL Server ile konuşturmak, Entity Framework Core sayesinde oldukça basittir. Bu bölümde, mevcut veya yeni bir .NET uygulamanıza SQL Server desteğini nasıl entegre edeceğinizi adım adım inceleyeceğiz. Bu adımlar, uygulamanızın tek bir SQL Server veritabanıyla çalışmasını sağlarken, çoklu veritabanı kurulumu için de bir temel oluşturacaktır. Bu süreci dikkatli bir şekilde takip ederek hatasız bir entegrasyon sağlayabilirsiniz.

1. Gerekli NuGet Paketlerini Yükleyin

İlk adım, Entity Framework Core’un SQL Server sağlayıcısını projenize eklemektir. Bunu NuGet Paket Yöneticisi Konsolu (PMC) veya .NET CLI aracılığıyla yapabilirsiniz. Bu paketler, EF Core’un SQL Server ile iletişim kurmasını sağlayan temel bileşenlerdir.

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools
    

Microsoft.EntityFrameworkCore.SqlServer paketi, uygulamanızın SQL Server ile iletişim kurmasını sağlayan temel sağlayıcıdır. Microsoft.EntityFrameworkCore.Tools ise migrasyonlar (veritabanı şema değişiklikleri) ve diğer EF Core komutları için gereklidir. Bu araçlar, veritabanı şemanızı kodunuzla senkronize tutmanıza yardımcı olur.

2. Bağlantı Dizelerinizi Yapılandırın (appsettings.json)

Uygulamanızın SQL Server'a nasıl bağlanacağını bildirmesi gerekir. Bu bilgiyi genellikle appsettings.json dosyasına ekleriz. Tek bir veritabanı için aşağıdaki gibi bir yapılandırma yeterli olacaktır. Bağlantı dizeleri, uygulamanızın kalbi niteliğindedir.

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyDatabase;User Id=sa;Password=YourStrongPassword;TrustServerCertificate=True"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}
    

Burada DefaultConnection adında bir bağlantı dizesi tanımladık. Server, Database, User Id ve Password değerlerini kendi SQL Server kurulumunuza göre ayarlamalısınız. TrustServerCertificate=True, geliştirme ortamında genellikle kullanılan bir ayardır ve sertifika doğrulamasını atlar. Üretim ortamında gerçek sertifika doğrulamasını kullanmanız önerilir, bu daha güvenli bir yaklaşımdır.

3. DbContext Sınıfınızı Oluşturun veya Güncelleyin

Entity Framework Core'da, veritabanı ile etkileşim kurmak için bir DbContext sınıfı tanımlamanız gerekir. Bu sınıf, uygulamanızdaki model sınıflarınızı (entity'lerinizi) temsil eden DbSet özelliklerini içerir. Bu, veritabanındaki tablolarınızın C# karşılığıdır.

using Microsoft.EntityFrameworkCore;
using YourNamespace.Models; // Model sınıflarınızın bulunduğu namespace

namespace YourNamespace.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions options)
            : base(options)
        {
        }

        // Model sınıflarınız buraya DbSet olarak eklenecek
        public DbSet Products { get; set; }
        public DbSet Categories { get; set; }
        // ... diğer DbSet'ler
    }
}
    

Burada ApplicationDbContext adında bir sınıf oluşturduk ve constructor'ında DbContextOptions alacak şekilde yapılandırdık. Bu, DI konteynerinden yapılandırma bilgilerini almasını sağlar. Product ve Category sizin örnek model sınıflarınızdır. Her DbSet, veritabanındaki bir tabloyu temsil eder.

4. DbContext'i Dependency Injection'a Kaydedin

Uygulamanızın başlangıç sınıfı olan Program.cs (veya eski versiyonlarda Startup.cs) dosyasında, DbContext'inizi DI konteynerine kaydetmeniz gerekir. Bu, uygulamanızın herhangi bir yerinden ApplicationDbContext örneğine kolayca erişmenizi sağlar ve uygulamanın esnekliğini artırır.

// Program.cs
using Microsoft.EntityFrameworkCore;
using YourNamespace.Data;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// SQL Server DbContext'i Dependency Injection'a ekle
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext(options =>
    options.UseSqlServer(connectionString));

var app = builder.Build();

// ... Diğer yapılandırmalar

app.Run();
    

AddDbContext metodunu kullanarak ApplicationDbContext'i kaydediyoruz ve SQL Server sağlayıcısını (UseSqlServer) kullanarak hangi veritabanına bağlanacağını belirtiyoruz. Bağlantı dizesini builder.Configuration.GetConnectionString("DefaultConnection") ile appsettings.json dosyasından alıyoruz. Bu, uygulamanın dinamik olarak doğru bağlantıyı kurmasını sağlar.

5. Migrasyonları Oluşturun ve Uygulayın

Veritabanı şemasını oluşturmak veya güncellemek için Entity Framework Core migrasyonlarını kullanırız. Projenizin kök dizininde aşağıdaki komutları çalıştırın. Migrasyonlar, veritabanı şema değişikliklerini izlemenin ve uygulamanın etkili bir yoludur.

dotnet ef migrations add InitialCreate
dotnet ef database update
    

InitialCreate yerine migrasyonunuza anlamlı bir isim verebilirsiniz. İlk komut, model sınıflarınızdan bir migrasyon dosyası oluşturur. İkinci komut ise bu migrasyonu SQL Server veritabanınıza uygulayarak tabloları oluşturur veya günceller. Uygulamanızın başlangıcında migrasyonları otomatik olarak uygulamak için de kod ekleyebilirsiniz. Bu, özellikle geliştirme ve test ortamlarında kullanışlıdır, ancak dikkatli kullanılmalıdır.

// Program.cs içinde, app.Run() öncesinde
using (var scope = app.Services.CreateScope())
{
    var dbContext = scope.ServiceProvider.GetRequiredService();
    dbContext.Database.Migrate(); // Migrasyonları otomatik uygula
}
app.Run();
    

Bu adımları tamamladığınızda, .NET uygulamanız SQL Server ile başarılı bir şekilde iletişim kurabilir hale gelmiş olacaktır. Artık ApplicationDbContext'i kullanarak veri ekleyebilir, sorgulayabilir, güncelleyebilir ve silebilirsiniz. Bu, uygulamanızın temel veri operasyonlarını gerçekleştirmesi için gerekli altyapıyı sağlar.

Farklı Veritabanları İçin Ayrı DbContext'ler Nasıl Yönetilir?

Bir uygulamanın iş mantığı, farklı veri setlerini veya farklı iş domainlerini ayrı veritabanlarında saklamayı gerektirebilir. Örneğin, bir e-ticaret uygulamasında kullanıcı bilgileri bir veritabanında, ürün kataloğu başka bir veritabanında ve sipariş geçmişi üçüncü bir veritabanında saklanabilir. Bu senaryoda, her veritabanı için ayrı DbContext sınıfları tanımlamak en iyi yaklaşımdır. Bu, kodun daha düzenli olmasını, sorumlulukların ayrılmasını ve her veritabanı için bağımsız migrasyonlar yönetmenizi sağlar. Bu sayede, her iş alanı kendi veri depolama gereksinimlerine göre optimize edilebilir.

Vaka Analizi: Bir E-Ticaret Platformu İçin Çoklu Veritabanı Yönetimi

Hayali bir e-ticaret platformumuz olduğunu varsayalım. Bu platformun üç ana veri alanı var:

1. Kullanıcılar ve Kimlik Doğrulama: Kullanıcı hesapları, profiller ve güvenlik bilgileri.
2. Ürün Kataloğu: Ürün bilgileri, kategoriler, envanter.
3. Siparişler ve Ödeme İşlemleri: Sipariş geçmişi, ödeme kayıtları.

Bu verileri üç ayrı SQL Server veritabanında saklamak istiyoruz: AuthDb, CatalogDb ve OrderDb. Her biri için ayrı DbContext'ler tanımlayacağız. Bu ayrım, her bir alanın bağımsız olarak ölçeklenmesine ve yönetilmesine olanak tanır.

1. Ayrı DbContext Sınıfları Oluşturma

Her veritabanı domain'i için ayrı bir DbContext sınıfı tanımlayalım:

// AuthDb için
using Microsoft.EntityFrameworkCore;
using YourNamespace.Models.Auth;

namespace YourNamespace.Data.Auth
{
    public class AuthDbContext : DbContext
    {
        public AuthDbContext(DbContextOptions options) : base(options) { }
        public DbSet Users { get; set; }
        public DbSet Roles { get; set; }
    }
}

// CatalogDb için
using Microsoft.EntityFrameworkCore;
using YourNamespace.Models.Catalog;

namespace YourNamespace.Data.Catalog
{
    public class CatalogDbContext : DbContext
    {
        public CatalogDbContext(DbContextOptions options) : base(options) { }
        public DbSet Products { get; set; }
        public DbSet Categories { get; set; }
    }
}

// OrderDb için
using Microsoft.EntityFrameworkCore;
using YourNamespace.Models.Order;

namespace YourNamespace.Data.Order
{
    public class OrderDbContext : DbContext
    {
        public OrderDbContext(DbContextOptions options) : base(options) { }
        public DbSet Orders { get; set; }
        public DbSet OrderItems { get; set; }
    }
}
    

Gördüğünüz gibi, her DbContext kendi sorumluluk alanındaki entity'leri içeriyor. Bu, kod organizasyonunu büyük ölçüde iyileştirir ve her alanın bağımsız olarak gelişmesine olanak tanır.

2. appsettings.json Dosyasını Güncelleme

Her veritabanı için ayrı bir bağlantı dizesi eklememiz gerekiyor:

{
  "ConnectionStrings": {
    "AuthConnection": "Server=localhost;Database=AuthDb;User Id=sa;Password=YourStrongPassword;TrustServerCertificate=True",
    "CatalogConnection": "Server=localhost;Database=CatalogDb;User Id=sa;Password=YourStrongPassword;TrustServerCertificate=True",
    "OrderConnection": "Server=localhost;Database=OrderDb;User Id=sa;Password=YourStrongPassword;TrustServerCertificate=True"
  },
  // ... diğer ayarlar
}
    

Bu bağlantı dizeleri, uygulamanın her bir DbContext için doğru veritabanına bağlanmasını sağlar. Güvenlik için, bu bilgilerin üretim ortamında ortam değişkenleri veya Key Vault gibi güvenli depolama çözümleri aracılığıyla sağlanması gerektiğini unutmayın.

3. DbContext'leri Dependency Injection'a Kaydetme

Program.cs dosyasında, her DbContext'i kendi bağlantı dizesiyle DI konteynerine kaydetmeliyiz. Bu, uygulamanın farklı bölümlerinin ihtiyaç duydukları DbContext'i kolayca almasını sağlar.

// Program.cs
using Microsoft.EntityFrameworkCore;
using YourNamespace.Data.Auth;
using YourNamespace.Data.Catalog;
using YourNamespace.Data.Order;

var builder = WebApplication.CreateBuilder(args);

// AuthDbContext'i kaydet
builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("AuthConnection")));

// CatalogDbContext'i kaydet
builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("CatalogConnection")));

// OrderDbContext'i kaydet
builder.Services.AddDbContext(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("OrderConnection")));

// ... diğer servisler ve uygulama yapılandırması
    

Her DbContext için AddDbContext metodunu çağırmak, EF Core'un her bir veritabanıyla ayrı ayrı nasıl etkileşim kuracağını bilmesini sağlar. Bu yapılandırma, uygulamanızın modülerliğini ve yönetilebilirliğini artırır.

4. Migrasyonları Yönetme

Her DbContext için ayrı migrasyonlar yönetmeniz gerekecektir. .NET CLI komutlarını kullanırken, hedef DbContext'i belirtmeniz önemlidir. Bu, her veritabanının şemasını bağımsız olarak güncellemenizi sağlar.

# AuthDbContext için migrasyon oluşturma
dotnet ef migrations add InitialAuthMigration --context AuthDbContext --output-dir Data/Auth/Migrations

# CatalogDbContext için migrasyon oluşturma
dotnet ef migrations add InitialCatalogMigration --context CatalogDbContext --output-dir Data/Catalog/Migrations

# OrderDbContext için migrasyon oluşturma
dotnet ef migrations add InitialOrderMigration --context OrderDbContext --output-dir Data/Order/Migrations
    

Migrasyonları uygularken de aynı şekilde --context parametresini kullanmalısınız:

dotnet ef database update --context AuthDbContext
dotnet ef database update --context CatalogDbContext
dotnet ef database update --context OrderDbContext
    

Bu komutlar, her bir veritabanı için şema değişikliklerini ayrı ayrı yönetmenizi sağlar, böylece veritabanı bağımsızlığını korursunuz ve olası çakışmaları önlersiniz.

5. DbContext'leri Kullanma

Artık uygulamanızın herhangi bir yerinde, örneğin bir denetleyici (controller) veya servis içinde, ihtiyacınız olan DbContext'i bağımlılık olarak enjekte edebilirsiniz. Bu, iş mantığınızın belirli bir veriye erişim için doğru veritabanına yönlendirilmesini sağlar.

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using YourNamespace.Data.Auth;
using YourNamespace.Data.Catalog;
using YourNamespace.Models.Catalog; // Product modelinizin bulunduğu namespace

namespace YourNamespace.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class ProductController : ControllerBase
    {
        private readonly CatalogDbContext _catalogDbContext;
        private readonly AuthDbContext _authDbContext; // Eğer kullanıcı bilgisi de gerekiyorsa

        public ProductController(CatalogDbContext catalogDbContext, AuthDbContext authDbContext)
        {
            _catalogDbContext = catalogDbContext;
            _authDbContext = authDbContext;
        }

        [HttpGet]
        public async Task GetProducts()
        {
            var products = await _catalogDbContext.Products.ToListAsync();
            // ... belki _authDbContext.Users ile bazı kontroller yapılır
            return Ok(products);
        }
    }
}
    

Bu yaklaşım, uygulamanızın farklı modüllerinin kendi veritabanı sorumluluklarına sahip olmasını sağlar, böylece kod tabanı daha anlaşılır, bakımı daha kolay ve ölçeklenebilir hale gelir. Özellikle büyük ve karmaşık uygulamalarda veya mikroservis mimarilerinde bu tür bir ayrım büyük avantajlar sunar. Bu, temiz mimari prensiplerine de uygun bir yaklaşımdır.

Dinamik Bağlantı Dizileri ve Ortam Tabanlı Yapılandırma Nasıl Yapılır?

Bir uygulamanın farklı ortamlarda (geliştirme, test, hazırlık, üretim) çalışması gerektiğinde, veritabanı bağlantı dizelerinin de ortama göre değişmesi hayati önem taşır. Dinamik bağlantı dizeleri ve ortam tabanlı yapılandırma, bu esnekliği sağlar. Bu sayede, aynı kod tabanını kullanarak uygulamanızı farklı veritabanı ortamlarına zahmetsizce dağıtabilirsiniz. Bu, CI/CD süreçlerinde de büyük kolaylık sağlar.

1. Ortam Tabanlı appsettings Dosyaları

.NET Core, varsayılan olarak ortam değişkenlerine dayalı yapılandırma sağlar. appsettings.json dosyasının yanı sıra, ortama özel dosyalar oluşturabilirsiniz: örneğin, appsettings.Development.json, appsettings.Staging.json ve appsettings.Production.json. Bu dosyalar, appsettings.json'daki varsayılan değerleri geçersiz kılar ve böylece ortama özel ayarlar yapmanıza olanak tanır.

Örneğin, appsettings.json'da varsayılan bir bağlantı dizesi varken:

// appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=DevDb;User Id=sa;Password=YourStrongPassword;TrustServerCertificate=True"
  }
}
    

Üretim ortamı için appsettings.Production.json dosyanızda farklı bir bağlantı dizesi tanımlayabilirsiniz:

// appsettings.Production.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=prod_db_server;Database=ProductionDb;User Id=prod_user;Password=ProdPassword;TrustServerCertificate=True"
  }
}
    

Uygulamanızın hangi ortamda çalıştığını belirlemek için ASPNETCORE_ENVIRONMENT ortam değişkenini kullanırız. Örneğin, Windows'ta set ASPNETCORE_ENVIRONMENT=Production veya Linux/macOS'ta export ASPNETCORE_ENVIRONMENT=Production komutuyla ortamı ayarlayabilirsiniz. .NET Core uygulaması başlatıldığında, bu ortam değişkenine göre uygun appsettings.{Environment}.json dosyasını otomatik olarak yükler ve ayarları birleştirir.

2. Ortam Değişkenleri ile Güvenli Bağlantı Dizeleri

Özellikle üretim ortamlarında, hassas bilgileri (veritabanı şifreleri gibi) doğrudan yapılandırma dosyalarında tutmak güvenlik riski taşır. Bunun yerine, bu bilgileri ortam değişkenleri aracılığıyla sağlamak çok daha güvenlidir. Ortam değişkenleri, uygulamanızın dağıtıldığı sunucu veya kapsayıcı ortamında belirlenir ve uygulamanız tarafından okunabilir. Bu, hassas verilerin kaynak kontrol sistemlerine girmesini engeller.

Örneğin, bir sunucuda ConnectionStrings__DefaultConnection adında bir ortam değişkeni tanımlayabilirsiniz:

# Linux/macOS
export ConnectionStrings__DefaultConnection="Server=env_db_server;Database=EnvironmentDb;User Id=env_user;Password=EnvPassword;TrustServerCertificate=True"

# Windows (Command Prompt)
set ConnectionStrings__DefaultConnection="Server=env_db_server;Database=EnvironmentDb;User Id=env_user;Password=EnvPassword;TrustServerCertificate=True"
    

.NET Core'daki yapılandırma sistemi, otomatik olarak __ (çift alt çizgi) ile ayrılmış ortam değişkenlerini iç içe yapılandırma değerleri olarak yorumlar. Yani, yukarıdaki ortam değişkeni ConnectionStrings:DefaultConnection olarak erişilebilir olacaktır. Bu mekanizma, yapılandırma hiyerarşisinde ortam değişkenlerine yüksek öncelik verir.

3. Dinamik DbContext Yapılandırması

Bazen uygulamanızın çalışma zamanında hangi veritabanına bağlanacağına karar vermesi gerekebilir. Örneğin, bir çok kiracılı (multi-tenant) uygulamada, her kiracının kendi veritabanı olabilir ve istek başına doğru veritabanına bağlanmak gerekir. Bu senaryoda, DbContext yapılandırmasını dinamik hale getirebiliriz. Bu, uygulamanın kiracıya özel davranışlar sergilemesini sağlar.

Bunu yapmak için, DbContextOptions'ı doğrudan enjekte etmek yerine, bağlantı dizesini bir servis aracılığıyla sağlamayı düşünebiliriz:

// Program.cs
builder.Services.AddScoped();

builder.Services.AddDbContext((serviceProvider, options) =>
{
    var connectionStringProvider = serviceProvider.GetRequiredService();
    var connectionString = connectionStringProvider.GetConnectionString(); // Kiracıya özel bağlantı dizesini al
    options.UseSqlServer(connectionString);
});
    

Burada IConnectionStringProvider adında bir arayüz ve bunu uygulayan bir servis tanımlamanız gerekecektir. Bu servis, mevcut HTTP isteğine veya kullanıcının kimliğine göre doğru bağlantı dizesini belirleyebilir. Bu, oldukça ileri düzey bir senaryodur ancak büyük ve karmaşık uygulamalarda inanılmaz bir esneklik sunar. Bu yapı, uygulamanın dinamik gereksinimlere uyum sağlamasını kolaylaştırır.

Ortam tabanlı ve dinamik bağlantı dizeleri yönetimi, uygulamanızın dağıtımını basitleştirir, güvenlik duruşunu güçlendirir ve farklı operasyonel ortamlara uyum sağlama yeteneğini artırır. Bu stratejileri doğru bir şekilde uygulamak, uzun vadede projenizin başarısı için kritik öneme sahiptir ve bakım maliyetlerini azaltır.

Performans ve Güvenlik İpuçları: SQL Server Çoklu Veritabanı Yapılandırması

Çoklu veritabanı yapılandırması, uygulamanıza esneklik ve ölçeklenebilirlik katarken, performans ve güvenlik konularında dikkatli olunması gereken yeni katmanlar ekler. Bu bölümde, SQL Server tabanlı çoklu veritabanı kurulumlarınızın hem hızlı hem de güvenli olmasını sağlayacak önemli ipuçlarını ve en iyi uygulamaları ele alacağız. Bu öneriler, uygulamanızın üretimde sorunsuz çalışmasını temin edecektir.

Performans Optimizasyonları

Veritabanı işlemleri, genellikle bir uygulamanın en yavaş kısmıdır. Bu nedenle, performans optimizasyonları kritik öneme sahiptir. İyi optimize edilmiş bir veritabanı, uygulamanızın genel hızını önemli ölçüde artırabilir.

• Bağlantı Havuzu (Connection Pooling): EF Core ve ADO.NET, veritabanı bağlantılarını yeniden kullanmak için otomatik olarak bağlantı havuzlama (connection pooling) kullanır. Bu, her istek için yeni bir bağlantı açıp kapatma maliyetini ortadan kaldırır. Ancak, bağlantı dizelerinizdeki parametrelerin (özellikle güvenlik veya şifreleme ile ilgili olanlar) tutarlı olduğundan emin olun, aksi takdirde havuzlama düzgün çalışmayabilir. Farklı veritabanları için farklı bağlantı dizeleri kullandığınızda, her havuz bağımsız olacaktır, bu normaldir ve performansı olumsuz etkilemez.
• Uygun İndeksleme: Sorgularınızın performansını artırmak için veritabanı tablolarınızda uygun indeksler oluşturun. Sıkça sorgulanan sütunlara (özellikle WHERE, JOIN ve ORDER BY koşullarında kullanılanlar) indeks eklemek, veri erişim sürelerini önemli ölçüde azaltabilir. EF Core migrasyonları aracılığıyla indeksleri tanımlayabilir veya doğrudan veritabanında oluşturabilirsiniz. Doğru indeks stratejisi, büyük veri setleriyle çalışırken hayati önem taşır.

  
  // EF Core'da indeks tanımlama örneği
  modelBuilder.Entity()
      .HasIndex(p => p.Name); // Product.Name sütununa indeks ekle
              

• Sorgu Optimizasyonu: Karmaşık sorguları basitleştirin ve gereksiz join'lerden kaçının. EF Core'u kullanırken, Include() metoduyla ilişkili verileri yüklerken dikkatli olun. Çok fazla veri yüklemek performans sorunlarına yol açabilir. Gerektiğinde Select() ile sadece ihtiyacınız olan sütunları çekin. Asenkron (async/await) metotları kullanarak UI'ın veya uygulamanın diğer bölümlerinin veritabanı işlemlerini beklemeden çalışmaya devam etmesini sağlayın, bu da kullanıcı deneyimini iyileştirir.
• Önbellekleme (Caching): Sıkça erişilen ancak nadiren değişen veriler için uygulama düzeyinde veya dağıtılmış önbellekleme kullanın. Redis veya Memcached gibi çözümlerle veritabanına olan yükü azaltabilir ve yanıt sürelerini iyileştirebilirsiniz. Her veritabanı için ayrı önbellek stratejileri düşünebilirsiniz. Önbellekleme, veritabanı sunucularının üzerindeki baskıyı azaltmanın etkili bir yoludur.
• SQL Server Performans İzleme: SQL Server Profiler, Extended Events, Dinamik Yönetim Görünümleri (DMVs) gibi araçlarla veritabanınızın performansını sürekli izleyin. Yavaş çalışan sorguları tespit edin ve bunları optimize edin. Sürekli izleme, potansiyel performans darboğazlarını erken aşamada belirlemenize yardımcı olur.

Güvenlik İpuçları

Veritabanı güvenliği, uygulamanızın genel güvenliğinin temelini oluşturur. Çoklu veritabanı ortamında her veritabanının kendi güvenlik duruşu olmalıdır, çünkü her birinin farklı hassasiyette verilere sahip olması muhtemeldir.

• En Az Yetki Prensibi: Uygulamanızın veritabanına bağlanmak için kullandığı kullanıcı hesaplarına sadece ihtiyaç duydukları minimum yetkileri verin. Örneğin, bir kullanıcı sadece ürünleri okuyorsa, ona sadece okuma (SELECT) yetkisi verin, yazma (INSERT, UPDATE, DELETE) yetkisi vermeyin. Her veritabanı (AuthDb, CatalogDb, OrderDb) için ayrı ve özelleştirilmiş kullanıcılar ve roller tanımlayın. Bu, bir güvenlik ihlali durumunda etki alanını sınırlar.
• SQL Enjeksiyonuna Karşı Korunma: Entity Framework Core gibi ORM'ler, parametreli sorguları otomatik olarak kullanarak SQL enjeksiyon saldırılarına karşı doğal bir koruma sağlar. Ancak, doğrudan SQL sorguları yazıyorsanız (FromSqlRaw veya ExecuteSqlRaw gibi metotlarla), parametreleri dikkatlice kullanmalı ve asla kullanıcı girişini doğrudan SQL sorgusuna katmamalısınız. OWASP Top 10 listesinde üst sıralarda yer alan bu zafiyetten korunmak kritik öneme sahiptir.

  
  // Güvenli kullanım (parametreli sorgu)
  var products = await _catalogDbContext.Products
      .FromSqlRaw("SELECT * FROM Products WHERE CategoryId = {0}", categoryId)
      .ToListAsync();
  
  // KÖTÜ KULLANIM (SQL Enjeksiyonuna açık)
  // var products = await _catalogDbContext.Products.FromSqlRaw($"SELECT * FROM Products WHERE CategoryId = {categoryId}").ToListAsync();
              

• Hassas Veri Şifrelemesi: Müşteri bilgileri, kredi kartı numaraları, şifreler gibi hassas verileri veritabanında şifreli olarak saklayın. SQL Server'ın şeffaf veri şifrelemesi (TDE) veya Always Encrypted gibi özellikleri, verilerin depolama ve iletim sırasında korunmasına yardımcı olur. Uygulama katmanında da hassas verileri şifreleyip çözebilirsiniz. Bu, veri ihlali durumunda bile verilerin korunmasını sağlar.
• Bağlantı Dizelerini Koruma: Bağlantı dizelerinizi asla kaynak kodda veya herkese açık yapılandırma dosyalarında saklamayın. Ortam değişkenleri, bulut tabanlı anahtar yönetim sistemleri (Azure Key Vault, AWS Secrets Manager) veya .NET Secret Manager gibi güvenli yöntemleri kullanın. Bu yaklaşım, kimlik bilgilerinin çalınma riskini minimize eder.
• Güvenlik Denetimleri ve Günlükleme: Veritabanı erişimlerini ve değişikliklerini denetlemek için kapsamlı günlükleme (logging) uygulayın. SQL Server denetim özelliklerini kullanarak kimin ne zaman hangi verilere eriştiğini veya değişiklik yaptığını izleyin. Anormal aktiviteyi tespit etmek için bu günlükleri düzenli olarak inceleyin.
• Ağ Güvenliği: Veritabanı sunucularına erişimi kısıtlayın. Güvenlik duvarları (firewalls) kullanarak sadece uygulamanızın çalıştığı sunucuların veya belirli IP adreslerinin veritabanı sunucularına erişmesine izin verin. Veritabanı iletişimini SSL/TLS üzerinden şifrelemeyi sağlayın. Bu, ağ düzeyinde yetkisiz erişimi engeller.

Bu performans ve güvenlik ipuçlarını uygulayarak, çoklu SQL Server veritabanı kurulumlarınızın sadece işlevsel değil, aynı zamanda sağlam, hızlı ve dış tehditlere karşı dirençli olmasını sağlayabilirsiniz. Unutmayın, güvenlik ve performans tek seferlik eylemler değil, sürekli dikkat ve optimizasyon gerektiren süreçlerdir. Bu yaklaşımlar, uygulamanızın uzun ömürlü ve güvenilir olmasını sağlar.

Sonuç: Geleceğe Yönelik Dayanıklı Bir Mimari

Modern uygulamaların karmaşıklığı ve değişen iş gereksinimleri, esnek ve ölçeklenebilir veritabanı stratejilerini zorunlu kılmaktadır. Bu makalede ele aldığımız gibi, .NET tabanlı uygulamalarınıza SQL Server desteği eklemek ve çoklu veritabanı kurulumlarını yönetmek, uygulamanızın geleceğe yönelik dayanıklılığını önemli ölçüde artırır. Tek bir veritabanı sağlayıcısına bağlı kalmadan, farklı iş domainleri için optimize edilmiş veri depolama çözümleri sunarak hem performansı artırabilir hem de bakım kolaylığı sağlayabilirsiniz. Bu sayede, uygulamanızın yaşam döngüsü boyunca esnekliğini korursunuz.

Adım adım gösterdiğimiz gibi, Entity Framework Core'un sağladığı soyutlama katmanı sayesinde, farklı DbContext sınıfları tanımlayarak ve bunları Dependency Injection ile doğru bir şekilde yöneterek çoklu veritabanı senaryolarını başarıyla hayata geçirebilirsiniz. Ayrıca, dinamik bağlantı dizeleri ve ortam tabanlı yapılandırma stratejileri, uygulamanızın farklı dağıtım ortamlarına sorunsuz bir şekilde adapte olmasını güvence altına alır. Son olarak, performans optimizasyonları ve sıkı güvenlik önlemleri, uygulamanızın sadece hızlı çalışmasını değil, aynı zamanda veri bütünlüğünü ve gizliliğini de korumasını sağlar. Bu bütünsel yaklaşım, uygulamanızın genel kalitesini yükseltir.

Unutmayın ki çoklu veritabanı mimarisi, doğru uygulandığında büyük avantajlar sunar, ancak aynı zamanda daha fazla yapılandırma ve yönetim karmaşıklığı da beraberinde getirir. Bu nedenle, her adımda dikkatli olmak ve en iyi uygulamaları takip etmek, projenizin uzun vadeli başarısı için kritik öneme sahiptir. Bu rehberin, .NET uygulamalarınıza SQL Server desteği ekleme ve sağlam bir çoklu veritabanı altyapısı kurma yolculuğunuzda size rehberlik etmesini umuyoruz. Başarılı ve sürdürülebilir uygulamalar geliştirmeniz dileğiyle.

Sıkça Sorulan Sorular (SSS)

Birden fazla DbContext kullanmak uygulamanın performansını nasıl etkiler?

Birden fazla DbContext kullanmak, genellikle performans üzerinde doğrudan olumsuz bir etkiye sahip değildir. Aksine, her DbContext kendi veritabanı sorumluluk alanıyla sınırlı olduğu için sorguların daha hedefli olmasını sağlar ve veritabanı bağlantı havuzlaması her DbContext için ayrı ayrı yönetildiği için etkin bir şekilde kaynak kullanılır. Performans sorunları genellikle yanlış sorgulama, eksik indeksleme veya aşırı veri yüklemesinden kaynaklanır, DbContext sayısından değil. Doğru yapılandırma ile performans artışı bile gözlemlenebilir.

Her veritabanı için ayrı migrasyonları nasıl yönetirim?

Her DbContext için ayrı migrasyonları yönetmek için .NET CLI komutlarını kullanırken --context parametresini belirtmeniz gerekir. Örneğin, dotnet ef migrations add InitialAuthMigration --context AuthDbContext. Bu, EF Core'un hangi DbContext sınıfı için migrasyon oluşturacağını veya uygulayacağını bilmesini sağlar. Her DbContext'in kendi migrasyon klasörü olması tavsiye edilir. Bu, migrasyonları daha düzenli ve çakışmasız yönetmenizi sağlar.

Çoklu veritabanı kurulumunda güvenlik riskleri nelerdir?

Çoklu veritabanı ortamında güvenlik riskleri artabilir çünkü yönetilmesi gereken daha fazla bağlantı dizesi ve erişim noktası vardır. Ana riskler arasında yetkisiz erişim (zayıf kimlik bilgileri), SQL enjeksiyonu (doğrudan SQL kullanılıyorsa), veri ifşası (şifresiz hassas veri) ve yanlış yetkilendirme (gereğinden fazla yetki verilmesi) bulunur. En az yetki prensibi, bağlantı dizelerinin güvenli yönetimi ve parametreli sorguların kullanımı bu riskleri azaltmak için kritik öneme sahiptir. Her veritabanı için ayrı güvenlik denetimleri önemlidir.

Farklı veritabanı türlerini (örn. SQL Server ve PostgreSQL) aynı uygulamada kullanabilir miyim?

Evet, Entity Framework Core ile bu mümkündür. Her farklı veritabanı türü için ayrı bir DbContext sınıfı ve ilgili EF Core sağlayıcı paketini (örn. Microsoft.EntityFrameworkCore.SqlServer ve Npgsql.EntityFrameworkCore.PostgreSQL) yüklemeniz gerekir. Ardından, her DbContext'i kendi sağlayıcısı ve bağlantı dizesiyle DI konteynerine kaydederek kullanabilirsiniz. Bu, mikroservis mimarilerinde sıkça görülen bir yaklaşımdır ve uygulamanıza teknoloji esnekliği kazandırır.

Mobil uyumlu HTML'den bahsettiniz, bunun çoklu veritabanı kurulumuyla ne ilgisi var?

Makalede mobil uyumlu HTML'in direkt olarak çoklu veritabanı kurulumuyla teknik bir bağlantısı yoktur. Ancak, modern web uygulamaları genellikle API tabanlı arka uçlarla iletişim kurar. Veritabanı tarafında performans ve güvenlik optimizasyonları yapmak, mobil uygulamanın API çağrılarına daha hızlı ve güvenli yanıt almasını sağlar. Dolayısıyla, güçlü bir arka uç mimarisi (çoklu veritabanı desteği dahil) dolaylı olarak mobil kullanıcı deneyimini de iyileştirir. Ayrıca, genel bir web geliştirme makalesi formatında mobil uyumluluğun önemi vurgulanmıştır, çünkü arka uç ne kadar iyi olursa olsun, ön yüz de modern standartlara uygun olmalıdır.