İlk olarak Linkedin tarafından geliştirilmiş ve sonrasında Apache Software Foundation çatısı altında open source haline getirilmiştir.

Ne zaman kullanmalıyız?

• Gerçek zamanlı veri işleme
• Mikroservisler arası iletişim
• Log toplama
• Event sourcing
• Stream processing

Kafka Mimarisi

Kafka, aşağıdaki bileşenlerden oluşmaktadır:

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - "2181:2181"

  kafka:
    image: confluentinc/cp-kafka:7.5.0
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENERS: PLAINTEXT://:9092
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - "2181:2181"

  kafka:
    image: confluentinc/cp-kafka:7.5.0
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENERS: PLAINTEXT://:9092
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

Cmd veya git bash ile docker-compose up -d komutunu çalıştırın. Zookeeper ve Kafka imajları indirildikten sonra kurulacaktır. Aşağıdaki gibi Docker Desktop tada 2 servisinde ayağa kalktığını görebilirsiniz.

Producer ve Consumer uygulamalarımızı yazalım.

Hava Durumu Takibi Uygulama Örneği

.NET Core ile Kafka kullanarak basit bir hava durumu takip uygulaması geliştireceğiz. Producer olan uygulamamız, belirli aralıklarla sıcaklık verileri üretecek ve Kafka ‘ya iletecek. Consumer tarafındada bu değerleri okurken eğer sıcaklık belirli bir eşiğin üzerine çıkarsa, ekrana bir uyarı mesajı basacağız. Gerçek dünya projelerinde bu adımda genellikle email / notification gönderimi ya da socket üzerinden Client ‘ları bilgilendirme gibi işlemler gerçekleştirilebilir.

Oluşturduğum test projesinin yapısı aşağıdaki gibidir, basit bir kurgu yaptım.

Öncelikle hava durumu verilerini üretecek Producer uygulamamızı yazalım. Bunun için yeni bir Console App açıyoruz ve aşağıdaki Confluent.Kafka paketini yüklüyoruz. Bu işlemi Consumer Console App ‘imiz için de yapacağız.

dotnet add package Confluent.Kafka

dotnet add package Confluent.Kafka

Producer

using Confluent.Kafka;
using Kafka.Dto;
using System.Text.Json;

var config = new ProducerConfig { BootstrapServers = "localhost:9092" };
var producer = new ProducerBuilder<Null, string>(config).Build();

var cities = new[] { "Antalya", "Adana", "Amasya" };
var rand = new Random();

while (true)
{
    KafkaWeatherDto data = new KafkaWeatherDto
    {
        City = cities[rand.Next(cities.Length)],
        Temperature = rand.Next(1, 50),
        Humidity = rand.Next(30, 90),
        Date = DateTime.Now
    };

    string jsonData = JsonSerializer.Serialize(data);
    await producer.ProduceAsync("WeatherTopic", new Message<Null, string>
    {
        Value = jsonData
    });

    Console.WriteLine($"Data gönderildi: {jsonData}");
    await Task.Delay(2000);
}

using Confluent.Kafka;
using Kafka.Dto;
using System.Text.Json;

var config = new ProducerConfig { BootstrapServers = "localhost:9092" };
var producer = new ProducerBuilder<Null, string>(config).Build();

var cities = new[] { "Antalya", "Adana", "Amasya" };
var rand = new Random();

while (true)
{
    KafkaWeatherDto data = new KafkaWeatherDto
    {
        City = cities[rand.Next(cities.Length)],
        Temperature = rand.Next(1, 50),
        Humidity = rand.Next(30, 90),
        Date = DateTime.Now
    };

    string jsonData = JsonSerializer.Serialize(data);
    await producer.ProduceAsync("WeatherTopic", new Message<Null, string>
    {
        Value = jsonData
    });

    Console.WriteLine($"Data gönderildi: {jsonData}");
    await Task.Delay(2000);
}

Üst kısımda konfigurasyonları ve tanımlamaları yaptıktan sonra while bloğu içerisinde işlemlerimizi gerçekleştiriyoruz. Burada da KafkaWeatherModel tipindeki modelimizi serialize ediyor ve ProduceAsync ile WeatherTopic ‘ine iletiyoruz. Senaryomuz gereği 2 sn de bir bu datanın topic e iletilmesini sağlıyoruz. Producer projesini ayağa kaldırdığımızda çıktısı şu şekilde olacaktır:

Consumer

using Confluent.Kafka;
using Kafka.Dto;
using System.Text.Json;

var config = new ConsumerConfig
{
    BootstrapServers = "localhost:9092",
    GroupId = "WeatherConsumerGroup",
    AutoOffsetReset = AutoOffsetReset.Earliest
};

var consumer = new ConsumerBuilder<Null, string>(config).Build();
consumer.Subscribe("WeatherTopic");

while (true)
{
    var consume = consumer.Consume();
    var kafkaWeatherModel = JsonSerializer.Deserialize<KafkaWeatherDto>(consume.Message.Value);

    if (kafkaWeatherModel != null)
    {
        Console.WriteLine($"{kafkaWeatherModel.City} > Sıcaklık : {kafkaWeatherModel.Temperature} , Nem : {kafkaWeatherModel.Humidity}");

        if (kafkaWeatherModel.Temperature > 35)
            Console.WriteLine($"DİKKAT : {kafkaWeatherModel.City} şehrinde sıcaklık çok yüksek : {kafkaWeatherModel.Temperature}");
    }
}

using Confluent.Kafka;
using Kafka.Dto;
using System.Text.Json;

var config = new ConsumerConfig
{
    BootstrapServers = "localhost:9092",
    GroupId = "WeatherConsumerGroup",
    AutoOffsetReset = AutoOffsetReset.Earliest
};

var consumer = new ConsumerBuilder<Null, string>(config).Build();
consumer.Subscribe("WeatherTopic");

while (true)
{
    var consume = consumer.Consume();
    var kafkaWeatherModel = JsonSerializer.Deserialize<KafkaWeatherDto>(consume.Message.Value);

    if (kafkaWeatherModel != null)
    {
        Console.WriteLine($"{kafkaWeatherModel.City} > Sıcaklık : {kafkaWeatherModel.Temperature} , Nem : {kafkaWeatherModel.Humidity}");

        if (kafkaWeatherModel.Temperature > 35)
            Console.WriteLine($"DİKKAT : {kafkaWeatherModel.City} şehrinde sıcaklık çok yüksek : {kafkaWeatherModel.Temperature}");
    }
}

Consumer tarafında yine Kafka ile ilgili yapılandırmamızı yapıyoruz. BootstrapServers ile Kafka adresimizi belirtiyoruz. GroupId, Kafka ‘daki consumer group adıdır. Aynı GroupId ‘ye sahip consumer’lar aynı gruba aittir ve partition ‘ları paylaşarak çalışır. Bu sayede Kafka her mesajı bir grup içinde sadece bir consumer a iletir. Örneğin: 2 partition varsa ve aynı GroupId ‘ye sahip 2 consumer varsa her biri 1 partition dinler.

AutoOffsetReset = AutoOffsetReset.Earliest ayarı consumer daha önce hiç mesaj okumamışsa veya kaldığı yerin kaydı yoksa, nereden başlayacağını belirler. Earliest en eski mesajlardan, Latest ise en son gelen mesajlardan okumaya başla demektir. Biz kendi örneğimizde bu değeri Earliest olarak ayarladık.

Consumer tarafında ekran görüntüsünde de görüldüğü üzere, sıcaklıklar belli bir derecenin üzerine çıktığında uyarı mesajını ekrana bastık. Bu örnek basit olsa da, temelleri öğrendikten sonra senaryo kolaylıkla genişletilebilir. Gerçek hayat uygulamalarında bu aşamada farklı aksiyonlar alınabilir. İlgili veriler veritabanına kaydedilebilir. Kaydedilen bilgiler grafikler ile görselleştirilebilir. Gerisi kendi uygulamanızın ve sizin ihtiyaçlarınıza göre şekillenecektir.

BONUS olarak Kafka tarafında nelerimiz oluşmuş Kafka UI ‘da görmeyelim mi ? (https://www.youtube.com/watch?v=ANnoNIMPWnQ)

Broker ‘larımız:

Topic ‘lerimiz:

Topic Detayı: 1 adet partition ‘ımızın olduğu görünüyor. İstenirse partition sayısı Producer tarafında ayarlanabilir.

Consumer ‘larımızın listesi:

Bir makalenin daha sonuna geldik , yeni makalelerde görüşmek üzere.

Faydalandığım linkler:

http://interviewbit.com/blog/kafka-architecture/

https://www.cloudduggu.com/kafka/architecture

Kafka Nedir? .Net Core ile Kullanımı yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Neden HybridCache?

.Net uygulamalarında genelde iki seçeneğimiz var:

1. IMemoryCache : Uygulama sunucusunun belleğinde tutulan hızlı bir cache. Ancak birden fazla sunucuda çalışan uygulamalarda, yapısı gereği verilerde tutarsızlığa neden olur.
2. IDistributedCache : Tüm sunucular aynı cache’i paylaşır ama erişim hızı memory cache kadar hızlı değildir. (Örn: Redis)

HybridCache, iki kullanımı da aynı anda destekleyerek bize kullanım kolaylığı ve ekstra performans sağlar. Örnek ile beraber HybridCache ‘in çalışma mantığını detaylı bir şekilde anlatacağım.

HybridCache Kullanımı

Statik olarak oluşturacağımız kullanıcı listesini cache ‘leyen bir örnek yapmak için hemen docker da bir Redis ayağa kaldıralım ve geliştirmelere başlayalım.

docker run -d --name redis-hybridcache -p 6379:6379 redis

Redis ‘i çalışır hale getirdiysek, yeni bir web projesi açalım ve Redis, HybridCache paketlerini yükleyelim:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis
dotnet add package Microsoft.Extensions.Caching.Hybrid

Daha sonra Program.cs mize şu satırları ekleyelim:

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost:6379";
});

builder.Services.AddHybridCache();

Burada basit konfigürasyonlarla Redis ve HybridCache implementasyonlarını yaptık. Hybrid Cache, Redis yapılandırmamızı otomatik olarak görecek ve birlikte sorunsuz çalışacaktır.

Test metodumuzu içerecek olan UserController adında yeni bir controller açıp içeriğini şu şekilde düzenleyelim.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Hybrid;

namespace HybridCacheTest.Controllers;

[Route("user")]
public class UserController : Controller
{
    private readonly HybridCache _hybridCache;

    public UserController(HybridCache hybridCache)
    {
        _hybridCache = hybridCache;
    }

    [Route("list")]
    public async Task<string> GetUsers()
    {
        string cacheKey = $"UserList";
        
        var cacheOptions = new HybridCacheEntryOptions
        {
            Expiration = TimeSpan.FromMinutes(10)
        };

        var userList = await _hybridCache.GetOrCreateAsync(cacheKey, async data => await GetUserList(), cacheOptions);

        if (userList != null)
            return "Kullanıcı listesi alındı.";
        else
            return "Kullanıcı listesi boş.";
    }

    /// <summary>
    /// Normalde servis katmanı aracılığı ile alınması gerekir ama örnek için controller içinden kullanıcı listesi oluşturup onu dönüyoruz.
    /// </summary>
    /// <returns></returns>
    private async Task<List<UserDto>> GetUserList()
    {
        return new List<UserDto>()
        {
            new UserDto() { Id = 1, Name = "Test 1"},
            new UserDto() { Id = 1, Name = "Test 2"}
        };
    }
}

Browser’dan /user/list adresine gidildiğinde, GetUsers() metodumuz çalışacak ve kullanıcı listesini cache ‘e alacaktır. Örneğimizi tamamladık, şimdi çalıştıralım.

_hybridCache.GetOrCreateAsync satırı şu işlemleri yapar;

1. Öncelikle “UserList” key ‘i memory cache’te var mı diye kontrol eder.
2. Memory cache’te yoksa distributed cache’e (Redis) bakar.
3. Data burada da yoksa ilgili metod çağrılır ve sonuç hem Redis’e hem de memory cache’e eklenir.

Böylece HybridCache ikinci istekte datayı Memory Cache ‘ten alıp, Client ‘a ileteceği için çok daha hızlı response dönecektir. Burada cache key lerimize vereceğimiz Expiration sürelerine dikkat etmeliyiz. Aksi durumda uygulamamızın çalıştığı sunucu belleğine fazla yük bindirmiş oluruz.

Ek açıklamalardan sonra Redis ‘i kontrol ettiğimizde, “UserList” key ‘ine ait data aşağıdaki gibi görünecektir :

Cache Remove işleminde ise ilgili data hem memory cache hem de distributed cache den silinir ve böylece tutarlılık sağlanmış olur.

Kritik Bilgi : Ani olarak birden fazla istek geldiğinde bile veri kaynağına 1 kez gidilir ve cache üretilir. Diğer client lar datayı cache üzerinden alırlar.

Bu makalede elimden geldiğince HybridCache ‘i anlatmaya çalıştım, umarım faydalı olmuştur.

Sonraki makalede görüşmek üzere

Faydalandığım linkler:

https://devblogs.microsoft.com/dotnet/hybrid-cache-is-now-ga/

https://medium.com/c-sharp-programming/exploring-hybridcache-in-net-9-a-game-changer-for-asp-net-core-applications-5afc321c0690

HybridCache Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Neden bu pattern i kullanmalıyım?

• Bir mikro servis ya da external api yavaş çalışıyor veya hiç cevap vermiyorsa, atılan her request sistem kaynaklarını boşa tüketecek ve cloud sistemlerde çalıştığımızı düşünürsek doğrudan maliyetlerimize de etki edecektir.
• Genel sistem performansına olumlu etkileri vardır.
• Circuit Breaker, belirli bir hata oranı aşıldığında ilgili servise yeni requestlerin atılmasını engeller.

Circuit Breaker ‘ın 3 state ‘i vardır:

Closed (Kapalı): Sistemin normal olduğu ve requestlerin servise gönderilebildiği durumdur.
Open (Açık) : Hata oranı belirlenen eşiği aşmıştır. Artık yeni istekler gönderilmez, hemen hata döner.
Half-Open (Yarı Açık): Belirli bir süre bekledikten sonra test amaçlı birkaç istek gönderilir. Eğer bunlar başarılı olursa devre tekrar kapalı hale gelir.

Aşağıdaki grafikte her durum için sayaç işlemlerini görebilirsiniz.

.Net Core ile Polly Kullanarak Circuit Breaker İmplementasyonu

Bir web uygulaması açalım ve örnek bir implementasyon yapalım. Polly ve Microsoft.Extensions.Http.Polly paketlerini Nuget ten yükleyelim.

Appsettings.json ‘daki ayarlarımız:

"CircuitBreakerSettings": {
  "ExceptionsAllowedBeforeBreaking": 5,
  "DurationOfBreakInSeconds": 30
}

Daha sonra Program.cs de implementasyonumuzu aşağıdaki gibi yapabiliriz:

var circuitBreakerSettings = new CircuitBreakerSettings();
builder.Configuration.GetSection(nameof(CircuitBreakerSettings)).Bind(circuitBreakerSettings);

// Circuit Breaker policy oluştur
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .OrResult<HttpResponseMessage>(msg => !msg.IsSuccessStatusCode)
    .CircuitBreakerAsync(
        handledEventsAllowedBeforeBreaking: circuitBreakerSettings.ExceptionsAllowedBeforeBreaking,
        durationOfBreak: TimeSpan.FromSeconds(circuitBreakerSettings.DurationOfBreakInSeconds),
        onBreak: (outcome, breakDelay) =>
        {
            if (outcome.Exception != null)
            {
                Debug.WriteLine($"Circuit breaker açıldı: {outcome.Exception.Message}. Yeni istek için bekleme süresi: {breakDelay}");
            }
            else
            {
                Debug.WriteLine($"Circuit breaker açıldı. StatusCode: {outcome.Result.StatusCode}. Yeni istek için bekleme süresi: {breakDelay}");
            }
        },
        onReset: () =>
        {
            Debug.WriteLine("Circuit breaker kapandı.");
        },
        onHalfOpen: () =>
        {
            Debug.WriteLine("Circuit breaker yarı açık. Dış servise erişim test ediliyor...");
        }
    );

// HTTP client'a policy handler ekle
builder.Services.AddHttpClient<ITestApiClient, TestApiClient>().AddPolicyHandler(circuitBreakerPolicy);

Sadece bu kısmı özetleyecek olursak:

Ayarlarımızı CircuitBreakerSettings class ına bind ediyoruz. Bu örnekte 5 başarısız istekten sonra 30 saniye isteklere ara verecek şekilde konfigürasyonumuzu yaptık. Oluşturduğumuz policy sayesinde HttpRequestException ile fırlatılan hatalar ve başarısız HTTP response lar yakalanıyor, 5 hatadan sonra devre açılıyor (onBreak). Devre kapandığında (onReset) veya yarı açık hale geldiğinde (onHalfOpen) action larımız çalışıyor. Son olarak oluşturduğumuz policy ‘i HttpClient ’a doğrudan bağlıyoruz.

Basit bir request içeren ITestApiClient.cs ve TestApiClient.cs class larımız:

public interface ITestApiClient
{
    Task<string> GetDataAsync();
}

public class TestApiClient : ITestApiClient
{
    private readonly HttpClient _httpClient;

    public TestApiClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<string> GetDataAsync()
    {
        var response = await _httpClient.GetAsync("https://dummyjson.com/products/333"); // Hata oluşması için olmayan bir ürün Id verdim

        response.EnsureSuccessStatusCode(); // Başarısız durumlarda exception fırlatır ve Circuit Breaker devreye girer

        return await response.Content.ReadAsStringAsync();
    }
}

Son olarak HomeController.cs:

public class HomeController : Controller
{
    private readonly ITestApiClient _apiClient;

    public HomeController(ITestApiClient apiClient)
    {
        _apiClient = apiClient;
    }

    [HttpGet("test")]
    public async Task<IActionResult> Test()
    {
        var data = await _apiClient.GetDataAsync();

        return Ok(data);
    }
}

5 istekten sonra Circuit Breaker devreye girecek şekilde yapılandırmamızı tamamladıktan sonra sonuç :

Circuit Breaker Pattern ‘i ile ilgili anlatacaklarım bu kadar. Pattern ‘in anlaşılabilir olması için kurguyu basit tutmaya çalıştım. Umarım faydalı olmuştur.

Sonraki yazılarda görüşmek dileğiyle…

Faydalandığım linkler:

https://learn.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker

https://medium.com/@90mandalchandan/implementing-circuit-breaker-in-net-core-with-polly-32c62a9984e4

Circuit Breaker Pattern Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

• Fuzzy Query Nedir?
• Docker Desktop ‘a Elasticsearch ve Kibana Kurulumu
• Kibana Console – Dev Tools
  • Yeni Index Oluşturma
  • Bulk Data Girişi
  • Fuzzy Query Örneği
  • Boosting Kullanımı

Fuzzy Query Nedir?

Fuzzy Query, arama sorgularında hatalı yazılmış, eksik, fazla karakter içeren veya benzer kelimeleri de eşleştirmek için kullanılan bir tekniktir. Kısaca “benzer eşleşme” yapar. Yani ilgili data içerisinde sorgulanan terim ile tam olarak eşleşmeyen ama benzer olan sonuçları da getirir. Bu işlem arka planda genellikle Levenshtein Distance (Levenshtein Mesafesi) algoritması kullanılarak gerçekleştirilir. Konuyla ilgili detayları incelemek isterseniz daha önce yazdığım “Levenshtein Mesafesi (Levenshtein Distance) Nedir?” blog yazısını inceleyebilirsiniz.

Docker Desktop ‘a Elasticsearch ve Kibana Kurulumu

Docker-compose.yml dosya içeriği aşağıdaki gibi. Dosyayı herhangi bir klasöre attıktan sonra docker-compose up komutu ile konteyner larını kurulmasını ve ayağa kalkmasını sağlayabilirsiniz.

version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.7.1
    expose: 
      - 9200
    environment:
      - xpack.security.enabled=false
      - "discovery.type=single-node"
      - ELASTIC_USERNAME=elastic
      - ELASTIC_PASSWORD=DkIedPPSCb
    networks:
      - es-net
    ports:
      - 9200:9200
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
  kibana:
    image: docker.elastic.co/kibana/kibana:8.7.1
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    expose:
      - 5601
    networks:
      - es-net
    depends_on:
      - elasticsearch
    ports:
      - 5601:5601
    volumes:
      - kibana-data:/usr/share/kibana/data
networks:
  es-net:
    driver: bridge
volumes:
  elasticsearch-data:
    driver: local
  kibana-data:
    driver: local

Kibana Console – Dev Tools

Kurulumu tamamladıysanız, Kibana Console Dev Tools arayüzüne http://localhost:5601/app/dev_tools#/console bu şekilde erişebiliyor olmalısınız. Öncelikle örnek verilerimizi tutacağımız products_st adında yeni bir index oluşturalım.

PUT /products_st
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text"
      },
      "price": {
        "type": "float"
      }
    }
  }
}

Daha sonra index içerisine bulk olarak dummy data gönderelim. Sorgu sonucunda bulacağımız her sonuç score unun farklı olduğunu görebilmek için yazım hataları olan veya benzer kayıtları bilerek ekledim.

POST /products_st/_bulk
{ "index": { "_id": 1 } }
{ "name": "Ekran Kartı", "price": 8500.0 }
{ "index": { "_id": 2 } }
{ "name": "Anakart", "price": 3200.0 }
{ "index": { "_id": 3 } }
{ "name": "İşlemci", "price": 6700.0 }
{ "index": { "_id": 4 } }
{ "name": "RAM Bellek", "price": 1200.0 }
{ "index": { "_id": 5 } }
{ "name": "SSD Disk", "price": 2100.0 }
{ "index": { "_id": 6 } }
{ "name": "HDD Disk", "price": 950.0 }
{ "index": { "_id": 7 } }
{ "name": "Kasa", "price": 1800.0 }
{ "index": { "_id": 8 } }
{ "name": "Güç Kaynağı", "price": 1100.0 }
{ "index": { "_id": 9 } }
{ "name": "Monitör", "price": 4500.0 }
{ "index": { "_id": 10 } }
{ "name": "Klavye", "price": 650.0 }
{ "index": { "_id": 11 } }
{ "name": "Mouse", "price": 350.0 }
{ "index": { "_id": 12 } }
{ "name": "Kulaklık", "price": 800.0 }
{ "index": { "_id": 13 } }
{ "name": "Ekran Karı", "price": 8400.0 }
{ "index": { "_id": 14 } }
{ "name": "Ekran Kart", "price": 8300.0 }
{ "index": { "_id": 15 } }
{ "name": "Ekraan Kartı", "price": 8600.0 }
{ "index": { "_id": 16 } }
{ "name": "Ankart", "price": 3100.0 }
{ "index": { "_id": 17 } }
{ "name": "Ana Kart", "price": 3300.0 }
{ "index": { "_id": 18 } }
{ "name": "Ram Belleği", "price": 1250.0 }
{ "index": { "_id": 19 } }
{ "name": "Ram Belleg", "price": 1190.0 }
{ "index": { "_id": 20 } }
{ "name": "SsdDisc", "price": 2050.0 }
{ "index": { "_id": 21 } }
{ "name": "HDDDisc", "price": 940.0 }
{ "index": { "_id": 22 } }
{ "name": "Kasaa", "price": 1790.0 }
{ "index": { "_id": 23 } }
{ "name": "Guc Kaynagı", "price": 1120.0 }
{ "index": { "_id": 24 } }
{ "name": "Monotor", "price": 4400.0 }
{ "index": { "_id": 25 } }
{ "name": "Monitr", "price": 4550.0 }

Buraya kadar herşey tamamsa artık Fuzzy Query mizi Dev Tools üzerinde yazarak nasıl çıktı elde ettiğimizi görebiliriz. Öncelikle bütün kayıtları çekerek datamızın varlığını kontrol edelim.

GET products_st/_search
{
  "size":50,
  "query": {"match_all": {}}
}

Sorguyu çalıştırdığımızda 25 kaydın gelmesi gerekiyor. Burada “size” değerini vermezseniz default olarak 10 kayıt gelecektir.

Şimdi “ekran” kelimesini Fuzzy Query ile aratarak eşleşmeleri bulalım ve score larını inceleyelim.

GET /products_st/_search
{
  "query": {
    "bool": {
      "must": {
        "fuzzy": {
          "name": {
            "value": "ekran",
            "fuzziness": "AUTO"
          }
        }
      }
    }
  }
}

Yukarıda gördüğünüz gibi bulunan her sonuç için bir _score değeri üretiliyor. En yüksek score en iyi eşleşen sonuç anlamına geliyor. Sorgudaki “fuzziness”: “AUTO” değeri Fuzzy Query’nin ne kadar toleranslı olacağını otomatik olarak belirlememizi sağlıyor. Fakat sayısal bir değer verirsek : Örneğin değer olarak “2” verilirse, 2 karakter farkı tolere eder.

Alan bazında boosting vererek ağırlığa göre arama yapmak isterseniz, her alan için boost tanımlayabilir, boosting sayesinde her alana bir ağırlık katsayısı (boost) verebilirsiniz. Böylece daha yüksek boost alan, daha yüksek _score üretir ve daha üst sıralara çıkar.

GET /products_st/_search
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "kart",
        "fuzziness": "AUTO",
        "boost": 3.0
      }
    }
  }
}

Birden fazla alan için tanımlama yapmak isterseniz, multi_match kullanabilirsiniz. Index imizde “description” adında yeni bir alanın daha olduğunu varsayarsak:

GET /products_st/_search
{
  "query": {
    "multi_match": {
      "query": "kart",
      "fields": [
        "name^2",
        "description^1"
      ],
      "fuzziness": "AUTO"
    }
  }
}

“name” için 2, “description” için 1 olarak ağırlık verebilir ve bu ağırlıklara göre _score ların üretilmesi sağlanabilir.

Bu konu ile ilgili .Net üzerinde örnekte yapmak istiyorum ama makaleyi daha fazla uzatmamak için burada bitiriyorum. .Net için örnek yapmak isterseniz Elastic.Clients.Elasticsearch paketini kullanabilirsiniz (Github: https://github.com/elastic/elasticsearch-net). Elasticsearch ten bağımsız projenizde Fuzzy Query kullanmak isterseniz, yine aynı algoritmayı kullanan FuzzySharp ‘ı (https://github.com/JakeBayer/FuzzySharp) tercih edebilirsiniz.

Başka bir makalede görüşmek üzere.

Fuzzy Query Nedir? Elasticsearch ve Kibana Console – Dev Tools Örneği yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Nerelerde Kullanılır?

Levenshtein Mesafesi kullanım alanları için birçok örnek verebiliriz:

• Form doğrulama: Ad, soyad gibi alanlarda olası yazım hatalarını yakalayabilir.
• Veri temizliği: Veri tabanındaki benzer kayıtları gruplayabilir. Örn: benzer üyelik tespiti gibi.
• OCR sonrası düzeltme: Görüntüden alınan metindeki hataların belirlenmesinde kullanılabilir.
• Arama motorları: Hatalı yazılmış sorgulara öneriler sunar.

Nasıl Hesaplanır ve Örnekler

Levenshtein algoritması, dinamik programlama kullanır. Her iki string’e ait karakterler bir matrisin satır ve sütunlarına yerleştirilir. Bu matrisin her hücresinde, iki kelimenin o ana kadar olan kısmı arasındaki minimum dönüşüm maliyeti hesaplanır.

1.Örnek: Sarı ile renklendirdiğim alandaki minimum değer alınır, “s” ve “t” birbirinden farklı karakterler ise minimum değere 1 eklenerek, kesişen hücreye yazılır. Bu örneğin ilk adımı için hesaplarsak, minimum değerimiz sıfır olacak, “s” ve “t” birbirinden farklı olduğu için +1 yaptığımızda yeni hücreye yazacağımız değer 0+1 = 1 olacaktır. Aynı işlemi bir sağa geçerek yaptığımızda tabloda göründüğü gibi 2 sayısını elde ediyoruz. Hesaplama algoritmasını diğer hücreler içinde aynı şekilde uygulandığında 1.Örnek için bulacağımız sayı 4 olacaktır. Yani “shine” ve “train” kelimeleri arasındaki dönüşüm için minimum 4 işleme ihtiyaç var demektir.

2.Örnek: İlk örnekte bahsettiğim gibi, algoritmayı bu örnek için de uyguladığımızda minimum işlem sayısını 3 olarak buluruz.

Özet

Levenshtein Mesafesi, basit ama güçlü bir metin benzerliği algoritmasıdır. Hatalı girişleri yakalamak, öneriler sunmak veya veri temizliği yapmak isterseniz alternatif olarak bu algoritmadan faydalanabilirsiniz. Bu algoritma Elasticsearch ‘de de kullanılıyor, yakın zamanda bununla ilgili bir yazı da paylaşacağım.

Yeni bir yazıda görüşmek üzere

Faydalandığım Linkler

https://devopedia.org/levenshtein-distance

https://www.youtube.com/watch?v=Dd_NgYVOdLk

Levenshtein Mesafesi (Levenshtein Distance) Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

1. Asenkron Programlama ve I/O İşlemleri

Asenkron programlama, uygulamalarımızın uzun süren I/O işlemleri sırasında bloklanmasını önler. Örneğin, bir veritabanı sorgusunun sonuçlanmasını beklerken diğer işlemler devam edebilir, böylece uygulamamızın yanıt süresi önemli ölçüde kısalır.

Asenkron programlama sayesinde, özellikle web uygulamalarında kullanıcı deneyimi iyileştirilir ve uygulamanızın genel performansı artar.

2. Bellek Yönetimi ve Garbage Collection

Performans optimizasyonu için, bellek kullanımını minimize etmek ve gereksiz nesne oluşturmalardan kaçınmak önemlidir. IDisposable interface ini kullanarak bellek yönetimini kontrol altında tutabilir ve using ifadesiyle kaynakları doğru bir şekilde Dispose edebilirsiniz.

3. Önbellekleme (Caching)

Önbellekleme, sık kullanılan verilerin bellekte tutulmasıyla uygulamamızın performansını artırabilir. .NET Core’da MemoryCache ve DistributedCache gibi önbellekleme stratejileri kullanarak, veritabanı sorgularını azaltabilir ve yanıt sürelerini iyileştirebilirsiniz.

Örneğin, bir web uygulamasında kullanıcı bilgilerini sık sık sorguluyorsanız, bu bilgileri cache leyerek her seferinde veritabanına gitme ihtiyacını ortadan kaldırabilirsiniz. Ayrıca, “Response Caching” kullanarak statik içerikleri cache leyebilir ve client lara daha hızlı yanıt dönebilirsiniz. Basitçe bir örnek vermek gerekirse :

public class HomeController: Controller
{
    [HttpGet]
    [ResponseCache(Duration = 180, Location = ResponseCacheLocation.Any)]
    public IActionResult GetData()
    {
        return Ok($"Responses are generated on {DateTime.Now}");
    }
}

4. Veritabanı Optimizasyonu

Veritabanı, bir uygulamanın performansını doğrudan etkileyen bileşenlerden biridir. .NET Core’da Entity Framework Core gibi ORM (Object-Relational Mapping) araçları kullanırken, sorguları optimize etmek büyük önem taşır.

AsNoTracking özelliğini kullanarak sorguların izleme yapılmadan çalışmasını sağlayabilir ve böylece performansı artırabilirsiniz. Ayrıca, veritabanı tarafında indeksler oluşturmak, gereksiz veri yükünü azaltır ve sorgu sürelerini kısaltır. Daha gelişmiş optimizasyonlar için, SQL Execution Plan hazırlanıp inceleyebilir ve karmaşık işlemleri Stored Procedure’lar ile gerçekleştirebilirsiniz.

5. HTTP Performans Optimizasyonu

HTTP istek ve yanıtlarının optimize edilmesi, özellikle web uygulamalarında kritik bir rol oynar. HTTP isteklerini gzip veya brotli gibi sıkıştırma teknikleriyle sıkıştırmak, bant genişliği kullanımını azaltır ve yanıt sürelerini hızlandırır.

.NET Core’da middleware kullanarak bu tür optimizasyonları kolayca uygulayabilirsiniz. Ayrıca, HttpClient gibi araçları kullanırken yeniden kullanılabilir HttpMessageHandler instance ları oluşturmak, bellek tüketimini ve bağlantı açma maliyetlerini azaltır.

6. Multithreading ve Paralel Programlama

Multithreading ve paralel programlama, CPU kaynaklarını en iyi şekilde kullanarak uygulamanızın performansını artırabilir. .NET Core’da Task Parallel Library (TPL) ve PLINQ (Parallel LINQ) kullanarak, büyük veri kümeleri üzerinde paralel işlemler gerçekleştirebilirsiniz.

Örneğin, bir görüntü işleme uygulamasında her bir resmi farklı bir iş parçacığında işlemek, işlem süresini büyük ölçüde kısaltabilir. Ancak, multithreading kullanırken iş parçacıkları arasındaki veri tutarlılığı ve kilitlenmelere (deadlock) dikkat etmek önemlidir.

7. Dağıtık Sistemlerde Performans

Mikroservis mimarisi gibi dağıtık sistemlerde performansını optimize etmek, hem iletişim hem de veri tutarlılığı açısından önemlidir. Mikroservisler arasında mesajlaşma ve veri paylaşımı yaparken gecikmeleri minimize etmek için RabbitMQ, Kafka gibi mesajlaşma kuyruklarını kullanabilirsiniz.

Ayrıca, dağıtık izleme (distributed tracing) araçlarıyla, mikroservisler arasında geçen süreyi izleyebilir ve performansı optimize etmek için gerekli düzenlemeleri yapabilirsiniz.

8. DevOps ile Performans İzleme ve Sürekli İyileştirme

Performans optimizasyonu sadece geliştirme aşamasında değil, uygulamanın yayınlanması ve bakım sürecinde de önemlidir. DevOps süreçlerine performans izleme ve iyileştirme adımlarını entegre ederek, uygulamanızın performansını sürekli olarak takip edebilir ve iyileştirebilirsiniz.

CI/CD pipeline’larına performans testlerini entegre etmek, her kod değişikliğinde performansın etkilenip etkilenmediğini kontrol etmenizi sağlar. Azure DevOps, Jenkins gibi araçlar kullanarak performans metriklerini sürekli izleyebilir ve gerektiğinde hızlı bir şekilde müdahale edebilirsiniz.

Bu makalede amacım bazı şeylere dikkat çekmekti. Buradaki anahtar kelimelerin size bir faydası olduysa ne mutlu bana

Sonraki yazıda görüşmek üzere.

.NET Core ile Performans Optimizasyonu: İpuçları ve Teknikler yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

SignalR Nedir?

SignalR, ASP.NET Core çatısı altında bulunan bir kütüphanedir. İstemciler ile sunucu arasında çift yönlü, asenkron bir iletişim sağlar ve uygulamanızda gerçek zamanlı özellikler eklemenizi kolaylaştırır. Buna farklı bir örnek daha vermek gerekirse; bildirimler. Bildirimler bulunduğunuz web sitesinde sayfa yenilenmeden ekranınıza düşebilir.

Yeni proje oluşturarak örneğimize başlayalım.

Projemize SignalR ı eklemek için Solution Explorer dan projeye sağ tıklayın > Add > Add Client-Side Library. Provider, Library ve diğer bilgileri aşağıdaki gibi düzenleyip Install edin.

Şimdi mesajlaşmayı yönetecek olan hub ımızı oluşturabiliriz.

using Microsoft.AspNetCore.SignalR;

namespace SignalRTest.Hubs
{
    public class ChatHub : Hub
    {
        public async Task SendMessage(string user, string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", user, message);
        }
    }
}

Hub ımızı oluşturduktan sonra Program.cs de SignalR ı inject edelim ve routingini verelim.

Home/Index.cshtml içeriğini aşağıdaki gibi düzenleyelim. Bu tasarımı kullanarak mesaj gönderecek ve gönderilen mesajları sayfada göreceğiz.

<div class="container">
    <div class="row p-1">
        <div class="col-1">User</div>
        <div class="col-5"><input type="text" id="userInput" /></div>
    </div>
    <div class="row p-1">
        <div class="col-1">Message</div>
        <div class="col-5"><input type="text" class="w-100" id="messageInput" /></div>
    </div>
    <div class="row p-1">
        <div class="col-6 text-end">
            <input type="button" id="sendButton" value="Send Message" />
        </div>
    </div>
    <div class="row p-1">
        <div class="col-6">
            <hr />
        </div>
    </div>
    <div class="row p-1">
        <div class="col-6">
            <ul id="messagesList"></ul>
        </div>
    </div>
</div>
<script src="~/js/signalr/dist/browser/signalr.js"></script>
<script src="~/js/chat.js"></script>

Son olarak chat.js i hazırlayalım.

"use strict";

var connection = new signalR.HubConnectionBuilder().withUrl("/chatHub").build();

document.getElementById("sendButton").disabled = true;

connection.on("ReceiveMessage", function (user, message) {
    var li = document.createElement("li");
    document.getElementById("messagesList").appendChild(li);
    li.textContent = `${user} says ${message}`;
});

connection.start().then(function () {
    document.getElementById("sendButton").disabled = false;
}).catch(function (err) {
    return console.error(err.toString());
});

document.getElementById("sendButton").addEventListener("click", function (event) {
    var user = document.getElementById("userInput").value;
    var message = document.getElementById("messageInput").value;
    connection.invoke("SendMessage", user, message).catch(function (err) {
        return console.error(err.toString());
    });
    event.preventDefault();
});

Bu script, bir SignalR bağlantısı kurarak kullanıcıların real time mesaj gönderip almasını sağlar. Gönderilen her mesaj, sunucuya iletilir ve sunucudan gelen mesajlar diğer tüm istemcilere iletilir. Bu sayede kullanıcılar, diğer kullanıcıların mesajlarını anında görebilir.

Test:

Bu makalede, SignalR ile basit bir chat uygulaması geliştirdik. SignalR’ın sağladığı kolay entegrasyon ve güçlü özellikler sayesinde, gerçek zamanlı iletişim gerektiren projelerde oldukça etkili çözümler üretebilirsiniz. Gerçek zamanlı web uygulamaları geliştirmek için SignalR gibi güçlü araçların yanı sıra, WebSocket protokolü ve gRPC gibi diğer teknolojilere de göz atabilirsiniz. Bu sayede farklı senaryolar için en uygun çözümü bulabilirsiniz.

Yeni bir yazıda görüşmek dileğiyle.
Kalın sağlıcakla.

.Net Core 8 ile SignalR Kullanımı yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Webhook’lar sayesinde ilgili endpointlere istek atılarak gerçekleştirilen kontrollere gerek kalmaz. Bu sayede sunucu tarafı gereksiz yükten kurtulmuş olur. Ayrıca Data Consistency (Veri Tutarlılığı) ‘de sağlanmış olur.

Webhook’lar için aşağıdaki senaryoları örnek olarak verebiliriz:

1. Ödeme işlemi tamamlandığında müşteriye otomatik bir e-posta gönderme.
2. Bir blog gönderisi yayınlandığında sosyal medya platformlarında otomatik olarak paylaşım yapma.
3. Bir müşteri destek bileti oluşturulduğunda destek ekibine bildirim gönderme.
4. Bir siparişte güncelleme yapıldığında ilgili yerlere bildirim gönderme.

Webhook’lar, bir uygulamadan diğerine gerçek zamanlı veri iletimi sağladıkları için iş süreçlerini otomatikleştirmek ve entegrasyonları kolaylaştırmak için oldukça kullanışlıdır.

Biz örnek senaryo için yukarıda bahsettiğimiz senaryolardan en sonuncusunu uygulayabiliriz. İlk önce boş bir solution açalım ve içerisine 2 adet web api projesi ekleyelim. Ben isimlendirmelerimi aşağıdaki gibi yaptım.

Order.Api : Sipariş güncelleme, Subscribe olma ve Notification.Api servisini tetikleyen işlemleri içerecek. Bu apide RabbitMq ile ilgili işlemler yapacağımız için RabbitMQ.Client paketini nuget üzerinden yüklemeyi unutmayınız.

Notification.Api : Bildirim gönderecek servisimiz. Tabi bunu kodlamayacağız, tetiklendiğine dair ekrana mesaj basmamız yeterli.

Öncelikle Order.Api projemizde OrderController adında yeni bir controller oluşturalım.. Unutmayın burada sadece bir örnek çalışıyoruz bu işlemler farklı mimarilerde de uygulanabilir veya daha clean yazılabilir Bağımlılıkları azaltmak ve daha esnek bir yapı elde etmek için bağımlılıkları interface ler aracılığıyla tanımlamak daha iyi olabilir. Bu, servislerin test edilebilirliğini artırır ve gelecekte başka bir mesajlaşma sistemi ya da farklı bir implemantasyon kullanmak istediğinizde kodu daha kolay değiştirebilmenizi sağlar.

 [ApiController]
 [Route("api/[controller]")]
 public class OrderController : ControllerBase
 {
     private readonly RabbitMqPublisher _publisher;
     private readonly WebhookSubscriptionService _subscriptionService;

     public OrderController(RabbitMqPublisher publisher, WebhookSubscriptionService subscriptionService)
     {
         _publisher = publisher;
         _subscriptionService = subscriptionService;
     }

     [HttpPost("subscribe")]
     public IActionResult Subscribe([FromBody] string webhookUrl)
     {
         var subscription = new WebhookSubscription
         {
             WebhookUrl = webhookUrl
         };
         _subscriptionService.AddSubscription(subscription);
         return Ok(subscription);
     }

     [HttpPost("update")]
     public IActionResult UpdateOrder([FromBody] OrderUpdateRequest orderUpdateRequest)
     {
         var message = new OrderUpdateMessage
         {
             OrderId = orderUpdateRequest.OrderId,
             Status = orderUpdateRequest.Status,
             UpdatedDate = orderUpdateRequest.UpdatedDate
         };

         _publisher.PublishOrderUpdate(message);

         return Ok("Sipariş başarıyla güncellendi ve RabbitMq kuyruğuna gönderildi.");
     }
 }

Order.Api içerisinde Models klasörü altına :

namespace Order.Api.Models
{
    public class OrderUpdateRequest
    {
        public int OrderId { get; set; }
        public string Status { get; set; }
        public DateTime UpdatedDate { get; set; }
    }
}

namespace Order.Api.Models
{
    public class OrderUpdateMessage
    {
        public int OrderId { get; set; }
        public string Status { get; set; }
        public DateTime UpdatedDate { get; set; }
    }
}

namespace Order.Api.Models
{
    public class WebhookSubscription
    {
        public Guid Id { get; set; } = Guid.NewGuid();
        public string WebhookUrl { get; set; }
        public DateTime SubscribedDate { get; set; } = DateTime.UtcNow;
    }
}

OrderUpdateRequest, OrderUpdateMessage, WebhookSubscription model / dto larını oluşturalım.

Şimdi gerekli servislerimizi yazalım. Öncelikle siparişte bir güncelleme olduğunda bu işlemi kuyruğa atacak RabbitMqPublisher class ımızı oluşturalım.

using Order.Api.Models;
using RabbitMQ.Client;
using System.Text.Json;
using System.Text;

namespace Order.Api.Services
{
    public class RabbitMqPublisher
    {
        private readonly IConnection _connection;
        private string _queueName = "order_updated_queue";

        public RabbitMqPublisher()
        {
            var factory = new ConnectionFactory() { HostName = "localhost" };
            _connection = factory.CreateConnection();
        }

        public void PublishOrderUpdate(OrderUpdateMessage message)
        {
            using (var channel = _connection.CreateModel())
            {
                channel.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);

                var body = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(message));

                channel.BasicPublish(exchange: "", routingKey: _queueName, basicProperties: null, body: body);
            }
        }
    }
}

Subscribe ve Remove Subscribe işlemlerini içeren class ımız.

using Order.Api.Models;

namespace Order.Api.Services
{
    public class WebhookSubscriptionService
    {
        private readonly List<WebhookSubscription> _subscriptions = new List<WebhookSubscription>();

        public IEnumerable<WebhookSubscription> GetAllSubscriptions()
        {
            return _subscriptions;
        }

        public void AddSubscription(WebhookSubscription subscription)
        {
            _subscriptions.Add(subscription);
        }

        public void RemoveSubscription(Guid id)
        {
            var subscription = _subscriptions.FirstOrDefault(s => s.Id == id);
            if (subscription != null)
            {
                _subscriptions.Remove(subscription);
            }
        }
    }
}

Subscribe olan clientların bilgisini DB de tutmamız daha doğru olacaktır fakat burada konuya odaklandığım için DB işlemlerini yapmayacağım. Dilerseniz siz geliştirirken o şekilde yapabilir, webhookurl dışında farklı bilgiler de tutabilirsiniz.

Son olarak kuyruğu dinleyen ve bir mesaj geldiğinde Subscribe olmuş clientları bilgilendirecek olan class ımızı yazalım.

using Order.Api.Models;
using RabbitMQ.Client.Events;
using RabbitMQ.Client;
using System.Text.Json;
using System.Text;

namespace Order.Api.Services
{
    public class WebhookNotificationService
    {
        private readonly WebhookSubscriptionService _subscriptionService;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly IConnection _connection;
        private readonly IModel _channel;
        private string _queueName = "order_updated_queue";

        public WebhookNotificationService(WebhookSubscriptionService subscriptionService, IHttpClientFactory httpClientFactory)
        {
            _subscriptionService = subscriptionService;
            _httpClientFactory = httpClientFactory;

            var factory = new ConnectionFactory() { HostName = "localhost", Port = 5672 };
            _connection = factory.CreateConnection();
            _channel = _connection.CreateModel();

            _channel.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
        }

        public void Start()
        {
            var consumer = new EventingBasicConsumer(_channel);
            consumer.Received += async (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = JsonSerializer.Deserialize<OrderUpdateMessage>(Encoding.UTF8.GetString(body));

                if (message != null)
                {
                    await NotifySubscribers(message);
                }
            };

            _channel.BasicConsume(queue: _queueName, autoAck: true, consumer: consumer);
        }

        private async Task NotifySubscribers(OrderUpdateMessage message)
        {
            var client = _httpClientFactory.CreateClient();

            var webhookPayload = new
            {
                orderId = message.OrderId,
                status = message.Status,
                updatedDate = message.UpdatedDate
            };

            var jsonPayload = JsonSerializer.Serialize(webhookPayload);
            var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

            foreach (var subscription in _subscriptionService.GetAllSubscriptions())
            {
                await client.PostAsync(subscription.WebhookUrl, content);
            }
        }
    }
}

WebhookNotificationService imizin ayağa kalkması ve diğer injectionlar için Program.cs i aşağıdaki gibi düzenleyelim.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient();
builder.Services.AddSingleton<RabbitMqPublisher>();
builder.Services.AddSingleton<WebhookSubscriptionService>();
builder.Services.AddSingleton<WebhookNotificationService>();

builder.Services.AddControllersWithViews();

var app = builder.Build();

// WebhookNotificationService'i başlat
var notificationService = app.Services.GetRequiredService<WebhookNotificationService>();
notificationService.Start();

Order.Api tarafındaki geliştirmelerimizi bitirdik.

Notification.Api tarafında ise NotificationController adında yeni bir controller açalım.

using Microsoft.AspNetCore.Mvc;
using Notification.Api.Models;

namespace Notification.Api.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class NotificationController : Controller
    {
        private readonly ILogger<NotificationController> _logger;

        public NotificationController(ILogger<NotificationController> logger)
        {
            _logger = logger;
        }

        [Route("Send")]
        [HttpPost]
        public async Task<IActionResult> Send(OrderUpdateMessage message)
        {
            //Bildirim gönderim işlemleri.
            //await _notificationService.Send(message);

            Console.WriteLine(JsonConvert.SerializeObject(message));

            return Ok();
        }
    }
}

Order.Api aracılığı ile subscribe olurken Notification.Api mizin ayağa kalktığı url ve send metodunun tetiklenmesini istediğimiz için url imizi ona göre kayıt ettireceğiz. 2 uygulamada da gerekli geliştirmeleri tamamladıktan sonra teste geçebiliriz.

Test – Postman ekran görüntüleri:

2 projemizinde ayağa kalmasını istediğimiz için multiple startup ayarımızı, Solution>Properties dan yapıyoruz.

Projeleri ayağa kaldırdıktan sonra öncelikle Order.Api deki subscribe endpointine istek atıp, sipariş güncelleme işlemi yapıldığında bizi bilgilendirmesini istiyoruz.

Daha sonra sipariş güncelleme işlemi yapıyoruz.

RabbitMq da kuyruğumuz oluştu.

Ve Notification.Api mizin console ekranı:

Sonuç olarak; bu yazımızda temel bir webhook servisi oluşturmaya çalıştık. Proje kodlarına ve postman collection dosyasına buradan erişebilirsiniz.

Yeni yazılarda görüşmek üzere !

Webhook Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Observability, uygulamalarımızın production ortamında durumlarını izlemeyebilme yeteneğidir. Uygulamalarımızın performansını, hatalarını ve genel durumunu izlemememize olanak tanır. Observability loglar (logs), metrikler (metrics) ve izler (traces) olmak üzere 3 temel bileşenden oluşur.

1. Loglar (Logs)
   Loglar, sistemin çalıştığı sırada neler olup bittiğini, hangi işlemlerin yapıldığını ve olası hataları göstermek için kullanılır. Loglar, bir sorunun nedenini anlamak ve teşhis etmek için çok önemlidir.
   
2. Metrikler (Metrics)
   Metrikler, bir sistemin performansını ölçmek için kullanılan sayısal verilerdir. Bu veriler, CPU kullanımı, bellek kullanımı, istek/saniye (requests per second), hata oranı gibi çeşitli ölçütleri içerir. Metrikler, sistemin genel sağlığı hakkında bilgi verir ve performans sorunlarını tespit etmeye yardımcı olur.
   
3. Traces (İzler)
   Traces, bir operasyonun baştan sonra izlenmesidir. Dağıtık sistemlerde, bir kullanıcı isteğinin işlenme sürecini anlamak zordur. Bu yüzden trace data, isteğin başlangıcından sonuna kadar olan süreci izlemeye yardımcı olur. Trace data, özellikle mikro servis mimarilerinde, bir isteğin hangi servislerde nasıl işlediğini anlamak için kullanılır.

Observability’nin Faydaları

• Karmaşık Sistemlerde Görünürlük: Modern uygulamalar genellikle mikro servisler, konteynerler ve bulut tabanlı mimariler gibi karmaşık yapılara sahiptir. Observability, bu karmaşık sistemlerin nasıl çalıştığını anlamayı kolaylaştırır.
• Sorunları Hızlı Teşhis Etme: Observability, sistemdeki anormallikleri ve hataları hızlı bir şekilde tespit etmemizi sağlar. Bu sayede, sorunlar meydana geldiğinde hızlı müdahale edilerek sistemin kesinti süresi en aza indirilir.
• Proaktif İzleme: İyi bir Observability uygulaması, potansiyel sorunları meydana gelmeden önce tespit etmeye yardımcı olur. Bu, sistemin daha stabil ve güvenilir çalışmasını sağlar.
• İyileştirilmiş Kullanıcı Deneyimi: Observability, kullanıcıların deneyimini olumsuz etkileyebilecek performans sorunlarını tespit etmeyi ve düzeltmeyi sağlar. Bu da genel kullanıcı memnuniyetini artırır.

Observability Araçları ve Teknolojileri

Observability’yi uygulamak için çeşitli araçlar ve teknolojiler kullanılır:

• Prometheus ve Grafana: Prometheus, metrik verilerini toplamak ve izlemek için kullanılan popüler bir araçtır. Grafana ise bu metrikleri görselleştirmek ve izlemek için kullanılan bir platformdur.
• ELK Stack (Elasticsearch, Logstash, Kibana): Bu araç seti, log yönetimi ve analizi için yaygın olarak kullanılır. Elasticsearch, büyük miktarda log verisini depolamak için kullanılırken, Logstash bu verileri toplar ve işler, Kibana ise görselleştirme sağlar.
• Jaeger ve Zipkin: Jaeger ve Zipkin, dağıtık izleme için kullanılan araçlardır. Bu araçlar, mikro hizmetler arasında geçen işlemleri izleyerek, performans sorunlarını tespit etmeye yardımcı olur.

Observability ve Monitoring Arasındaki Fark

Monitoring ve Observability terimleri bazen birbirinin yerine kullanılsa da, aslında farklı kavramlardır:

• Monitoring: Monitoring, belirli metrikleri ve logları önceden belirlenmiş eşiklere göre izlemeyi ifade eder. Örneğin, sistemdeki oluşan 500 hataları ile ilgili bir uyarı tetiklenebilir.
• Observability: Observability, monitoring’in ötesine geçerek, sistemin genel durumu hakkında daha detaylı bilgi sağlar. Observability, bir sistemdeki beklenmedik sorunları anlamak ve teşhis etmek için gerekli olan verileri sunar.

Faydalandığım linkler:
https://www.honeycomb.io/blog/what-is-observability-key-components-best-practices
https://www.linkedin.com/pulse/observability-vs-monitoring-g%C3%BCrkan-t%C3%BCzmen/

Yeni yazılarda görüşmek üzere

Observability (Gözlemlenebilirlik) Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.

Channels API Özellikleri

1. İki Ana Kanal Türü:
   • UnboundedChannel: Kapasitesi sınırsız olan bir kanaldır. Herhangi bir veri miktarını kabul eder.
   • BoundedChannel: Belirli bir kapasiteye sahip olan bir kanaldır. Maksimum kapasiteye ulaştığında Producer’lar bekletilir.
2. Asenkron İletişim: Channels API, async/await desenini destekler.
3. Backpressure Desteği: BoundedChannel kullanarak, Consumer yetişemediğinde Producer ‘ın durdurulmasını sağlar. Bu, sistemin aşırı yüklenmesini engeller.
4. Thread-Safe: Channels, çoklu thread ortamında güvenli bir şekilde çalışacak şekilde tasarlanmıştır. Bu sayede birden fazla Producer ve Consumer aynı kanalı kullanabilir.

Kullanıma Örnek

• Producer-Consumer Deseni: Örneğin, bir veri işleme hattında bir thread veri üretirken, başka bir thread bu veriyi işleyebilir.

Örnek Kod

Aşağıda basit bir UnboundedChannel örneği bulunmaktadır, yeni bir Console App oluşturarak uygulamayı test edebilirsiniz.

var userDataChannel = Channel.CreateUnbounded<UserModel>();

// Producer Task
var producer = Task.Run(async () =>
{
    for (int i = 0; i < 10; i++)
    {
        await userDataChannel.Writer.WriteAsync(new UserModel() { Id = i, Name = "User_" + i });
        Console.WriteLine($"=========================");
        Console.WriteLine($"Produced: User_{i}");
    }
    userDataChannel.Writer.Complete();
});

// Consumer Task
var consumer = Task.Run(async () =>
{
    await foreach (var userModel in userDataChannel.Reader.ReadAllAsync())
    {
        Console.WriteLine($"=========================");
        Console.WriteLine($"Consumed: {userModel.Id}");
        Console.WriteLine($"Consumed: {userModel.Name}");
    }
});

Task.WhenAll(producer, consumer);

Çıktı:

Bu örnekte, UserModel alan bir channels oluşturduk ve produce ettik. Consumer tarafında da eş zamanlı olarak veriyi tükettik ve ekrana bastık. Buradaki kullanımları projenize göre şekillendirebilir, Producer ve Consumer kısımlarını ayrı ayrı class lara taşıyıp daha kullanılabilir bir yapı kurgulayabilirsiniz.

Faydalandığım linkler:
https://learn.microsoft.com/en-us/dotnet/core/extensions/channels
https://code-maze.com/dotnet-producer-consumer-channels/

Yeni bir yazıda görüşmek üzere

.Net Core Channels Nedir? yazısı ilk önce Sebahattin Tonbul | Blog üzerinde ortaya çıktı.