Görsel kaynağı: https://medium.com/java-performance/performance-is-the-enemy-of-clean-code-fdd65c4c7d99
Selamlar herkese. Değerli üstadım Türkay Ürkmez’in Generic Constraintlerle alakalı bir LinkedIn paylaşımını gördüm. Burada farklı bir açıdan performansa katkı olacak bir konu hakkında yorumda bulundum O sebeple böyle bir yazı yazmak istedim. Kısacası, konu başlıktan da anlaşılacağı üzere False Sharing.

False Sharing Nedir?

False sharing, aynı CPU cache line’ında yer alan birbirinden bağımsız değişkenlere, birden fazla thread’in erişmeye çalışması durumudur. Bu işlem de performans düşüşüne yol açar. Cache line derken bunun ne olduğuna da değinmemiz gerekiyor.

Cache Line: CPU cache’lerinin bellekten veri çekerken kullandığı en küçük veri bloklarına verilen isimdir. 64 ya da 128 byte boyuta sahiptirler. CPU, veriyi bellekten tek tek okumak yerine, tüm cache line’ı çeker.

Biraz daha açıklamak gerekirse, eğer farklı thread’ler aynı cache line içinde yer alan farklı değişkenlere sıkça yazma işlemi yaparsa, CPU’lar sürekli olarak cache’in güncelliğini sağlamak için cache coherence protocol kullanarak senkronizasyonu sağlamaya çalışırlar. Bu yüzden de gereksiz bellek erişimi ve CPU yükü anlamına gelir.

Şimdi problemin olduğu noktaya gelelim. Örneğin long türünde bir değişkenimiz var bu da 8 byte demektir. Yukarıdaki bilgiye göre deCPU verileri byte byte değil de cache line’ı alarak çeker. Bu da 64–8 byte’lık bir alanın daha cache line’da gelebileceğini söyler. Bu nedenle 8'den sonra gelen diğer byte’lar da o cache line içerisinde yer alır. Ne zamana kadar? 64 ya da bazı mimarilerde 128 olana kadar.

Bunu şöyle anlatmaya çalışalım. Şöyle 2 alanımız olsun.

• sharedData[0] → 0x00000000
• sharedData[1] → 0x00000008

Bu iki değer sırasıyla thread 1 ve thread 2 tarafından güncellensin. Örneğin, sadece sharedData[0] güncellenirse, tüm CPU çekirdeklerine cache line’da değişiklik var sinyali gönderiliyor. Bu da cache invalidation dediğimiz olayı gerçekleştiriliyor. Yani cache geçersiz oluyor. Bu yüzden de tekrar cache line’ın dolması gerekiyor. Günün sonunda bu da yazının başında belirttiğimiz bellek erişimlerinin tekrar tekrar olmasını sağlar. Yani gereksiz yere bellek erişimi ortaya çıkar.

Cache Invalidation: CPU veya bellek sisteminde bir cachelenmiş bir verinin güncelliğini yitirdiğini belirten bir mekanizmadır.

False Sharing Problemine Karşı C# ile Çözüm Üretmek

Eğer C# ile yazılım geliştiriyorsanız örneklerle nasıl False Sharing oluşturacağımızı ve bunu nasıl çözeceğimizi görelim.

False Sharing Örneği

using System.Diagnostics;

const int iterations = 10_000_000;
var threadCount = Environment.ProcessorCount;
var sharedData = new long[threadCount];
var stopwatch = Stopwatch.StartNew();
var threads = new Thread[threadCount];

for (var i = 0; i < threadCount; i++)
{
    var threadIndex = i;
    threads[i] = new Thread(() =>
    {
        for (var j = 0; j < iterations; j++)
        {
            sharedData[threadIndex]++;
        }
    });
}

foreach (var thread in threads) thread.Start();
foreach (var thread in threads) thread.Join();

stopwatch.Stop();
Console.WriteLine($"False Sharing ile çalışan kod için geçen zaman: {stopwatch.ElapsedMilliseconds} ms");

Çıktısı: False Sharing ile çalışan kod için geçen zaman: 986ms

Yukarıdaki koda baksetığımızda masum görünen bir sharedData[threadIndex]++ ifadesi görmekteyiz. Bu ifade, aslında bütün cache line’ı güncelleten performans düşmanı bir ifadedir.

False Sharing’in Önlendiği Örnek

using System.Diagnostics;
using System.Runtime.InteropServices;

const int iterations = 10_000_000;
var threadCount = Environment.ProcessorCount;
var sharedData = new PaddedLong[threadCount];
var stopwatch = Stopwatch.StartNew();

var threads = new Thread[threadCount];

for (var i = 0; i < threadCount; i++)
{
    var threadIndex = i;
    threads[i] = new Thread(() =>
    {
        for (var j = 0; j < iterations; j++)
        {
            sharedData[threadIndex].Value++;
        }
    });
}

foreach (var thread in threads) thread.Start();
foreach (var thread in threads) thread.Join();

stopwatch.Stop();
Console.WriteLine($"False sharing önlerken çalışan kod için geçen zaman: {stopwatch.ElapsedMilliseconds} ms");

[StructLayout(LayoutKind.Explicit, Size = 64)]
struct PaddedLong
{
    [FieldOffset(0)]
    public long Value;
}

Çıktısı: False sharing önlerken çalisan kod için geçen zaman: 244 ms

Yukarıdaki kodda, PaddedLong veri türü, 64 byte’lık bir cache line’a hizalanmış durumda (alignment). Bunu Size = 64 ile belirttik. Yani yazının başındaki 64 byte’ı hatırlayacak olursak, her PaddedLong nesnesi, kendi cache line’ına sahip demek bu. FieldOffset ise, değişkenin struct içerisindeki konumunu belirtir. Eğer StructLayout tanımında LayoutKind.Explicit bir yapı kullanmamış olsaydık, derleyici değişkenler için otomatik hizalama (auto alignment) yapacaktı. Bunu önleyerek de her nesneye kendi cache line’ına sahip olma şansı verdik yani boşluk bırakmadık diyelim :)

Yazı bu kadardı. Okuduğunuz için teşekkür ederim. Umarım sizlere faydalı olabilmiştir.

Kaynaklar

• https://theboreddev.com/understanding-false-sharing
• https://en.wikipedia.org/wiki/False_sharing
• https://stackoverflow.com/questions/22766191/what-is-false-sharing-how-to-reproduce-avoid-it

Batch Script Nedir?

Bilmeyenleriniz varsa, batch script Windows işletim sisteminde çalışan, belirtilen komutları otomatik olarak çalıştırmaya yaran script dosyalarıdır. Uzantı olarak genelde .bat yada .cmd şeklinde denk gelmişsinizdir.

Amacınız komutları tekrar tekrar çalıştırmaktan kaçınmaksa, bu tarz işleri Windows için batch, Linux için shell script ile daha kolay hale getirebilirsiniz. Bir bakıma otomasyon diyebiliriz.

PowerShell ile Farkı Nedir?

Tabii Windows’ta batch script tek seçenek değil. Bunun yanı sıra, PowerShell de kullanabilirsiniz. Sadece PowerShell, daha gelişmiş bir dildir ve istendiği taktirde .NET kütüphanelerini de kullanabilirsiniz. Yani buradan şunu anlayabiliriz batch script’ten bahsediyorsak görece daha basit işlemleri yapabiliriz. PowerShell ise daha gelişmiş işlemler için idealdir.

Temel Komutlar

İlk temel komutumuz, şaşırtıcı bir komut olan, hiçbir yerde karşılaşmadığınız echo komutudur. İlginçtir bu komutla “Merhaba dünya” yazdıracağız.

@echo off
echo Merhaba dunya
pause

@echo off ile komutların ekrana yazdırılmasını engelleriz. Eğer bunu yazdırmasaydık direkt echo Merhaba dunya komutunu ekrana yazdırılacaktı.

echo ile ekrana bir mesaj basarız. Eğer herhangi bir parametre kullanmazsak, mevcut echo ayarını gösteriririz. Yani on mu off mu gibi.

pause ise kullanıcıdan bir tuşa basmasını bekler.

Bu örnekle birlikte, bir batch dosyasının nasıl çağırılabileceğini de görmüş oluyoruz. Sadece dosyanın adını yazarak çağırabiliriz. Tabiiki çift tıklayarak da açabiliriz.

cls

Bu komutla ekrandaki çıktıları temizleriz.

@echo off
echo Merhaba dunya
pause
echo

cls
echo Her seyi temizledim
pause

Çıktı aşağıdaki gibidir. Görselleri paylaşarak anlatıyorum ama bunu başka türlü daha anlaşılır gösterebileceğimi sanmıyorum.

Klasör İşlemleri

Bir klasör olşturmak için diğer işletim sistemlerinde de olduğu gibi burada da mkdir komutunu kullanırız. Kısa olarak md komutunu da kullanabilirsiniz. Burada her iki komut örneğini de göstereceğim. Ve pause’ları da kaldırayım diyorum :)

@echo off

mkdir TestDizi
md TestDiziniMdIle

echo Klasorler olusturuldu

Gördüğünüz gibi her iki türlü de oluşturabildik. Dilersek tek seferde recursive olarak oluşturabiliriz. Bunun için de md ya da mkdir’i şöyle kullanmalıyız.

@echo off

md a\b\c\d

echo Klasorler olusturuldu

Dizin Değiştirme

Dizin değiştirme için diğer işletim sistemlerinde yer alan cd komutu burada da aynı şekilde kullanılıyor. Kodumuza bakalım önce

@echo off

md a
echo a dizini olusturuldu, ilgili dizine gidiliyor
cd a
echo a dizinine giris yapildi.
echo mevcut dizin %CD% olarak tanimli. Alt satirda tekrari yazdirilacak.
cd
echo ust dizine geri cikiliyor
cd ..

cd a bu komutla a dizinine gideriz.

echo içerisinde yazdığımız %CD% değeri bulunduğumuz dizin bilgisini tutan değişkendir. Bu tarz farklı hazır değişkenler mevcuttur.

Eğer cd komutuna parametre vermezseniz, %CD% değişkeni ile aynı şeyi yapar ve mevcut dizini yazdırır.

Bir üst dizin için ise yan yana iki nokta kullanırız. Diyelimki farklı bir sürücüdesiniz. Bu durumda aşağıdaki komut ile ilgili sürücüdeki dizine gidebilirsiniz. Diyelimki C sürücüsünde terminal ekranı açık. Bu durumda şu komut iş görür.

cd /D D:\Projects/MyApi

bunun bir diğer yöntemi ise pushd komutudur.

pushd D:\Tests\batchs

Sadece pushd kullandığınızda, değişmeden önceki dizin saklanır. Bu durumda, popd ile değişimden sonraki dizine geri dönersiniz. Örnek;

@echo off

pushd C:\Python312
echo mevcut dizin %CD% olarak gorunuyor.
echo eski dizine geri donuluyor
popd
echo mevcut dizin artik %CD% olarak gorunuyor.

Dizin Silme

Diyelimki bir dizini silmek istiyorsunuz. Bu, örneklerimizde oluşan a dizini olsun, bunun için rmdir ya da kısa olarak rd komutunu kullanabilirsiniz.

@echo off

echo D:\Tests\batchs\a dizini siliniyor...
rd D:\Tests\batchs\a /s /q
echo dizin silindi...

2 farklı parametre gördük.

/s parametresi, içerisindeki bütün dosyalarla birlikte silme işlemi yapar.

Eğer s parametresini vermeseydik dizinin boş olmadığına dair bir hata görecektik.

/q parametresi, silme işlemi için onay istemez.

Eğer q parametresini vermeseydik, böyle bir onay istenecekti.

Dosya İşlemleri

Dosyaya Yazdırma

Örneğin bir mesajı, bir dosyaya yazdırmak isteseydik aşağıdaki şekilde echo kullanımı (pipe), dosyaya yazmamıza yardımcı olacaktı.

@echo off
echo Lorem ipsum dolor sit falan filan. > lorem.txt
echo Dosya olusturuldu

Dosya Taşıma

Dosya taşıma için move komutunu kullanabilirsiniz.

@echo off
echo Lorem ipsum dolor sit falan filan. > lorem.txt
echo Dosya olusturuldu
echo Dosya tasiniyor
md dosyalar
move lorem.txt dosyalar\
echo Dosya tasindi

Burada move komutu /Y ve /-Y parametrelerini almaktadır.

/Y parametresi, herhangi bir onay almadan dosyaları taşır

move /Y lorem.txt dosyalar\

/-Y parametresi, kullanıcı onayını bekler.

move /-Y lorem.txt dosyalar\

Dosya Silme

Batch scripting yaparken, windows’ta dosya silmek için del komutu kullanırız. Yine bu komut yerine erase komutunu da kullanabiliriz.

@echo off

echo dosya siliniyor
del dosyalar\lorem.txt
echo Dosya silindi

Parametrelerine gelecek olursak biraz daha bol parametreye sahiptir.

• /F parametresi, read-only dosyaları zorla siler.
• /Q parametresi, kullanıcıdan onay beklemez.
• /S parametresi, alt dizinlerde yer alan dosyaları da siler.
• /P parametresi, kullanıcıdan onay istemek içindir.
• /A parametresi, bazı attribute’lara sahip dosyaları silmenize yardımcı olur.

del /A parametresiyle kullanılabilecek tüm attribute’lar şunlardır:

• R attribute’u, salt okunur (Read-only) dosyaları siler
• S attribute’u, sistem (System) dosyalarını siler
• H attribute’u, gizli (Hidden) dosyaları siler
• A attribute’u, arşiv (Archive) dosyalarını siler
• I attribute’u, içerik dizine eklenmeyen (Not Content Indexed) dosyaları siler
• L attribute’u, symlink ya da junction points gibi sembolik bağlantıları siler.
• O attribute’u, çevrimdışı (Offline) dosyaları siler
• • ise herhangi bir özniteliğin olmadığını belirtir.

Örnek bir kullanım şöyledir;

del /A:HR dosyalar\*.txt

Yukarıdaki örnekte hem gizli hem de read-only olan bütün txt dosyalarını siler. Yani bir wildcard kullanımı da yapabilirsiniz. Fakat wildcard kullanımı attribute olmadan da kullanılabilir. Sadece örnek vermek için wildcard kullandım.

İlk yazı bu kadardı. Okuduğunuz için teşekkür ederim. Hatalarım varsa affola.

• Apache JMeter
• ApacheBench (ab)
• Locust
• k6
• Gatling
• Artillery

Bu sistemler dışında, bu yazının da konusunu oluşturan NBomber da yine yük testi yapabilmenize olanak sağlayan F# ile geliştirilen, .NET ekosisteminde kullanılabilecek faydalı bir framework olarak öne çıkıyor.

NBomber - Distributed load testing framework for .NET/C#/F#

NBomber Nedir?

NBomber yük testleri ve stres testleri yapmak için geliştirilen, açık kaynak kodlu ve .NET tabanlı bir performans test aracıdır. Her ne kadar açık kaynak kodlu olsa da lisans politikası onu kişisel kullanım için ücretsiz kılarken, ticari lisanslar için ücret talep etmekte.

NBomber henüz cloud ortamda bir desteğe sahip olmasa da yakın zamanda geleceğini web sitelerinde de görebilirsiniz. Ayrıca bu kısımda mevcut lisans ücreti politikasını da görebilirsiniz.

NBomber’ın Öne Çıkan Özellikleri Nelerdir

✅ Platform Bağımsız Çalışabilme

.NET Core tabanlı olduğı için herhangi bir sisteme bağımlı olmak zorunda değilsiniz. Ayrıca dockerize etmek de çok basit. Özellikle Visual Studio ya da Rider gibi IDE’ler kullanıyorsanız bu daha da basit halde.

✅ Zengin Protokol Desteği

NBomber, sadece HTTP testleri yapmak için tasarlanmış gibi durabilir ancak bunun dışında WebSockets, gRPC, Kafka, AMQP, SQL gibi protokollerde de testler yapmanıza olanak sağlar.

✅ Esnek API Desteği

NBomber dokümanlarında da göreceksinizdir ama buradan da belirtmek isterim, dilediğinizde kendi Sinklerinizi yaratabilmeniz için geliştirici dostu bir API mevcut.

✅ Gelişmiş / Görsel Raporlama

NBomber’da dilerseniz test sonuçlarını JSON, CSV ya da HTML olarak alabilirsiniz. Örnek bir rapor aşağıda yer almaktadır.

https://nbomber.com/assets/reports/html_report.html

Bunun dışında gerçek zamanlı olarak da raporlama yapabilmek için aşağıdaki sinkler desteklenmektedir;

• InfluxDB
• TimescaleDB
• Grafana

Bu bahsettiğim sinkler’i kendiniz de geliştirebilirsiniz. Bunun dışında bir veri tabanında tutmak istiyorsanız da yine kendi implementasyonunuzu yapabilirsiniz.

✅ Dağıtık Cluster Desteği

NBomber, dağıtık cluster desteği sağlar. Distributed mode’da milyonlarda kullanıcı varmış gibi simultane testler yapabilirsiniz. Bunu yine bahsettiğim gibi cluster ile yapabilirsiniz.

Overview | NBomber

✅ CI/CD Entegrasyonu

Testlerinizi otomatik olarak çalıştırmak için CI/CD pipelinelarınıza NBomber’ı ekleyebilirsiniz. Olası performans düşüşlerini yakalayabilmek için assertion ve thresholdlar tanımlayabilirsiniz. Kendi örnekleri şu şekilde;

NBomber/examples/xUnitExample/LoadTestExample.cs at dev · PragmaticFlow/NBomber

Aslında burada xUnit ya da NUnit gibi testler içerisinde de NBomber’ı kullanabilirsiniz. Detaylı bilgi şurada yer almaktadır;

Asserts and Thresholds | NBomber

NBomber ile Örnek Yük Testi Uygulaması

Bu kadar çok detay verdik ancak NBomber nasıl istediğimiz işleri yapar onu henüz konuşmadık.

NBomber temelde, senaryolardan oluşur ve bu senaryolar da kendi içerisinde adımlara sahiptir. Adımları da kullanıcı davranışı olarak düşünebilirsiniz. Örnek senaryolarımızda bu hareketleri tek bir kullanıcının yaptığını da düşünebilirsiniz. Kodlamayı yaparken de bunu göreceğiz. Ama önce NBomber’ı projemize dahil edelim.

dotnet add package NBomber

Projemizi oluşturduğumuzu varsaydığım için direkt yukarıdaki komutla dahil ettim. Şimdi ilk senaryomuzu oluşturalım.

using var httpClient = new HttpClient();
var ilkSenaryo = Scenario.Create("httpbin_ilk_test", async context =>
{
    var response = await httpClient.GetAsync("https://httpbin.org/get");

    return response.IsSuccessStatusCode ? Response.Ok() : Response.Fail();
}).WithLoadSimulations(Simulation.KeepConstant(10, TimeSpan.FromSeconds(30)));

NBomberRunner
.RegisterScenarios(ilkSenaryo)
.Run();

Bu örnekte httpbin adresine, 10 sanalkullanıcıyla sabit olarak 30 saniye boyunca istek atıyoruz. Burada örnek çıktı şöyle oluyor

scenario: httpbin_ilk_test
  - ok count: 1624
  - fail count: 0
  - all data: 0 MB
  - duration: 00:00:30

load simulations:
  - keep_constant, copies: 10, during: 00:00:30

┌─────────────────────────┬─────────────────────────────────────────────────────────────┐
│                    step │ ok stats                                                    │
├─────────────────────────┼─────────────────────────────────────────────────────────────┤
│                    name │ global information                                          │
│           request count │ all = 1624, ok = 1624, RPS = 54.1                           │
│            latency (ms) │ min = 135.86, mean = 182.28, max = 1118.07, StdDev = 121.53 │
│ latency percentile (ms) │ p50 = 140.29, p75 = 141.57, p95 = 449.28, p99 = 748.03      │
└─────────────────────────┴─────────────────────────────────────────────────────────────┘

Burada basit bir senaryo tanımını gördük. LoadSimulation tanımı ise yine en basitlerinden birisiydi. Diğer simülasyon türleri aşağıda yer almaktadır;

Load Simulation | NBomber

Biz yine de açıklayalım.

KeepConstant

Sabit sayıda sanal kullanıcıyı belirli bir süre boyunca çalıştırır. Örneğin, 10 kullanıcı 30 saniye boyunca sürekli test isteği gönderir.

Inject

Her saniyede belirli bir sayıda yeni kullanıcı başlatır. Örneğin, her saniye 5 yeni kullanıcı başlatılır ve 30 saniye boyunca çalıştırılır.

RampConstant

Kullanıcı sayısını belirli bir süre boyunca kademeli olarak artırır. Örneğin, ilk başta 1 kullanıcıyla başlar, sonra yavaşça 50 kullanıcıya çıkar.

RampInject

İstek oranını (TPS — Transactions Per Second) kademeli olarak artırır. Örneğin, ilk başta her saniye 1 istek atılır, sonra giderek artar.

InjectRandom

İstek oranını belirli bir aralıkta rastgele değiştirerek gönderir. Örneğin, bir saniyede 1 ile 10 arasında değişen sayıda istek gönderir.

IterationsForConstant

Belirli bir kullanıcı sayısını sabit tutarak, her bir kullanıcının belirlenen toplam iterasyon sayısına ulaşana kadar testin devam etmesini sağlar.

IterationsForInject

Belirli bir hızda (rate) yeni kullanıcılar (sanal kullanıcılar) başlatarak, toplam belirlenen iterasyon sayısına ulaşana kadar testi devam ettirir.

Pause

Bir senaryonun belirli bir süre boyunca duraklatılmasını sağlar.
Bu, senaryonun başlamasını geciktirmek veya çalışma sırasında bir ara vermek için kullanılabilir.

Burada bahsedilen simülasyon ayarları istenirse appsettings dosyasında da yer alabilir.

Load Simulation | NBomber

Konudan uzaklaşmadan son olarak da step tanımlarını görelim.

using var httpClient = new HttpClient();
var ilkSenaryo = Scenario.Create("httpbin_ilk_test", async context =>
{
    await Step.Run("sadece_get_requesti", context, async () =>
    {
        var response = await httpClient.GetAsync("https://httpbin.org/get");

        return response.IsSuccessStatusCode ? Response.Ok() : Response.Fail();
    });

    await Step.Run("query_string_ile_get_requesti", context, async () =>
    {
        var response = await httpClient.GetAsync("https://httpbin.org/get?kullaniciadi=ali");

        return response.IsSuccessStatusCode ? Response.Ok() : Response.Fail();
    });

    return Response.Ok();

})
.WithLoadSimulations(Simulation.KeepConstant(10, TimeSpan.FromSeconds(30)));

NBomberRunner
.RegisterScenarios(ilkSenaryo)
.Run();

Stepler için kullanıcı davranışlarını tanımlarız demiştim. Bu örnek uygun olmasa da nasıl tanımlandığını görmek açısından iyi olabilir.

Birden fazla step arasında veri paylaşımı yapılabilir. Bu işlemler şöyle yapılabilir;

• ResponseType ile
• ScenarioContext.Data ile
• Closure Variable ile

Üç şekilde de veri paylaşabilirsiniz. Şu an için bu yazıda böyle bir örnek göstermeyeceğim. Yukarıdaki senaryoyu çalıştırınca aşağıdaki çıktıyı alıyoruz. Bu sefer örneğin ekran görüntüsünü atacağım.

Size ek olarak bazı linkler de paylaşacağım. Bunlardan birisi NBomber Studio. Kısacası çalışan testler grafik arayüzü ile görebileceğiniz bir web tabanlı arayüz.

NBomber Studio

Overview | NBomber

Aslında burada yer alan link bu arayüzü gösteriyor.

NBomber

Raporlar

Eğer varsayılan olarak bir klasör tanımı yapmadıysanız raporlarınız, uygulama dizini altındaki reports klasörüne kayıt ediliyor. Bu bilgiyi de şöyle veriyor

22:33:23 [INF] Reports saved in folder: "D:\Tests\ConsoleApp4\ConsoleApp4\reports\2025-02-02_19.32.04_session_85af8b5e"

Bu klasörün içeriği de şöyle oluyor

Örneğin steplerle beraber son oluşan testimiz için HTML rapor çıktısı şu şekilde yer alıyor

Hepsi bu kadardı. Okuduğunuz için teşekkür ederim. Umarım sizlere faydalı olabilecek bir paylaşım olmuştur.

Kaynaklar

• https://nbomber.com/docs/getting-started/overview/

Even though I mentioned this in the first sentence, I made the career change I discussed in my 2023 Recap. This was one of the good things about 2024 for me.

2023 Yılının Özeti

My Father Had Surgery

After February, we started frequent hospital visits because of my father’s thyroid issues. This process felt uncomfortably long for me.

Eventually, my father had thyroid surgery, and his thyroid was removed. The pre-surgery process, the surgery itself, and the post-surgery recovery period exhausted me. For months, we went back and forth to the hospital — endless tests, getting results, and doctor check-ups. At some point, I realized how utterly drained I was.

If I remember correctly, it was around June when we were told during a post-surgery check-up that everything was fine. That made me happy. But just think about it — a process that started in February lasted until June. It wore me out.

In this case, General Surgery Specialist Aygün Aliyeva performed my father’s surgery. I can’t thank her enough. Looking back now, I realize it was a very well-done operation.

Op. Dr. Aygün Aliyeva

My Mother Had Surgery

After that, although I can’t remember the exact date, it was either July or August when my mom had eye surgery. She had a condition that could have left her almost blind — her cataract was very advanced.

I’m writing this based on what her doctor said, though I knew this condition had been there for 10–15 years. Thankfully, this surgery also went well. Still, it took about a month of back-and-forth hospital visits.

This was my second surgery adventure in 2024. :)

My Father Had Surgery Again

Just when I started to think I was feeling relieved, my father’s hemorrhoid problem came up. Unfortunately, this was another long-standing issue that had worsened over the years because my father neither paid attention to it himself nor listened to us or the doctors.

This process drained me so much. My father’s first surgery and my mother’s surgery hadn’t been this exhausting. Because of the blood loss my father experienced before the surgery, we were going to the hospital almost every other night. I spent the hours I should’ve been sleeping at the hospital, and then I worked during the day. I know I didn’t get proper sleep for about two weeks.

While trying to manage my work successfully, I also went through a psychologically challenging time. But I managed to get through it, thanks to the people around me. Just having them there was enough for me.

It’s been about 1.5 months since his surgery, and he suffered for the first month. Seeing him comfortable now makes me happy. I hope I don’t face another surgery during the rest of 2024.

By the way, during these surgeries and the preparation processes, my migraines became so intense that the doctor had to inject me in my forehead and the back of my head. I couldn’t even lower my head because the moment I did, I’d experience an extreme headache.

As a result, I was asked to get an MRI. Thankfully, everything came out fine with me. :)

Not Everything Was Bad!

Even though I couldn’t take a vacation this year due to these reasons, some good things happened too. For example, I moved to a nicer house. Of course, that was thanks to my manager(H. Yusuf Yavuz) 😛

I also met a very skilled, knowledgeable, and great conversationalist CTO in 2024. Having the chance to learn from him has been a real privilege for me.(Gürkan Sel)

We launched many new projects, and these projects taught me a lot. Although the increase in my responsibilities sometimes tired me out, I learned how to handle it.

What is a source of stress for many became a game of time management for me.

Even though I can’t fully explain the details of these processes that contributed so much to my career, I’m happy with the work we accomplished in such a short time.

Also, one of the good things about 2024 was working at the same place as a friend like Mustafa Dikyar — someone whose advice I didn’t always follow but who still treated me with understanding.

I almost forgot! After swearing I’d never wear shirts or ties and making such bold statements, I’ve actually started enjoying it now. Really!

Even if I tie my tie crooked, I don’t care. Feels like it’ll fix itself at some point :)

For this, I owe endless thanks to Oğuz kumcular and his amazing wife, my buddy. Otherwise, I wouldn’t have much of a clue about dressing up :)

Also, my birthday was celebrated for the first time in years. Normally, I’m not the kind of person for such things, but the fact that my friends did this made me incredibly happy ❤ (Getting emotional here).

This year, my cat pulled off some funny mischief that made us all laugh. That’s another reason I’m happy :)
At a moment when we were really worried because we thought it had gone outside and gotten lost, it suddenly appeared in a box on top of the kitchen cabinet :)
After many years, I went to Balıkesir. I went with my manager(H. Yusuf Yavuz), and it was truly a great experience for me. It’s such a beautiful place to live.

Other than that, I’d love to mention the amazing people at work here, but I can’t because I’m not sure if they have accounts or not.

By the way, I’m trying to improve my English level. I’ve made some progress through TV shows and writing like this, but since I don’t have any speaking practice, my speaking skills are non-existent.

Maybe I can work on this weakness in 2025.

What Are My Expectations for 2025?

First of all, I don’t want any more surgeries or health problems. Please!

After that, I want health, happiness, and peace once again — for the whole world. I wish for a year where everyone talks about good things, has fun, and is free from wars and deaths.

These are just wishes, though. You know, Santa Claus isn’t real either. So, it’s not going to happen…

Best Regards!

https://unsplash.com/photos/man-in-black-jacket-holding-camera-CTflmHHVrBM
Selamlar. Bu yazıda Design Patterns konularından olan Creational Patterns konusu hakkında bilgi vermeye çalışacağım. Türkçede çeviri olarak “Yaratımsal Tasarım Desenleri” olarak biliniyor. Birazcık anlamsal zorluğa sahip gibi geliyor.

Creational Patterns Nedir? Ne İş Yapar?

Aslında bu türden creational design patterns konusundan bahsederken, nesnelerin nasıl oluşturulacağından ve yönetileceğinden de bahsetmiş oluyoruz.

Nesne oluşturma işlemlerinde yaşanan karmaşayı azaltmayı hedefler. Bunun yanında koda esneklik kadar. Yeniden kullanılabilirlik katar.

Bana Creational Patterns Listesini Ver!

Hay hay! Aşağıdaki design pattern konularını mutlaka duymuşsunuzdur. Bunlar creational patterns olarak da bilinir.

Singleton Design Pattern

Singleton design pattern, bir sınıfın sadece bir örneğinin olmasını garanti eden bir patterndir. Tabiiki burada hatalı kodlanmış bir singleton örneğinden bahsetmiyorum. Design pattern buradaki konumuzdur. Bu design pattern’den bahsederken, aklınıza logging, configuration ya da database konuları gelebilir.

Veri tabanı ya da logger örnekleri gerçek hayat senaryoları içerisinde en çok karşılaşacağınız örnekler olabilir.

Factory Method Pattern

Bu design pattern’da nesnelerin oluşturulması alt sınıflarda gerçekleştirilir. Bunu yaparken de bir interface kullanılır. Bu sayede nesnelerin oluşturulması soyut bir hale gelirken, alt sınıflarda da hangi nesnelerin oluşturulacağı belirlenir.

Örneğin “ZubiZaretta” isimli bir e-ticaret sitemiz olsun. Bu sitede ödeme işlemleri yapılıyor. Kredi kartı, havale ya da örneğin yurt dışında da PayPal olsun. Elimizde aşağıdaki ödeme yöntemleri mevcut

• Kredi kartı
• PayPal
• Havale

Factory Method Pattern kullanarak farklı olan bu ödeme yöntemleri yönetilebilir. Kod örneğini burada paylaşmak yazıyı uzatak ama faydasını şöyle gösterebilirim

ProcessPayment(new CreditCardPaymentProcessorFactory(), 200m);

void ProcessPayment(PaymentProcessorFactory factory, decimal amount)
{
    IPaymentProcessor processor = factory.CreatePaymentProcessor();
    processor.ProcessPayment(amount);
}

Yukarıdaki koda bakarak bu kodun logic değiştirmeden, genişletilebilir bir kod olduğunu görmüş oluyoruz. 1 ay sonra Abuzittin isimli ödeme yöntemi gelseydi şöyle bir kod işimizi çözecekti.

ProcessPayment(new CreditCardPaymentProcessorFactory(), 200m);
ProcessPayment(new AbuzittinPaymentProcessorFactory(), 200m);

void ProcessPayment(PaymentProcessorFactory factory, decimal amount)
{
    IPaymentProcessor processor = factory.CreatePaymentProcessor();
    processor.ProcessPayment(amount);
}

Factory sınıflarının kendi içlerindeki davranışları, o sınıfları bağlar. Örneği kredi kartı kuruluşunun API’ları ile Abuzittin’in aynı olmayabilir. Söylemek istediğim bu. Ama siz asla ve asla asıl payment adımında bir değişiklik yapmazsınız.

Abstract Factory Pattern

Bu design pattern Factory Method Design Pattern ile çok karıştırılıyor. Factory Method DP’de ortak bir interface ile işleri halledebilirken, Abstract Factory DP’de ise birden fazla nesnenin arayüzüne göre işleri hallederiz.

Sıkça verilen bir örnek üzerinden gitmek istiyorum. Örneğin mobilya üreten bir fabrikamız var. Bu fabrikada eski tür ve modern mobilyalar üretiliyor. Sandalye ve masalar olsun. Bunları üretirken yazılımsal olarak ortaya çıkan karmaşayı Abstract Factory Pattern ile çözebiliriz. Aslında buna karmaşa demem ama anlaşılması için öyle diyorum. Yaklaşımımız şöyle olur;

• Abstract Factory
• Concrete Factory
• Abstract Product
• Concrete Product
• Client

Abstract factory ve abstract product’lar interface’leri içerirken, concrete factory ve product’lar ise implementasyonları içerir. Client ise burada kullanıcıdır.

Mesela sandalyeleri abstract factory olarak ISandalye olarak düşünelim. Yine IMasa da burada. Bunların implementasyonu Concrete Factory’de gerçekleştirilir.

Abstract Product dediğimiz factory interface ise bahsedilen 2 interface’i kullanır. Örneğin IUretimFactory adında bir interface olsun. Bu interface’in memberları ISandalye ve IMasa türünden 2 method olsun.

Concrete Product dediğimiz sınıflar ise bu bahsettiğimiz Abstract Product’ı implement eder.

Örneğin “FuturistikMobilya” adında 3. türden bir mobilya işimiz olsaydı, sadece FuturistikMobilya sınıfını ve bu sınıfı yönetmek için bir de factory sınıfını eklememiz yetecekti. Haliyle kod genişleyebilir durumda olurdu. Mevcut kodumuz değişmeden de yeni özellikler eklenebilir olurdu.

Builder Pattern

Bu design pattern kullanılarak karmaşıklığı yüksek nesnelerin adım adım oluşturulması sağlanır. Bu bize bir işin adımlara bölünerek yapılabileceğini söyler. Yine bu adımların yönetilmesi için de bir Builder sınıf kullanılır. Yapısal olarak şöyledir;

• Product
• Builder
• ConcreteBuilder
• Director

Gerçek dünya örneği birazcık acıkmamla alakalı olarak peynir üretim sürecini içerecek. Peynirin nasıl üretileceğini bilmesem de içerisindeki temel ürünleri koyduğumuzu söyleyelim. Normalde bu yazıda kod örneği vermeyecektim. Ancak kod örneği bu pattern’i çok iyi açıklar.

• Süt
• Yoğurt
• Tuz

Şimdi sınıfınızın bu 3 property’e sahip olduğunu düşünün. Yani peyniri yaparken 3 farklı ürünü set etmeniz karışıma eklemeniz gerekiyor. Bunun class’ı nasıl olurdu?

internal class Peynir
{
    public double Sut { get; set; }

    public double Yogurt { get; set; }

    public double Tuz { get; set; }
}

Ne demiştik yapılan işi süreçlere bölerek peyniri üreteceğiz. O zaman bu cümlesini kurduğumuz işin bir de arayüzünü kurgulayalım.

internal interface IPeynirBuilder
{
    void SetSut(double oran);

    void SetYogurt(double oran);

    void SetTuz(double oran);

    Peynir GetPeynir();
}

Şimdi elimizde peynir sınıfı ve bir de Builder arayüzü var. Bu bilgilerle beyaz peynir üretelim.

internal class BeyazPeynirBuilder : IPeynirBuilder
{
    private Peynir _peynir = new Peynir();

    public void SetSut(double oran)
    {
        _peynir.Sut = oran;
    }

    public void SetTuz(double oran)
    {
        _peynir.Tuz = oran;
    }

    public void SetYogurt(double oran)
    {
        _peynir.Yogurt = oran;
    }

    public Peynir GetPeynir()
    {
        return _peynir;
    }
}

E beyaz peyniri ürettik, bir de gelin kaşar peynir üretelim. Tabiiki kaşar peynir 2–3 malzeme ile üretilmiyor. Amaç burada süreci anlamak.

internal class KasarPeynirBuilder : IPeynirBuilder
{
    private Peynir _peynir = new Peynir();

    public void SetSut(double oran)
    {
        _peynir.Sut = oran;
    }

    public void SetTuz(double oran)
    {
        _peynir.Tuz = oran;
    }

    public void SetYogurt(double oran)
    {
        _peynir.Yogurt = oran;
    }

    public Peynir GetPeynir()
    {
        return _peynir;
    }
}

Yapısal olarak bahsettiğimiz kısımda Director’den bahsetmiştik. Şimdi bu işi PeynirUretici isimli sınıfta yapalım.

internal class PeynirUretici
{
    private IPeynirBuilder _builder;

    public PeynirUretici(IPeynirBuilder builder)
    {
        _builder = builder;
    }

    public void BeyazPeynirUret()
    {
        _builder.SetSut(5);
        _builder.SetYogurt(2);
        _builder.SetTuz(0.4);
    }

    public void KasarPeynirUret()
    {
        _builder.SetSut(7);
        _builder.SetYogurt(10);
        _builder.SetTuz(2);
    }

    public Peynir GetPeynir()
    {
        return _builder.GetPeynir();
    }
}

Artık kullanımı da şöyle olur :)

IPeynirBuilder beyazPeynirBuilder = new BeyazPeynirBuilder();
PeynirUretici peynirUretici = new PeynirUretici(beyazPeynirBuilder);
peynirUretici.BeyazPeynirUret();
var beyazPeynir = peynirUretici.GetPeynir();

Aynısını kaşar peynir için de yapabilirsiniz.

Prototype Pattern

Son design pattern olan prototype pattern’a geldik. Bu design pattern’da mevcut bir nesnenin klonlarını oluşturarak yeni nesneler oluşturulur. Aslında bu cümle hatalı. Sıfırdan bir nesne oluşturmuyor. Var olan bir nesnenin kopyasını oluşturuyor. Yeni bir nesne oluşturmanın bir hayli maliyetli olduğu süreçlerde prototype pattern kullanılır. Nesnelerin oluşturulma süreçleri hızlanır. Yapısal olarak aşağıdaki gibidir;

• Prototype
• ConcretePrototype

Örneğin bir doküman yönetim sisteminde raporların, sözleşmelerin yönetilmesi için bir örneğimiz olsun. Örneğin şöyle bir sınıfımız olsun

internal abstract class Document
{
    public string Id { get; set; }
    public string Title { get; set; }

    public abstract Document Clone();
}

Clone işlemi yapan abstract bir metoda sahibiz. Dokümanın kendisini klonlar.

Sonrasında rapor ve sözleşme için aşağıdaki sınıflarımızın olduğunu hayal edin.

internal class Report : Document
{
    public int PageCount { get; set; }

    public override Document Clone()
    {
        return (Document)MemberwiseClone();
    }

    public override string ToString()
    {
        return $"Report: Id={Id}, Title={Title}, PageCount={PageCount}";
    }
}

internal class Contract : Document
{
    public string PartiesInvolved { get; set; }

    public override Document Clone()
    {
        return (Document)MemberwiseClone();
    }

    public override string ToString()
    {
        return $"Contract: Id={Id}, Title={Title}, PartiesInvolved={PartiesInvolved}";
    }
}

Hem rapor hem de sözleşmelerin cache’lendiği ve klonlandığı işi yapan DocumentCache sınıfı ise şöyle olsun

internal class DocumentCache
{
    private static Dictionary documentMap = new Dictionary();

    public static Document GetDocument(string documentId)
    {
        Document cachedDocument = documentMap[documentId];
        return cachedDocument.Clone();
    }

    public static void LoadCache()
    {
        Report report = new Report { Id = "1", Title = "Annual Report", PageCount = 50 };
        documentMap[report.Id] = report;

        Contract contract = new Contract { Id = "2", Title = "Sales Contract", PartiesInvolved = "Company A & Company B" };
        documentMap[contract.Id] = contract;
    }
}

Bu yapıyı kullanan örnek bir kodumuz şöyle olsun;

DocumentCache.LoadCache();

while (true)
{
    Console.WriteLine("Choose document to clone:");
    Console.WriteLine("1. Report");
    Console.WriteLine("2. Contract");
    Console.WriteLine("0. Exit");
    string choice = Console.ReadLine();

    if (choice == "0")
    break;

    Document clonedDocument = null;
    switch (choice)
    {
        case "1":
        clonedDocument = DocumentCache.GetDocument("1");
        break;
        case "2":
        clonedDocument = DocumentCache.GetDocument("2");
        break;
        default:
        Console.WriteLine("Invalid choice.");
        continue;
    }

    if (clonedDocument != null)
    {
        clonedDocument.Id = Guid.NewGuid().ToString();
        Console.WriteLine("Cloned Document:");
        Console.WriteLine(clonedDocument);
    }
}

Hepsi bu kadar. Umarım sizin için faydalı olmuştur. Okuduğunuz için teşekkür ederim.

Kaynaklar

• https://refactoring.guru/design-patterns/creational-patterns
• https://en.wikipedia.org/wiki/Factory_method_pattern

Selam herkese. Bir önceki yazıda CDC ve Change Tracking hakkında ufak bir girizgahta bulunmuştum;

SQL Server’da Veri Değişikliklerini İzlemek: CDC ve Change Tracking Nedir?

Şimdi bu yazıyı teoriden pratiğe dökelim ve örnek bir uygulama yapalım.

Gereksinimler

• Docker
• SQL Server
• AdventureWorks veri tabanı

Bu gereksinimler, bu yazı için olan gereksinimlerdir. Docker ve AdventureWorks veri tabanı tamamen benim çalışma ortamım için gerekli. Siz kendi veri tabanınızda bu çalışmaları gerçekleştirebilirsiniz.

Kurulum

Eğer daha önce Docker üzerinde bir MSSQL kurulumu yapmadıysanız aşağıdaki şekilde kurulumu gerçekleştirebilirsiniz.

docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=BenimP@r0lam1923" --env MSSQL_AGENT_ENABLED=True -p 1433:1433 --name localSqlServer --hostname localSqlServer -d mcr.microsoft.com/mssql/server:2022-latest

Bu kurulumda bir envorinment variable tanımladık dikkatini çekmediyse belirteyim. MSSQL_AGENT_ENABLED=True bu tanım ile birlikte SQL Server Agent’ını da aktif ediyoruz. Eğer aktif etmezseniz, CDC çalışmaz, değişiklikler algılanmaz.

Eğer daha önceden MSSQL kurduysanız ancak agent aktifleştirme işlemi yapmadıysanız docker’da MSSQL uygulamasının shell’ine girmelisiniz. Daha sonra aşağıdaki komutu çalıştırmanız gerekiyor;

/opt/mssql/bin/mssql-conf set sqlagent.enabled true

Daha sonranda container’ı durdurup baştan başlatmanız yeterlidir. Eğer systemctl bu sistemde mevcut ise aşağıdaki komutu vermeniz yeterlidir;

systemctl restart mssql-server.service

Evet hepsi bu kadar. Ben bu yazı için yukarıda da bahsettiğim gibi AdventureWorks veri tabanını kullanıyorum. Aşağıdaki linkten indirebilirsiniz;

https://github.com/Microsoft/sql-server-samples/releases/download/adventureworks/AdventureWorks2022.bak

Daha sonrasında bu restore etmeniz gerekiyor. Bu aşamayı SQL Server Management Studio ya da kullanıyorsanız DataGrip ile yapabilirsiniz.

Evet kurulum aşaması bu kadardı.

Change Data Capture Özelliğini Aktif Etmek

Bu özelliği aktif etmek için öncelikle CDC’yi veri tabanı seviyesinde aktifleştirmemiz gerekiyor. Bunu aşağıdaki SQL kodu ile yapıyoruz;

USE AdventureWorks2022
GO
EXEC sys.sp_cdc_enable_db
GO

Bu değişiklik ile cdc adında bir şema oluşuyor. Ancak henüz bir tablo seviyesinde ayar yapmadık bunu belirteyim. Oluşan cdc şeması aşağıdaki gibi görünüyor;

Burada değişiklik algılanacak kolonlar, tablolar, DDL geçmişi gibi bilgiler yer alıyor. Ancak dediğim gibi henüz tablo seviyesi bir ayar yapmadığımız için şu anda bu tabloların tamamı boş durumda.

Eğer veri tabanı seviyesinde CDC işlemini kapatmak isteseydik aşağıdaki komutu kullanacaktık;

USE AdventureWorks2022
GO
EXEC sys.sp_cdc_disable_db
GO

Her şey okey, önceki yazıda bahsettiğim rollere sahip olduğumuzu varsayarak o kısımlara değinmedim. Artık tablo seviyesinde aktif etme işlemine geçebiliriz. Aşağıdaki SQL kodu ile tablo ve schema seviyesinde aktifleştirme işlemini gerçekleştirebiliriz;

USE AdventureWorks2022
GO
EXEC sys.sp_cdc_enable_table
    @source_schema = N'HumanResources',
    @source_name   = N'Department',
    @role_name     = NULL,
    @supports_net_changes = 1
GO

Yukarıdaki SQL kodu HumanResources şemasında yer alan Department tablosundaki değişiklikleri dinleyecek asenkron işlemi aktif ediyor.

• source_schema — Şema bilgisi
• source_name — Tablo bilgisi
• role_name — Hangi rolde çalışılacağı bilgisini içerir. Eğer bu parametre NULL olarak ayarlanırsa veya belirtilmezse, varsayılan olarak CDC verilerine sadece sysadmin rolü ve db_owner veritabanı rolünün üyeleri erişebilir. Bu durum, CDC verilerinin güvenliğini sağlamak ve yalnızca yetkili kullanıcıların veya rollerin bu verilere erişimini kontrol etmek için önemlidir.
• supports_net_changes — Sadece nihai değişiklik bilgisini içerir. Yani bir satırdaki bir bilgi birden fazla defa değişikliğe uğradıysa en son veriyi tutar.

Bir de yukarıda yer almayan bir değer daha var.

• filegroup_name — cdc’nin hangi filegroup içerisinde yer alacağını belirtir. Varsayılan olarak cdc default file group altında yer alır.

Açıklamalar bu kadar. Şimdi bu SQL kodunu çalıştıralım. Ben aşağıdaki gibi bir çıktıyı DataGrip üzerinden aldım.

[2024-03-17 17:56:00] [S0001][22969] Update mask evaluation will be disabled in net_changes_function because the CLR configuration option is disabled.
[2024-03-17 17:56:00] [S0001][14243] Job 'cdc.AdventureWorks2022_capture' started successfully.
[2024-03-17 17:56:00] [S0001][14243] Job 'cdc.AdventureWorks2022_cleanup' started successfully.
[2024-03-17 17:56:00] completed in 6 s 274 ms

Yukarıda 2 adet job’ın tanımlı olduğunu görüyoruz. Bunlardan ilki veri değişikliklerini yakalarken, diğeri de otomatik olarak cdc tablosunda cleanup işlemi gerçekleştirir. Varsayılan cleanup ise 3 günlük bir süreye sahip. Yani retention süresi 3 gün. Şimdi cdc tablolarındaki değişikliklere bir bakalım.

captured_columns tablosunun değiştiğini, yani içerisine yeni veriler eklendiğini görmekteyiz.

change_tables da yine değişlik içermekte. Yani yeni bir satır eklendiğini görmekteyiz;

Tabii bunlar olmadan CDC’nin enabled olup olmadığını veri tabanı seviyesinde ayrıca şöyle bir sorgu ile görebiliriz;

SELECT name, is_cdc_enabled FROM sys.databases

Gördüğünüz gibi veri tabanı seviyesinde aktif olduğunu görebiliriz. Ayrıca CDC şemamıza içi boş olan yeni bir tablo daha katıldı. HumanResources_Department_CT adında bu tablo değişiklik kayıtlarının tutulacağı bilgiyi içerir. Dolu veri ile örneğini inceleyeceğiz.

Bu aşamadan sonra Department tablosunda ilk satırda bir değişiklik gerçekleştireceğim. Engineering olan Name kolonu değerini Engineering Department yapacağım. Ve CT yani Change Tracking tablosuna aşağıdaki 2 satır yansıdı.

Tabloya bakınca 2 farklı veri görüyorsunuz. Aslında neyin önce neyin sonra olduğunu anlayabilirsiniz. Fakat bunları daha kolay anlayabilmenin bir yolu daha var. 2 Satırlık verilerle bunları görmek daha kolay iken, binlerce satırda bu iş daha zor olabiliyor.

__$operation Kolonu Değerleri ve Açıklamaları

• 1 — Delete sorgularında bu değer kullanılır. Yani bir satırın silindiğini görebiliriz.
• 2 — Insert işleminde bu değer kullanılır.
• 3 — Before Update işlemi olarak geçer. Güncelleme işlemi yapılmadan önceki kaydın durumunu temsil eder. Bu, bir güncelleme işleminin “önceki” durumunu belirtir ve genellikle net değişikliklerin hesaplanmasında kullanılır.
• 4 — After Update işlemi olarak geçer. Güncelleme işleminden sonra kaydın durumunu temsil eder. Bu, bir güncelleme işleminin “sonraki” durumunu temsil eder ve güncellenmiş değerleri gösterir.

Tablo seviyesinde yapılan bu işlemi disable etmek istersek de aşağıdaki SQL kodunu kullanmamız gerekiyor;

USE AdventureWorks2022
GO
EXEC sys.sp_cdc_disable_table
    @source_schema = N'HumanResources',
    @source_name   = N'Department',
    @capture_instance   = N'HumanResources_Department',
GO

Genel olarak CDC işlemi temel olarak böyle. Tablo seviyesinde yapılan işlemler için ayrıca sadece kolon seviyesinde change tracking işlemi yapılabilir. Bu konuya şimdilik girmedim. Kaynaklar tarafında vereceğim linkten ulaşabilirsiniz.

Sonuç olarak CDC mükemmel bir özellik, ancak CDC tablolarında yer alan bu satırları böyle veri tabanından okumak çok zahmetli olabilir. Mesela şöyle bir süreç için zahmetli olabilir.

Satış yapıldığını varsayalım. Bu satışın verisi hem data warehouse’a aktarılacak hem de başka bir API’a bildirilecek. Bu gibi durumlarda bu tabloyu da ayrıca sürekli dinleyen bir çözüm üretmek gerekebilir.

Veri tabanındaki değişiklikleri CDC’yi kullanarak bir mesaj kuyruğuna stream etmek buradaki en iyi çözüm olabilir. Bunun için de Debezium kullanılabilir.

Debezium

Debezium aslında tam olarak bu iş için var. Örnek senaryomuz yukarıdaki senaryo olsun. Debezium, CDC tarafındaki verileri alsın ve belirttiğiniz bir Kafka kuyruğuna bassın. Siz de bu kuyruğu kullanarak data warehouse’a ve API endpointlerine yeni verileri aktarın. Bu gerçekten, custom solution implement etmekten daha da basit hale geliyor.

Hepsi bu kadar. Okuduğunuz için teşekkür ederim.

Kaynaklar

• https://learn.microsoft.com/en-us/sql/relational-databases/track-changes/enable-and-disable-change-data-capture-sql-server?view=sql-server-ver16
• https://debezium.io/
• https://stackoverflow.com/questions/69038304/how-enable-sql-server-agent-in-docker-container-existing
• https://docs.rivery.io/docs/sql-server-cdc-troubleshooting

Herkese selamlar. Son yazının üzerinden 240 yıl falan geçti. Bu yazıyı da arayı fazla uzatmamak adına yazmak istedim.

Şimdi bu yazının konusu CDC yani Change Data Capture olayı. Bir de yan sanayi olarak Change Tracking olayı var. Aslında ikisi de aynı işi yapıyorlar. Sadece maliyet noktasında farklılıkları var.

Change Data Capture, SQL Server’a has bir özellik değil bu arada. Bunu destekleyen farklı veri tabanları da var. Örneğin PostgreSQL, MySQL, MongoDB gibi. Ama bu yazıda ben SQL server üzerine yoğunlaşmak istedim.

Not: Bu yazı sadece CDC ve Change Tracking nedir onu anlatıyor. Diğer yazılarda ise uygulama aşamasına geçerek örnekler sunmak istiyorum.

CDC Tam Olarak Neyi Anlatıyor?

CDC ya da diğer bir özellik olan Change Tracking kavramları, bize veri tabanındaki değişikliklerin anında yakalanmasını ve başka bir yere loglanmasını anlatıyor gibi basit bir şey söyleyebilirim.

Normalde bu işlemler için, client tarafında AOP yaklaşımlı çözümler mevcut iken(Entity Framework tarafında da yine bu işlemler uygulama içerisinde yapılabilmekte), bu yaklaşımda böyle bir gereksinim bulunmamaktadır.

Çünkü burada işlemler en azından SQL Server tarafında veri tabanı tarafından gerçekleştirilmektedir.

Uygulama dışında CDC olmadan başka neler yapılabilirdi? Belki çoktan aklınıza gelmiş olabilir. Trigger kullanımı da bu konuda size destek sağlayabilird. Ancak şu ana kadar baktığınız her şey, ekstra geliştirmeler gerektiriyor.

Faydaları Neler?

Öncelikle ilk faydası, development zamanını düşürmesidir. Yani kendiniz bu iş için ayrıca bir application logic yazmak zorunda değilsiniz.

Database şema değişikliğinin bilinmesi zorunluluğu da yok. Yani yeni kolonlar eklemek zorunda değilsiniz ya da triggerlar ya da ikinci bir tablo. Bu tablo genelde silinen ya da değişen kayıtları basit bir timestamp datası ile tutabiliyor sonuçta. Ama buna da gerek duymuyorsunuz.

Gelelim TTL, retention gibi konulara. Normalde, CDC olmasaydı, siz belirli dataları manuel bir çözüm ile silmek durumunda kalabilirdiniz. Bu tablo sadece değişenleri tutan bir tablo olduğu için, ilgili işlem bitince, silinmeleri gerekiyor sonuçta. CDC ise otomatik olarak bunu bir background task gibi süresi dolanları silerek çözmekte.

DML işlemlerinde öyle aman aman bi yük yok. Birazdan değineceğimiz Change Tracking işleminde ufak da olsa bir yük var. Ancak öyle çok da büyük bir yük değil. Yani bir manuel çözüm bu trigger vs. olabilir, bu gibi çözümlerden kesinlikle daha az yüke sahip.

Change Data Capture vs. Change Tracking Arasındaki Farklar Nelerdir?

Öncelikle her ikisi de DML değişikliklerini desteklemekte. Ayrıca DML veri türü ya da kolon değişiklikleri de bu iki işlemde desteklenmekte.

Gelelim fark noktasına. Öncelikle, CDC tarihsel veri tutarken, change tracking tutmuyor. Haliyle bu alan olarak change tracking işlemini tercih edilebilir hale getiriyor.

Fakat bir başka noktada da CDC kullanılabilir oluyor. Çünkü CDC, asenkron bir şekilde çalışırken, Change Tracking senkron bir şekilde çalışıyor.

CDC tarafında bir veri değişikliğinde kullanıcı tablosunda hem gerçekleşeni hem de gerçek datayı saklama işlemi gerçekleştirilir. Bu işlem transaction logları asenkron şekilde okunarak gerçekleştirilir. Aşağıda bir CDC işlem örneği yer almaktadır;
CDC simulasyonu
Change Tracking ise değişiklik bilgisini saklarken, (örneğin yeni bir satır eklediniz, güncellediniz ya da sildiniz) değişikliğe dair ayrıntıları belirtmez. Yani hangi veriler değişmiş bilemezsiniz. Kısacası bu işlemde hangi satırlarda değişiklik olduysa onu bilirsiniz fakat ne değişmiş bilemezsiniz. Bir de change tracking işleminde işlemler senkron olarak gerçekleştirilir, tarihsel veri tutmaz. Bu nedenle depolama noktasında daha az maliyetlidir.
Change Tracking simulasyonu
CDC işlemini database seviyesinde aktif etmek ya da pasif etmek için, sp_cdc_enable_db | sp_cdc_disable_db prosedürlerini çalıştıran kullanıcılar, sysadmin rolünde olmalıdır.

CDC işlemini tablo seviyesinde aktif ya da pasif etmek için sp_cdc_enable_table | sp_cdc_disable_table prosedürlerini çalıştıran kullanıcılar sysadmin rolünde ya da database db_owner rolünde olmalıdır. Bu ikisi farklı şeyler. Buna dikkat etmek gerekebilir.

Bu roller dışında bir kullanıcı rolü ile bu işlemler yapılamaz.

Şu anlık bu yazı bu kadar arkadaşlar. Okuduğunuz için teşekkür ederim. Haydi görüşürük ❤

Kaynaklar

• https://learn.microsoft.com/en-us/sql/relational-databases/track-changes/track-data-changes-sql-server?view=sql-server-ver16

Bu yıl çok fazla şey oldu. Yani bir tanesi dünyanın gündemine oturdu. Keşke dünya gündemine iyi bir konuyla otursaydık. Ama bir depremle yok olduk adeta.

Ben bu depremle bir arkadaşımı kaybettim. 50 bin’den fazla insan ise hayatını kaybetti. Milyonlar ise yakınlarını, Türkiye ise mutluluğunu kaybetti.

Yukarıdaki fotoğrafı gördüğümde gözlerimdeki yaşı tutamamıştım. Birçok duyguyu aynı anda yaşadım. Ama bu fotoğraftaki babanın duygularını asla anlayamam. Ölen kızının başında bekledi ve o anda yaşadıkları. Yok yine çok üzülüyorum.

Siz bakmayın epik değeri olan bu fotoğrafa. Çok uzun bir süre yardım gidemedi oraya. Sebebiyle ilgili değilim asla. Oraya gidemeyen yardımlardan dolayı birinde hakkım var ise haram olsun.

Yukarıdaki adam toplumun kahramanı olurken, teröristler onu karalamak için kampanya başlattı. Tabiiki üçün birini aldılar. Allah kimseyi bazı egolar nedeniyle enkaz altında yardım beklemeye muhtaç etmesin.

Yukarıdaki fotoğraf gibi birçok kare birçok ilde vardı. Hatta bu sene Ağustos ayında arkadaşım Elazığ’da evlendi. Oraya giderken Malatya’dan geçtik. O aylarda bile enkazlar duruyordu. Yamulmuş ama düşmemiş bir bina da bir dağın başında kurulan köyde vardı.

Bazı Geziler Falan

Arkadaşımın nişanı yapıldıktan sonraki gün Munzur’a gittik. Hayatımda ilk defa gittim oraya. Gerçekten harika bir yer. Bir zamanlar buralarda terörün çok fazla olması beni çok fazla üzdü. Çünkü böyle harika bir yerin, terör nedeniyle yıllarca ulaşılmaz oluşu çok kötüydü.

Giderken aşağıdaki kaleyi gördüm. Elazığ’dan feribot ile geçerken bu manzaraya sahip olabiliyorsunuz.

Daha sonra Tunceli içerisinde bir dağda çay içtik. Bu esnada manzaram şöyleydi.

Munzur Baba Dergah’ına gittik. Girişte şunu görüyorsunuz

Burada cerağ yaktım. Bilmediğim bir şeydi. Öğrenmiş oldum.

Daha sonra burada bu suya girdik. Gerçekten aşırı soğuk 😄 öyle böyle değil. Eve getirdik ve su hemen bitti. Aşağıda peş peşe birkaç fotoğraf gelecek.

Daha bir sürü fotoğraf var ama fotoğraflarda pozveremeyen bir salağım ben 😄

Düğünden sonraki sabah Harput kalesine çıktık. Kaleye girdik, kalenin içine girdik bildiğiniz. Rütubetli o odalara kadar. Merdivenlerden indik.

Bence herkesin gelip görmesi gereken bir yer. Ama uçakla gelin ya da arabayla geliyorsanız atmosferik motor olmasın. Böyle bir yerde yemek yedik.

Ben harput kebap ne bir şey yedim. Tadı iyiydi. Et biraz sertti. Ama tadı enfesti. Daha sonra dabakhane’ye gittik.

Tekrardan kaleye döndük harput’a. Ve birkaç fotoğraf çektim.

Ahan da fotojenik sayılabilecek düzeyde bir fotoğrafım varmış. Not: En fotojeniği bu 😛

Sonra yer altına indim yani kalenin alt kısımlarına girdik. Biraz rütubetliydi.

Baya bir aşağıya inmeniz gerekiyor 😛

Kaleden ayrıldıktan sonra dönüşte Keban Barajı’nı gördük.Lan buranın manzarası bana daha iyi geliyor ya.

Neden bilmiyorum şu manzarayı da sevdim

Daha sonra Kapadokya’ya gittim. Biraz gezdik. Yani iyiydi diyeceğim ama yok be diyemiyorum. Çok pahalı şehir. Fakat bazı fotoğraflar çekmedim değil;

Lan bu fotoda kaya sanki bir yüz ifadesine sahip gibi 😛

Asmalı Konak’a gittik 😛

Lan be şuraya bak ya :)

Yine malak gibi poz vermişim 😛

Canımızdan çok sevdiğimiz bayrağımızla fotoğraf çekinmezsek olmaz dedik ve bir fotoğraf karesinde yer aldık 😛

Not: Güzel kızlar eqlesin

Fotoğraftan gram anlamadığım için bu fotoğrafı beğendim ben. Güneş, araba, yol falan filan.

Daha sonra Nevşehir’e hacıbektaş’a gittik. Çingeneler ve suriyeliler oraya doluşmuş. Devletin uğramadığı bir yer haline gelmiş. Sanırım devletin şevkatli eli oralarda yoktu.

Ne zaman poz vermeyi öğreneceksem artık…

Burada kalacaktık ancak kalmak istemedik. Böyle güzel bir mekanı adeta yok etmişler. Gerçekten o maneviyat burada kalmamış. Gezilen her yere kakasını yapmışlar. Çilehane’ye gittik. Salak salak düşün IQ ne idüğü belirsiz tipler gelmişler, adeta oyun oynuyorlar, işiyorlardı. Gezi falan burada sona erdi. 12–13 saat sonra Gebze’de olduk.

Kariyer Değişikliği

2023'ün Kasım ayında Enuygun’dan istifa ettim. 22 Aralık 2023 itibariyle de Enuygun ile tüm ilişiğim kesilmiş olacak. 2023 yılında çok güzel şeyler tattım diyebilirim. Bir finans kuruluşuna geçtim diyebilirim. Türkiye’nin en büyük holdinglerinden birisinin bir kuruluşuna.

Artık Kaldırabiliyorum

Araba kullanmayı biraz daha öğrendim. En azından yokuşta kaldırabiliyorum artık 😛 ama İstanbul trafiğine hala girmek istemiyorum. Bana manuel hala zor geliyor. Amelelik gibi geliyor.

Borsa

Borsaya girdim lan. YTD. Yapıyoruz bir şeyler. Sağolsun Oğuz kumcular ile ilerletiyoruz bu işi. Bu süreçte şu varlıklarımın tamamında karlıyım. 2023'ü karlı kapatıyorum;

• BES
• Yerli fon
• Yerli hisse senedi
• Kripto
• Döviz
• Emtia (Altın, Gümüş, Paladyum, Platin)

Umarım böyle de gider he.

Yeni Dostlar

Bu yıl içerisinde Mustafa Dikyar gibi harika bir insanı kazandım. Umarım bu güzel insanla dostluğumuz sonsuza dek gider. Gerçekten vakit geçirmekten keyif aldığım süper bir insan.

Birbirimizi anlıyoruz. Tradeofflarımızı biliyoruz. Ve aynı sıkıntıları paylaşıp, yükleniyoruz. Bence öyle. Öyle değil mi lan Mıstaa?

Size Mıstaa’yı anlatacak olursam, çok çalışkan, işini sahiplenen, öğrenmeyi seven, öğretmeyi seven, ekibinin yaşadığı zorluklarda kendisin öne atan über bir insan.

Ahan bu da Mıstaa’lı bir fotoğraf olsun

Özet Geç P*ç Diyenler İçin

Kısacası 2023 benim için diğer yıllara göre çok daha fazla dolu bir yıl oldu. Mutlu muyum değil miyim bilemiyorum. Çünkü çok üzüldüğüm zamanlar oldu. Çünkü arkadaşımı kaybettim depremde. Ama yeni arkadaşlar kazandım. İş değişikliğim oldu. Borsa ile haşır neşir oldum. Öyle ya başka daha ne olsun? Ha bir de tekrardan spor yapma kararı aldım. Daha önce 2.5–3 sene aralıksız yapmıştım. Pandemi olmasaydı yapmaya devam da ederdim.

Bu kadar uzun bir yazıyı, fotoğraflı falan okuyup sabrettiyseniz, teşekkürler gerçekten. Sabrınıza hayranım ve zamanınızı ayırdığınız için müteşekkirim.

2024 umarım hepimiz için mutlu bir yıl olur. Bir daha asla üzülmeyiz ve gökkuşağından daha fazla renkleri olan, güneşten daha sıcak gülücükler dağıtırız çevremize.

Öptüm, kib…

Daha önce commandlineparser kullandınız mı bilmiyorum. Ancak enuygun’dan önceki firmamda, bir süreliğine kullanma durumum olmuştu mono kullanarak.

Hep içten içe bu işi daha çok kolaylaştıran bir kütüphane olması gerektiğini düşünüyordum. Haliyle kendi kütüphanemi yapmaya karar verdim ve bok gibi bir şey ortaya çıktı. Zaten hiçbir yerde de göremezsiniz onu.

Daha sonraları ise Microsoft mühendisleri ve topluluk gerçekten çok tatlış bir kütüphane ortaya çıkartmış. Kullanımı kolay, dokümantasyonu güzel olan bir kütüphane yani System.CommandLine kütüphanesi.

Kısaca System.CommandLine

Öncelikle şu anda System.CommandLine preview olarak yayında. Yani kurarken “Include prerelease” demeniz gerekiyor.

Bu kütüphane temel olarak bir CLI uygulaması yapma esnasında ne gerekiyor ise onu size sağlıyor. Mesela CLI input parse etmek ya da bir description göstermek gibi.

Prerelease dedim ancak şu anda .NET CLI, .NET için uninstall, diagnostic tool, svcutil vs. gibi birçok araç yine bu kütüphaneyi kullanıyor.

Ayrıca bu kütüphane şu anda AOT desteği ile birlikte geliyor. Kısacası modern özelliklerle size CLI app geliştirmek konusunda yardımcı olabilir.

Yine bu kütüphane POSIX ya da Windows kurallarına göre inputların kontrolünden de emin oluyor.

Tab completion ve response file desteği de yine bu kütüphane ile gelmekte.

Kurulum

Eğer Visual Studio kullanıyorsanız Nuget paketlerine prerelease olanları da dahil ederek System.CommandLine olarak arama yapın. Yok kullanmıyor iseniz şöyle de kurabilirsiniz

dotnet add package System.CommandLine --prerelease

Örnek Bir Proje — Docker Image Search

Örneğin bir projede oluşturduk ve bu projenin amacı da Docker üzerinden image araması gerçekleştirmek. Yani aslında birden çok özelliği var fakat bu projede image search yapalım. Hem yukarıdaki kütüphaneyi hem de Docker kütüphanesini kuralım

dotnet add package Docker.DotNet

Şimdi gelelim kütüphanenin kullanımına. Öncelikle System.CommandLine kütüphanesi option dediğimiz, command’lara passlanabilen named parameter dediğimiz özelliklere sahiptir. Ya da yapı diyeyim.

Dinamik olarak type bind edilebilen generic türlerdir. Örneğin bir image’in adını alacağımız option’ı yazmamız gerekirse şöyle olur;

Option Tanımlamak

var dockerImageNameOption = new Option(
        name: "--image-name",
        description: "Image name to search"
    );

Gördüğünüz gibi eğer bir “— image-name” komutu gönderirsek bunun türü string olmalıdır diyebiliyoruz. Eğer bir option’ın T değeri nullable değil ise required olarak tanımlanmış demektir. Mesela search aşamasında bir de limit belirtelim. Yani bize tek seferde 2 sonuç dönsün diyebilelim ya da limit belirtmeden kütüphanenin default değerleri dönsün diyebilelim.

var dockerImageLimitOption = new Option(
        name: "--count",
        description: "Search response limit. The default value is null"
    );

Örneğin yukarıdaki senaryoda image name girilmeseydi şu şekilde bir çıktı alacaktık

Tabii option tanımladık hemen anında olsun gibi bir şey yok :) option’lar için ne demiştik? Command’lara passlanmalılar. Şimdi gelin bir root command tanımlayalım.

RootCommand Tanımlama

Öncelikle RootCommand nedir onu bilmeliyiz. Bir root command, çalıştırılabilir uygulamanın dosyasının adını belirten komuttur. Bu yazı dotnet üzerine olduğu için dotnet komutu, dotnet.exe’yi belirtir diyebiliriz.

Örneğimiz için RootCommand şöyle olsun;

var rootCommand = new RootCommand("Sample Docker CLI");
rootCommand.AddOption(dockerImageNameOption);
rootCommand.AddOption(dockerImageLimitOption);

Tabiiki bu tarz bir yapı kurulmamalı ama örnek olması açısından veriyorum. Option’larımızı rootCommand olarak ekledik ancak bu option’lara veri geldiğinde bunları yakalayıp işlem yaptırmamız da gerekiyor. Diğer türlü sadece option eklemiş olur ancak handle etmemiş oluruz

rootCommand.SetHandler(async (imageName, imageCount) =>
{
    var images = await client.Images.SearchImagesAsync(new Docker.DotNet.Models.ImagesSearchParameters()
    {
        Term = imageName,
        Limit = imageCount
    });

    foreach (var image in images)
    {
        Console.WriteLine("----------------");
        Console.WriteLine($"Image: {image.Name}");
        Console.WriteLine($"Description: {image.Description}");
        Console.WriteLine($"Start: {image.StarCount}");
        Console.WriteLine($"Official: {(image.IsOfficial ? "Yes" : "No")}");
        Console.WriteLine("----------------");
        Console.WriteLine(Environment.NewLine);
    }

}, dockerImageNameOption, dockerImageLimitOption);

Yukarıdaki kod örneğinde, rootCommand bir variadic yapıya sahiptir. Yani istediğiniz kadar parametre alabiliyor. Tabiiki abartmayın 😛

Aldığı parametrelerin türü ise, option’ların aldığı T türünden.

Daha sonrasında ise şu kodu ekleyerek, CLI tarafında gelen argümanları rootCommand’e paslamamız gerekiyor;

await rootCommand.InvokeAsync(args);

Projemize, launchSettings ile CLI args paslayarak test işlemimizi şöyle yapalım;

Default hiçbir parametrenin girilmediği yani root command’in bir şey parse etmediği durumda eğer uygulamayı çağırır isek şöyle bir çıktımız olacak.

Bu yazı bu kadar. Okuduğunuz için teşekkür ederim. Umarım faydalı olmuştur :)

Örnek GitHub Reposu

GitHub - aligoren/docker-cli-example-with-system-commandline: Docker CLI Example with…

Kaynaklar

• https://learn.microsoft.com/en-us/dotnet/standard/commandline/

Reliability ya da bir şeyin reliable olması demek güvenilir olması demektir. Negatif durumlarda ise unreliable olduğunu söyleriz.

Yazılım süreçlerinde ise reliable olma konusunu konuşurken şunları düşünebiliriz.

• Uygulama, kullanıcının beklediği şekilde fonksiyonu çalıştırır
• Kullanıcı kaynaklı hataları ya da kullanıcının bir yazılımı beklentilerin üzerinde bir şekilde kullanmasını tolere eder
• Performansı söz konusu ise hem yük hem de veri yoğunluğu noktasında yeterli düzeydedir
• Sistem, herhangi bir yetkisiz erişimi ve kötüye kullanımı engeller.

Eğer tüm bu bahsedilenler bir araya geldiğinde iyi bir şekilde ya da doğru şekilde çalışmak anlamına geliyorsa, reliability kavramını şöyle düşünebiliriz

bazı şeyler yanlış gittiğinde bile doğru şekilde çalışmaya devam etmek

Yanlış gitmesi mümkün olan şeylere faults deriz yani hatalardır. Bu hataları tahmin edebilen sistemlere ise fault-tolerent ya da resilient sistemler deriz.

Kavramlara Bir Göz Atalım

faults: Hatalar

fault tolerent: Hata tolere edebilirlik

resilient: Esnek ya da dayanıklılık

Kısacası bir şeyler yanlış gidebilir bu mümkün, bu durumda faults olarak değerlendiririz. Bu hataların oluşmasını tolere edebilecek bir sistemden de bahsettiğimizde ya fault-toleren ya da resilient sistemlerden bahsetmiş oluyoruz.

Aslında fault-tolerent kavramını belki yanlış anlayabileceğimizi öğretiyor bu kitap.

Düşünün bir kara delik dünyamızın yanında belirdiği anda dünyayı da yok yutacaktır. Bu noktada var olan bütün sunucularımız da bununla birlikte yok olacaktır. Bu durumda 2 senaryo var.

Senaryo 1

Mister Spak ve Turist Ömer verilerimizi kompüter’e taşıyabilir.

Senaryo 2

Bir başka gezegende de host edilebilir ortamlar oluşturmak

İlk senaryo kurgu olsa da ikinci senaryo da şu an için pek mümkün değil gibi. Çünkü sisteminizin fault tolerent olabilmesi için milyarlarca doları gözden çıkarmanız gerekebilir.

Yani fault tolerent sistem olmak, her durumu temsil etmez. Ancak belirli durumlarda fault tolerent olmaktır.

Fault vs Failure

Bir sistem hakkında konuşurken fault yani hata ya da failure gibi durumlardan bahsedebiliriz. İkisi aynı anda söylenebilir ancak aynı şeyler değildir.

Fault dediğimiz durumda sistem çalışıyordur ancak bir şeyler yanlış gidiyordur. Failure durumda ise gerçekten bir sorun vardır ve hizmet verilemezlik ortaya çıkmıştır. Faults dediğimiz durumların failure ortaya çıkarabileceğini de bilmemiz gerekiyor.

Sıfır Hata, Sıfır Arıza mı Demek Hocam?

Gerçekçi olmak gerekirse hataların tamamen yok edilmesi en azından günümüzde pek mümkün görünmüyor sevgili okur 😛

Bu nedenle fault tolerent sistemler tasarlarken de, hataların arıza oluşturan yani failure oluşturan durumlara yol açmasının önüne geçecek fault tolerent sistemler tasarlamamız gereklidir

Kitapta bu noktadan sonra hata türleri önümüze geliyor. Bunlar ise şunlar

• Hardware Faults
• Software Errors
• Human Errors

Bunlara da birazcık değinmek gerekebilir.

Hardware Faults Bize Neyi Anlatır?

Genellikle bir sistemsel hata ile karşılaşınca, donanımsal hataları düşünmeye başlarız.

Örnek vermek gerekirse bir anda hard-disk’ler çökebilir, RAM kaynaklı hatalar ortaya çıkabilir, dünyanın en mükemmel en sorunsuz elektrikli ülkesi olan Türkiye’de elektrik bir anda kesintiye uğrayabilir, ya da kediniz ağ kablosunu kemirebilir ya da daha fena şeyler yapabilir. Takılmayın kedidir kedi

Bir firmada çalışan bir arkadaşım bu tarz şeyleri veri merkezlerinde sürekli olabildiğini söylüyordu. Bu gerçekten Enuygun’dan önceki firmamda iş ortaklığı yürüttüğümüz bir firmada sistem admin ve daha fazlası olarak çalışan bir arkadaşla olan sohbette duyduklarımdı.

Peki ne yapılabilir?

İlk olarak, bir HDD’nin bozulacağı senaryo için, bir başka yedek satın alarak onu bekletmek olabilir. Diskler belki RAID olarak yarlanabilirler. Sunucularda belki çiftli güç kaynakları olabilir. (Donanımdan anlamadığım belli mi lan?) Ya da jeneratorler yedek güç olarak bu noktada yer alabilir.

Günün sonunda bir HDD mi bozuldu? Diğeri devreye girebilir, sallıyorum bir güç kaynağı mı bozuldu? Diğeri devreye girer. Elektrik mi gitti? Bu noktada artık jeneratorler devreye girer.

Siz bu sayede bir donanımın bozulmasını engellemiş olmuyorsunuz, sistemin yıllarca sorunsuz şekilde çalışmış oluyorsunuz.

Maliyetler?

Normalde bu tarz bir yaklaşım sorun yaratmazken, yüksek işlem gücü gerektiren uygulamalar ve veri saklama alanları nedeniyle donanım gereksinimleri de arttı. E bu durumda her donanımı çiftlemek de birazcık güç olabilir. Bunun yerine AWS gibi Azure gibi ya ad Google Cloud gibi sistemler sanal makineler oluşturarak size esnek ve elastik yapıları tek bir reliable makine üzerinde çalışma fırsatı sunuyor.

Software Errors Bize Neyi Anlatır?

Genellikle donanım kaynaklı hataların birbirinden bağımsız ya da bir anda ortaya çıktığını varsayarız. Bir makinenin diski ya da RAM’i arızalanıyor ise, bu başka bir makinede de böyle bir sorunun olacağını göstermez. Çünkü bu sıcaklıktan, voltajdan vs. birçok şeyden de ortaya çıkabilir.

Ayrıca bir başka hata türü de mesela, tasarlanan sistemde oluşan sistemsel hata türüdür. Bu tarz hataları tahmin etmek çok zordur. Bunun için testler yapıyor olmanız size tünelin sonundaki ışığı göstermeyecektir.

Örnek 1:

Belirli kötü bir girdi verildiğinde bir uygulama sunucusunun her bir örneğini çökerten bir yazılım hatası. Örneğin, 30 Haziran 2012'deki artık saniye (leap second) olayı, Linux çekirdeğindeki bir hatadan dolayı birçok uygulamanın aynı anda askıda kalmasına neden oldu.

Kaynak: https://www.wired.com/2012/07/leap-second-glitch-explained/

Örnek 2:

Örneğin CPU’yu, belleği, disk alanı vs. gibi paylaşılan kaynakları tüketen kontrolsüz bir süreç.

Örnek 3:

Bir sistem düşünün ana thread’i bloklasın. Bu nedenle yanıt verilebilir olması da sıkıntıya giriyor.

Örnek 4:

Kelebek etkisi. Bir hatanın bir başka hatayı, o hatanın da başka bir hatayı tetiklemesi nedeniyle ortaya çıkan kaotik hatalar da ortaya çıkabilir.

Maalesef bu türden hatalar ortaya çıkana dek kendisini göstermeyen sinsi düşmanlardır. Maalesef bu tarz hataların hemen uygulanacak hızlı çözümleri de yoktur :( Ama şöyle örnekler sunulabilir

• Kapsamlı testler yapmak
• Process’leri izole etmek
• Process’lerin crash olmasına ve restart edilmesine izin vermek
• Monitoring

Vs. vs. vs. bildiğiniz türden şeyler

Human Errors Bize Neyi Anlatır?

Günün sonunda bugün ortaya çıkan tüm ürünler, insan elinin değdiği sistemlerdir. Yapay zeka projelerinden tutun da yazdığımız CRUD uygulamalara kadar. Ayrıca bu sistemlerin çalışmasında görevli kişiler de yine insanlardır.

Kedi gibi bir insan da olsa sonuçta insanlar yani hata yapabilirler 😛 Localde çalışıyordu demeleriyle ünlüdürler.

Ünlü GitLab veri silme hikayesini biliyorsunuzdur belki. 300 GB data bir anda uçuruldu.

Kaynak: https://about.gitlab.com/blog/2017/02/10/postmortem-of-database-outage-of-january-31/

Hiç kuşku yok ki bu hatayı yapan kişi kötü bir niyetle yapmasa da insanlara ve yaptıkları işlere güvenme noktasında agnostik olmamız gerektiğini kabul etmeliyiz.

Nasıl Güvenilir Sistemler İnşa Ederiz?

Peki insanlar güvenilir değil yani unreliable ise, sistemlerimizi nasıl güvenilir yapacağız?

• Hata oluşma ihtimallerinin en aza indirileceği sistemler tasarlayabiliriz. Mesela, iyi şekilde tasarlanan abstraction’lar, API’lar vs… Bunlar bir şeyleri doğru yapmaya sizi zorlarken, yanlış yapma noktasında da önünüze engeller çıkarır. Örneğin çok kritik bir şeyi silecekseniz, bunu bir UI ile yapacaksanız üzerinde düşünmeniz gereken bazı UI/UX durumları olabilir.
• Sandbox ortamlar kullanarak, hataların yapılabileceği noktaları gerçek ortamlardan ayırabiliriz. Bu sayede gerçek kullanıcı datasına herhangi bir müdahalemiz de olmamış olur. GitLab örneği çok iyi açıklıyor bunu.
• Çok yorucu olsa da manuel testler, integration testler ve unit testleri tüm noktalarıyla yapmaya çalışabiliriz. Burada belki automated testler de nadir de olsa ortaya çıkabilecek durumlar için önden size bu durumu bildirebilirler. (Çalıştığım firmada, kendi projemde bir test ile hiç karşılaşmadığımız bir hatayı cover edebildik)
• Bu türden hatalar olabilir ancak bunların hızlı şekilde kontrol altına alınabileceği etkisi daha ufak geliştirmelere izin vermemiz gerekebilir. Örneğin bir noktada config sorunumuz var ise hemen roll-back yapabilmeliyiz.
• Detaylı bir monitoring işimize yarayabilir. Mesela performans ölçümleri, hata oranları vs. gibi. Buna diğer mühendislik disiplinlerinde telemetry de denilebilir.

Peki Reliability Ne Kadar Önemlidir?

Reliable olma, bir nükleer tesis yazılımında ya da uzay araçları yaızlımlarında fark etmeksizin önemlidir. Bunun yanında bir e ticaret platformunun yazılımlarında da önemlidir. Yani reliable yani güvenilir olma durumu her koşulda önem arz eder.

X bir firmada sıklıkla ortaya çıkan buglar nedeniyle hem finansal kayıplar olabilir hem de prestij kaybı ortaya çıkabilir. Yani bu güvenilir olmama durumunun ortaya çıkaracağı etkilerdir.

Bazen ise reliable olma durumunun o kadar da olmadığı şartlara sahip olabiliriz. Mesela bir prototip ürün geliştirirken reliable olması çok önemli değildir. Prototipin işi bu değildir. Eğer bunun üzerine çok düşünülür ise geliştirme maliyetleri bir hayli artacaktır.

Bu konu bu kadardı. Umarım kafanızda data-system ya da veri sistemi üzerine birazcık da olsa bir şeyler oluşturabilmişimdir. Buradaki içerikler kitaptan geliyor.

Okuduğunuz için teşekkür ederim.

Kaynaklar

• https://dataintensive.net/