ASP.NET Core 6/Yapılandırma Ayarlarının Kullanımı

Bu bölümde programımızın yapılandırma ayarlarının nasıl yapıldığı ve programımızdan yapılandırma ayarlarına nasıl erişildiği anlatılacaktır. Şimdi ASP.NET Core Empty şablonuyla yeni bir proje oluşturun ve projeye Yapilandirma ismini verin.

Programımızın yapılandırma ayarları genel anlamda appsettings.json ve appsettings.Development.json dosyalarında tutulur. ASP.NET Core Empty şablonuyla oluşturulan projenin appsettings.json dosyası şöyle olacaktır:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Projedeki tek yapılandırma dosyası appsettings.json değildir. appsettings.json genel amaçlı yapılandırma ayarlarını içerir. Programımız farklı geliştirme aşamasında olabilir. Bunlar Development, Staging ve Production'dır. Development programımızın geliştirme aşamasında olduğunu belirtir, Staging programımızın büyük ölçüde tamamlandığını, ancak henüz canlıya geçilmek için hazır olmadığını belirtir (geçiş aşaması). Production ise programımızın tam olarak tamamlandığını ve canlıya geçilebileceğini belirtir.

Başlattığımız projenin geliştirme durumunda herhangi bir değişiklik yapmadıysak varsayılan durumda Development'ta demektir. Programımız çalışırken ilk önce appsettings.json dosyasındaki ayarları, sonra geliştirme ortamına özgü json dosyasındaki ayarları kullanır. ASP.NET Core Empty şablonuyla oluşturulan projenin appsettings.Development.json dosyası şöyle olacaktır:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  }
}

Eğer appsettings.Development.json dosyası ile appsettings.json dosyası aynı yapılandırma için ayarlar içeriyorsa daha spesifik olan appsettings.Development.json dosyasının dediği geçerlidir. Örneğimizde appsettings.Development.json dosyası appsettings.json dosyasının ayarlarını değiştirmiyor, yaptığı ayarlarda appsettings.json dosyasıyla tam olarak aynı ayarları kullanıyor. Ayrıca appsetting.json dosyası appsettings.Development.json dosyasına "AllowedHosts" ayarı konusunda ekleme yapıyor.

Yapılandırma ayarlarına erişme

Projemizdeki appsettings.json ve appsettings.Development.json dosyaları esasında tek bir sanal yapılandırma dosyası inşa ederler. Daha doğrusu yapılandırma servisi iki dosyayı üzerine yazma kurallarını da hesaba katarak birleştirir ve bu birleşimden yapılandırma ayarlarını alır. Yapılandırma servisinin tek yapılandırma ayarı kaynağı bu iki dosya değildir. Yapılandırma servisi komut satırı argümanlarına ve çevre değişkenlerine de erişebilir. Örnek (Program.cs dosyasındaki uygun bir yere ekleyebilirsiniz):

app.MapGet("config", async (HttpContext context, IConfiguration config) => {
    string defaultDebug = config["Logging:LogLevel:Default"];
    await context.Response.WriteAsync($"The config setting is: {defaultDebug}");
});

IConfiguration servisi Microsoft.Extensions.Configuration isim alanında bulunmaktadır. Lambda ifadesi şeklinde tanımlanan bir endpoint'ten yapılandırma servisine eriştikten sonra şimdi nasıl direkt Program.cs dosyası üzerinden yapılandırma servisine erişeceğimizi görelim. WebApplication ve WebApplicationBuilder sınıflarının Configuration özelliği aracılığıyla da yapılandırma servisine erişilebilir. Örnek:

var builder = WebApplication.CreateBuilder(args);
var servicesConfig = builder.Configuration;
// - burada ayağa kaldırılacak servisleri belirlemek için yapılandırma ayarlarını kullan
var app = builder.Build();
var pipelineConfig = app.Configuration;
// - burada request pipeline'a eklenecek middleware'leri belirlemek için yapılandırma ayarlarını kullan
app.MapGet("config", async (HttpContext context, IConfiguration config) => {
    string ayar = config["Logging:LogLevel:Default"];
    await context.Response.WriteAsync($"The config setting is: {ayar}");
});
app.MapGet("/", async context => {
    await context.Response.WriteAsync("Hello World!");
});
app.Run();

Middleware'lerin yapılandırmasının appsettings.json dosyası üzerinden yapılması

Daha önceki derslerimizde options pattern'ini kullanarak nasıl middleware'lerin yapılandırılabileceğini görmüştük. O zaman middleware'in yapılandırma ayarını direkt Program.cs dosyasında belirtmiştik. Şimdi bir middleware'in yapılandırma ayarının nasıl appsettings.json dosyasından alınacağını göreceğiz. Şimdi appsettings.json dosyasını şöyle değiştirelim:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Ayarlar": {
    "HizliCalissin": "true"
  }
}

Burada basitçe middleware'in kullanacağı ayarları ekledik. Şimdi Program.cs dosyasını şöyle değiştirelim:

var builder = WebApplication.CreateBuilder(args);
var servicesConfig = builder.Configuration;
builder.Services.Configure<MiddlewareAyarlari>(servicesConfig.GetSection("Ayarlar"));
var app = builder.Build();
var pipelineConfig = app.Configuration;
// - middleware yapılandırma alanı
app.UseMiddleware<LocationMiddleware>();
app.MapGet("config", async (HttpContext context, IConfiguration config) => {
    string ayar = config["Logging:LogLevel:Default"];
    await context.Response.WriteAsync($"The config setting is: {ayar}");
});
app.MapGet("/", async context => {
    await context.Response.WriteAsync("Hello World!");
});
app.Run();

Bu kod daha önceki bölümlerde yazdığımız sınıflara bağlıdır. Ancak koda bakarak yapılan işi anlayacağınızı öngörüyorum. Öncelikle appsettings.json dosyasındaki "Ayarlar" kısmı alınmaktadır, daha sonra bu kısımdaki girdiler kullanılarak bir MiddlewareAyarlari nesnesi oluşturulmaktadır. LocationMiddleware isimli sınıf tabanlı middleware, yapıcı metot yoluyla IOptions<MiddlewareAyarlari> servisini kendine enjekte etmekte ve kendi çalışmasını eriştiği MiddlewareAyarlari nesnesine göre manipule etmektedir. Sonuç olarak bir middleware kendi ayarlarını bir yapılandırma dosyasından almıştır.

launchSettings.json dosyası

launchSettings.json dosyası Properties klasörü altına gizlenmiştir. Bu dosya sunucu ayağa kalkarken yapılacak teknik yapılandırmaları içermektedir. Benim sistemimde ASP.NET Core Empty şablonu kullanılarak oluşturulan projenin launchSettings.json dosyasının içeriği şöyle olmaktadır:

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:36186",
      "sslPort": 0
    }
  },
  "profiles": {
    "Yapilandirma": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:5163",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

iisSettings kısmı ASP.NET Core IIS Express üzerinden başlatıldığında geçerli olacak ayarları içerir. IIS Express artık göreceli olarak geride kalmıştır. Sunucunuz IIS Express üzerinden ayağa kalkmıyorsa buradaki ayarların herhangi bir işlevselliği yoktur.

profiles kısmı sunucu için farklı çalışma profilleri tanımlamaya yarar. Dosyamızda da gördüğümüz gibi Yapilandirma ve IIS Express olmak üzere iki profil bulunmaktadır. Sunucunun hangi profilden başlatılacağı Visual Studio üzerinden belirtilebilir. Visual Studio'da araç çubuğunda bulunan sunucuyu başlatmak için kullandığımız yeşil okun yanında hangi profilde olduğumuz yazar. Sunucuyu farklı bir profilde çalıştırmak için profil isminin yanındaki aşağı bakan küçük oku tıklayabiliriz.

Her iki profilde de çevre değişkenleri belirtilebilmektedir. Daha önce programın bulunduğu geliştirme sürecine göre farklı appsettings.json dosyalarının kullanılabileceğini söylemiştik. İşte geliştirme sürecinin belirtildiği yer burasıdır. Ayrıca yine sunucunun çalıştırıldığı zaman hangi portu dinleyeceği, sunucu çalıştırıldığı zaman tarayıcının otomatik çalıştırılıp çalıştılmayacağı yine buradaki ayarlardan yapılır.

Çevre değişkenlerine ulaşma

Biraz önceki launchSettings.json dosyasındaki tek çevre değişkeni "ASPNETCORE_ENVIRONMENT" idi. Ancak istenirse bu çevre değişkenlerinin sayısı artırılabilir. Ayrıca programımız üzerinden bu çevre değişkenlerine ulaşılabilir. Çevre değişkenlerine ulaşmak da yapılandırma dosyalarına olduğu gibi yine IConfiguration servisi üzerinden olur. Örnek:

app.MapGet("config", async (HttpContext context, IConfiguration config) => {
    string ayar = config["Logging:LogLevel:Default"];
    await context.Response.WriteAsync($"The config setting is: {ayar}");
    string environ = config["ASPNETCORE_ENVIRONMENT"];
    await context.Response.WriteAsync($"\nThe env setting is: {environ}");
});

Çevre değişkenlerine Visual Studio üzerinden erişme

Visual Studio üzerinden programda kullanılan çevre değişkenlerine erişilebilir ve bu çevre değişkenleri değiştirilebilir. Bunun için;

• Menü çubuğundaki Debug menüsü açılır.
• "Proje_Ismi Debug Properties" menü ögesi tıklanır. Bizim projemizin ismi Yapilandirma olduğu için burada "Yapilandirma Debug Properties" yazar.
• Açılan "Launch Profiles" penceresi aslında launchSettings.json dosyası için bir arayüzdür. launchSettings.json dosyası üzerinden yapılan ayarlar bu pencere üzerinden de yapılabilir. Burada çevre değişkenleri eklenebilir, silinebilir, değiştirilebilir.

Çevre servisinin kullanımı

IConfiguration servisi üzerinden çevre değişkenlerine ulaşabiliriz. Ancak üzerinde bulunduğumuz geliştirme sürecinin öğrenilmesi çok sık başvurduğumuz bir şey olduğu için ASP.NET Core bunun için özel bir servis tanımlamıştır. Çevre değikenlerine IWebHostEnvironment servisi üzerinden erişilebilir. Bu arayüzde bulunan önemli üyeler şunlardır:

EnvironmentName: Geçerli ortamı döndürür.
IsDevelopment(): Geçerli ortam Development ise true döndürür.
IsStaging(): Geçerli ortam Staging ise true döndürür.
IsProduction(): Geçerli ortam Production ise true döndürür.
IsEnvironment(env): Geçerli ortam belirtilen ortam ise true döndürür.

NOT: Yukarıdaki metotlar esasında IWebHostEnvironment arayüzü üzerinde çalışan ancak Microsoft.Extensions.Hosting isim alanında bulunan eklenti metotlarıdır.

Eğer geçerli ortama servisleri ayağa kaldırırken erişmek istiyorsak WebApplicationBuilder.Environment özelliğini kullanırız, eğer geçerli ortama request pipeline'a middleware eklerken erişmek istiyorsak WebApplication.Environment özelliğini kullanırız. Eğer geçerli ortam bilgisine bir endpoint veya middleware içinden erişmek istiyorsak IWebHostEnvironment servisini enjekte ederiz.

Kullanıcı sırlarını depolama

Kullanıcı sırları adı üstünde gizli kalması gereken bilgilerdir. Bu bilgiler API anahtarları, veritabanı bağlantı şifreleri, admin şifresi, vb. olabilir. Ayrıca bu tür bilgiler sık değişebilir. Bu tür bilgilerin hem gizli kalması gerektiğinden hem de sık değişebileceğinden kaynak koda gömülmesi pek tavsiye edilmez. Kaynak kod dosyaları, appsettings.json ve launchSettings.json dosyaları Git benzeri bir versiyon kontrol sistemine dahil edilebilir, bu da kaynak koda erişebilen her geliştiricinin gizli kalması gereken bu bilgilere erişebileceği anlamına gelir.

Kullanıcı sırları servisi bu tür bilgileri projede tutmaz. Bu yüzden proje bir versiyon kontrol sistemine gittiğinde gizli bilgiler gitmemiş olur.

Kullanıcı sırları araç paketinin kurulması ve yapılandırılması

Kullanıcı sırlarını depolayabilmemiz için öncelikle bir araca ihtiyacımız var. Öncelikle Visual Studio'da menü çubuğundaki View menüsü altındaki "Terminal" ögesine tıklayın. Alt kısımdaki "Error List" ve "Output" pencereciklerinin yanına "Geliştirici Powershell" pencereciği de gelecektir. Bu pencereciğe geçin. Terminalde varsayılan durumda solution dosyasının olduğu klasörde olacaksınız. .csproj uzantılı proje dosyanızın olduğu klasöre cd komutunu vererek geçin. Şimdi aşağıdaki iki komutu verin:

dotnet tool uninstall --global dotnet-user-secrets
dotnet tool install --global dotnet-user-secrets --version 3.0.0-preview-18579-0056

Bu komutlar öncelikle user-secrets isimli bir araç varsa bunu silmektedir, daha sonra aynı aracı belirttiğimiz versiyonda kurmaktadır. Şimdi bu aracı ilklendirelim:

dotnet user-secrets init

Kullanıcı sırlarını saklamak istediğimiz her bir proje için ilklendirme işlemi gereklidir. Şimdi aşağıdaki iki komutu çalıştıralım:

dotnet user-secrets set "WebService:Id" "MyAccount"
dotnet user-secrets set "WebService:Key" "MySecret123$"

Burada gizli bilgi deposuna iki gizli bilgi saklanmaktadır. Birisi bir servise bağlanmak için kullanabileceğimiz kullanıcı adı, diğeri şifredir. Gizli bilgiler anahtar-değer çiftleri şeklinde depolanır. Birbiriyle ilgili olan gizli bilgiler : ile ayrılan ön ekler alabilirler. Bu girdiğiniz gizli bilgileri görmek için aşağıdaki komutu kullanabilirsiniz:

dotnet user-secrets list

Kullanıcı arayüzünü kullanarak gizli bilgileri görme ve değiştirme

Visual Studio kullanıcı arayüzünü kullanarak kullanıcı sırlarını görebilir ve değiştirebiliriz. Bunun için "Solution Explorer" pencereciğindeki projeye sağ tıklayın. Açılan bağlam menüsünden "Manage User Secrets" ögesini tıklayın. JSON formatında kullanıcı sırlarını görüp değiştirebileceğiniz, ekleyebileceğiniz secrets.json isimli bir dosya açılır. Bu dosyada değişiklik yapıp kaydederek kullanıcı sırlarını değiştirebilirsiniz.

Program içinde kullanıcı sırlarına erişme

Kuşkusuz program içinden kullanıcı sırlarına erişemiyorsak kullanıcı sırları aracını kullanmanın pek mantığı olmayacaktır. Kullanıcı sırlarına standart yapılandırma servisi üzerinden erişilir. Örnek:

app.MapGet("config", async (HttpContext context, IConfiguration config) => {
    string wsID = config["WebService:Id"];
    string wsKey = config["WebService:Key"];
    await context.Response.WriteAsync($"\nThe secret ID is: {wsID}");
    await context.Response.WriteAsync($"\nThe secret Key is: {wsKey}");
});