Modern web uygulamaları, kullanıcılarına anlık ve dinamik deneyimler sunmak zorundadır. Peki, tarayıcılarınızın sunucudan sürekli güncel verileri, karmaşık altyapılar kurmadan, basitçe almasını nasıl sağlarız? Server-Sent Events (SSE) ve Ballerina ile gerçek zamanlı veri akışını kolayca hayata geçirebilirsiniz.

Günümüzün dijital dünyasında kullanıcı beklentileri hiç olmadığı kadar yüksek. Statik web sayfalarının yerini, anlık bildirimler, canlı skorlar, borsa verileri, sohbet uygulamaları ve sürekli güncellenen gösterge panoları aldı. Bir kullanıcı, favori takımının gol attığını veya bir hisse senedinin fiyatının değiştiğini saniyeler içinde öğrenmek ister. Geleneksel HTTP istek-cevap döngüsü, bu tür gerçek zamanlı senaryolar için yetersiz kalır. Sürekli sorgulama (polling) yapmak sunucu kaynaklarını yorarken, karmaşık WebSockets bağlantıları her zaman gerekli olmayabilir. İşte bu noktada, tek yönlü, verimli ve kullanımı kolay bir alternatif olan Server-Sent Events (SSE) devreye girer. Ballerina gibi ağ odaklı dillerle birleştiğinde, SSE’nin sunduğu basitlik ve güç, gerçek zamanlı uygulamalar geliştirmeyi hiç olmadığı kadar erişilebilir kılar. Bu makalede, SSE’nin temel prensiplerinden, Ballerina ile nasıl adım adım uygulanacağına kadar tüm detayları ele alacak, gerçek dünya senaryolarıyla bu teknolojinin potansiyelini keşfedeceğiz. Amacımız, karmaşık altyapılar kurmadan, Ballerina’nın doğal eşzamanlılık özelliklerini kullanarak nasıl güçlü ve ölçeklenebilir gerçek zamanlı veri akışı çözümleri oluşturabileceğinizi göstermektir. Bu sayede, kullanıcılarınıza daha zengin ve etkileşimli deneyimler sunabilirsiniz.

Server-Sent Events (SSE) Nedir? Tek Yönlü İletişimin Gücü

Server-Sent Events (SSE), adından da anlaşılacağı gibi, sunucunun istemciye (genellikle bir web tarayıcısı) olay tabanlı veri akışı göndermesini sağlayan bir web teknolojisidir. Temel farkı, geleneksel HTTP’deki istek-cevap modelinin aksine, SSE’nin tek yönlü bir iletişim kanalı kurmasıdır. Yani, istemci bir bağlantı başlatır ve sunucu bu bağlantı üzerinden istemciye sürekli olarak veri “iter”. Bu, özellikle bir kaynaktan sürekli bilgi akışı beklediğiniz, ancak istemcinin sunucuya veri göndermesine gerek duymadığınız senaryolar için mükemmel bir çözümdür. Örneğin, canlı spor skorları, borsa fiyat güncellemeleri, haber akışları veya bir IoT cihazından gelen sensör verileri gibi durumlar SSE için idealdir.

SSE, HTTP/1.1 protokolü üzerinden çalışır ve bu da onu mevcut web altyapılarıyla son derece uyumlu hale getirir. Diğer bir deyişle, özel bir protokol veya karmaşık bir el sıkışma mekanizmasına ihtiyaç duymazsınız; basit bir HTTP bağlantısı yeterlidir. Sunucu, Content-Type: text/event-stream başlığı ile yanıt vererek istemciye bir olay akışı gönderdiğini belirtir. İstemci tarafında ise, JavaScript’in yerleşik EventSource API’si bu akışı kolayca tüketebilir. SSE’nin sunduğu otomatik yeniden bağlanma (reconnection) mekanizması, ağ kesintileri veya sunucu yeniden başlatmaları gibi durumlarda istemcinin bağlantıyı otomatik olarak yeniden kurmasını sağlar, böylece veri akışının sürekliliği garanti altına alınır. Bu özellik, geliştiricilerin hata yönetimi ve bağlantı istikrarı konusunda daha az endişelenmesini sağlar.

Peki, SSE’yi WebSockets veya düzenli polling ile karşılaştırdığımızda farklar nelerdir?

• Polling (Sürekli Sorgulama): İstemci, belirli aralıklarla sunucuya yeni veri olup olmadığını sorar. Bu, sunucu üzerinde gereksiz yük oluşturur ve verinin anında değil, bir sonraki sorgulama anında gelmesine neden olur. Gecikme yaşanabilir ve kaynak tüketimi yüksektir.
• WebSockets: İstemci ve sunucu arasında çift yönlü, tam dubleks bir iletişim kanalı kurar. Hem istemci hem de sunucu birbirine istediği zaman veri gönderebilir. Sohbet uygulamaları veya çevrimiçi oyunlar gibi sürekli iki yönlü iletişimin gerekli olduğu durumlarda idealdir. Ancak, daha karmaşık bir protokol ve sunucu tarafında daha fazla kaynak yönetimi gerektirebilir.
• Server-Sent Events (SSE): Tek yönlü bir iletişim kanalıdır; sunucudan istemciye veri akışı sağlar. WebSockets kadar karmaşık değildir, HTTP üzerinden çalışır ve otomatik yeniden bağlanma özelliklerine sahiptir. İstemcinin sunucuya sık sık veri göndermesine gerek olmayan durumlarda WebSockets’a göre daha hafif ve basit bir çözümdür.

Özetle, SSE, gerçek zamanlı veri akışını basitlik, verimlilik ve mevcut web teknolojileriyle uyum içinde sunarak, birçok yaygın senaryo için mükemmel bir denge noktası sağlar. Özellikle, bir borsa takip uygulaması düşünün; hisse senedi fiyatları sürekli değişir ve kullanıcının bu değişimleri anında görmesi gerekir. Kullanıcıların fiyatları sunucuya göndermesine gerek olmadığı için, SSE bu tür bir uygulama için WebSockets’tan daha uygun ve daha az kaynak tüketen bir çözüm olacaktır. Ballerina’nın eşzamanlılık yetenekleriyle birleştiğinde, SSE’nin sunduğu bu avantajlar daha da belirginleşir ve gerçek zamanlı sistemler geliştirmek için güçlü bir araç haline gelir.

Ballerina ve Gerçek Zamanlı Akış: Neden Ballerina SSE İçin İdeal?

Ballerina, dağıtık sistemler ve ağ odaklı uygulamalar geliştirmek için tasarlanmış modern bir programlama dilidir. Konkurenslik (eşzamanlılık) ve ağ iletişimi, dilin çekirdeğinde yer alır, bu da onu gerçek zamanlı veri akışı ve özellikle Server-Sent Events (SSE) gibi teknolojiler için son derece uygun hale getirir. Ballerina’nın akışkan sözdizimi ve yerleşik ağ yapıları, karmaşık gerçek zamanlı senaryoları bile şaşırtıcı derecede basit ve okunabilir bir şekilde ifade etmenize olanak tanır. Dilin temelinde yer alan service ve resource kavramları, HTTP servislerini tanımlamayı doğal ve sezgisel bir süreç haline getirir. Bu yapısal yaklaşım, bir SSE sunucusunun nasıl davranacağını açıkça belirtmeye yardımcı olurken, aynı zamanda hata denetimi ve kaynak yönetimini de basitleştirir. Ayrıca, Ballerina’nın yerleşik desteklediği konkurens modelleri (örneğin, worker‘lar ve strand‘lar), birden fazla istemciye aynı anda veri akışı sağlarken bile performans sorunları yaşamamanızı temin eder. Her bir istemci bağlantısı, kendi hafif iş parçacığında ele alınabilir, böylece sunucunun ölçeklenebilirliği artırılır. Bu özellikler, özellikle çok sayıda eşzamanlı bağlantının yönetilmesi gereken gerçek zamanlı veri akışı uygulamaları için kritik öneme sahiptir.

Ballerina’nın ağ iletişimi konusundaki doğal yetenekleri, SSE gibi HTTP tabanlı akış protokollerini uygulamayı çok daha kolaylaştırır. Ballerina’da bir HTTP servisi tanımlamak ve bir resource üzerinden veri akışı sağlamak için özel kütüphanelere veya karmaşık konfigürasyonlara ihtiyaç duymazsınız. Dilin kendisi, bu tür senaryolar için gerekli yapı taşlarını zaten sunar. Örneğin, bir IoT projesinde akıllı ev sensörlerinden gelen sıcaklık, nem veya hareket verilerini anlık olarak bir mobil uygulamaya veya web arayüzüne aktardığınızı düşünün. Her sensör verisi geldiğinde, sunucunuz bu veriyi bağlı istemcilere SSE aracılığıyla iletebilir. Ballerina’nın eşzamanlılık ve olay odaklı yapısı sayesinde, sensörlerden gelen birden fazla veri akışını aynı anda işleyebilir ve bunları bağlı tüm istemcilere verimli bir şekilde dağıtabilirsiniz. Bu, Ballerina’nın hem geliştirme kolaylığı hem de çalışma zamanı verimliliği açısından SSE için neden ideal bir seçim olduğunu gösterir.

Dilin sağladığı basitlik, geliştiricilerin iş mantığına odaklanmasına ve ağ katmanının karmaşıklığıyla boğuşmak yerine gerçek zamanlı veri akışı senaryolarını hızla hayata geçirmesine olanak tanır. Ayrıca, Ballerina’nın güçlü tür sistemi, derleme zamanında olası hataları yakalamaya yardımcı olur, bu da daha güvenilir ve bakımı kolay kod yazmanızı sağlar. Özetle, Ballerina’nın tasarlanmış olduğu temel prensipler – ağ odaklılık, eşzamanlılık ve basitlik – onu Server-Sent Events kullanarak gerçek zamanlı uygulamalar oluşturmak için mükemmel bir araç haline getirir. Geliştiriciler, daha az kod yazarak ve daha az karmaşıklıkla, yüksek performanslı ve ölçeklenebilir veri akışı servisleri geliştirebilirler.

Ballerina ile İlk SSE Sunucusu Nasıl Yazılır? Adım Adım Rehber

Ballerina ile bir Server-Sent Events (SSE) sunucusu oluşturmak oldukça basittir. İşin özü, bir HTTP servisi tanımlamak ve belirli bir kaynağa yapılan istekleri text/event-stream içerik türüyle yanıtlayarak olay akışı sağlamaktır. Bu bölümde, adım adım bir Ballerina SSE sunucusu oluşturacak ve temel çalışma prensiplerini inceleyeceğiz. İlk olarak, Ballerina projemizi oluşturarak başlayalım. Ardından, bir HTTP servisi içinde SSE akışı sağlayacak bir kaynak (resource) fonksiyonu tanımlayacağız. Bu fonksiyon, istemciye sürekli olarak veri gönderecek şekilde tasarlanacaktır. Verileri göndermek için http:Caller nesnesini kullanacağız, bu nesne Ballerina’nın HTTP servisleriyle etkileşim kurmak için sağladığı bir araçtır. Ayrıca, Ballerina’nın akış (stream) yetenekleri sayesinde, olayların istemciye nasıl gönderileceğini kontrol etmek de oldukça kolaydır. Veri akışının doğru şekilde çalışması için, HTTP yanıt başlıklarında Content-Type olarak text/event-stream ayarlandığından emin olmalıyız.

Aşağıda, Ballerina ile basit bir SSE sunucusu örneği bulunmaktadır. Bu örnek, her saniye artan bir sayı gönderen bir akış oluşturur.

import ballerina/http;
import ballerina/io;
import ballerina/time;

// HTTP servisimizi tanımlıyoruz. Bu servis, 9090 portundan gelen istekleri dinleyecek.
service /events on new http:Listener(9090) {

    // '/stream' yoluna gelen GET isteklerini karşılayan bir kaynak fonksiyonu.
    resource function get stream(http:Caller caller) returns error? {
        // SSE için Content-Type başlığını ayarlıyoruz.
        check caller->addHeader("Content-Type", "text/event-stream");
        check caller->addHeader("Cache-Control", "no-cache");
        check caller->addHeader("Connection", "keep-alive");

        io:println("Yeni bir SSE istemcisi bağlandı.");

        // Olay ID'si için bir sayaç başlatıyoruz.
        int eventId = 0;

        // Sürekli olarak veri gönderecek bir döngü başlatıyoruz.
        // Bu döngü, istemci bağlantısı kesilene kadar devam eder.
        while (true) {
            // Bir mesaj oluşturuyoruz. SSE formatında event, id ve data alanlarını kullanıyoruz.
            string data = string data: {"message": "Merhaba, bu ${eventId}. olay!", "timestamp": "${time:utcNow().toString()}"}\n;
            string eventType = event: message\n;
            string id = id: ${eventId}\n;
            string retry = retry: 1000\n; // İstemcinin bağlantı koptuğunda ne kadar süre sonra yeniden deneyeceğini belirtir (ms).

            // Oluşturulan mesajı istemciye gönderiyoruz.
            error? result = caller->writeStream({
                content: eventType + id + retry + data + "\n" // Her olaydan sonra bir boş satır olması önemlidir.
            });

            // Eğer bir hata oluşursa (örneğin istemci bağlantıyı kapatırsa), döngüden çıkıyoruz.
            if (result is error) {
                io:println("İstemci bağlantısı kesildi veya bir hata oluştu: " + result.message());
                break;
            }

            eventId += 1; // Olay ID'sini artırıyoruz.
            time:sleep(1); // 1 saniye bekliyoruz.
        }
        io:println("SSE akışı sona erdi.");
        return;
    }
}
  

Yukarıdaki kod bloğunda gördüğünüz gibi, Ballerina'da bir SSE akışı oluşturmak için:

1. http:Listener kullanarak bir HTTP servisi başlatıyoruz.
2. resource function get stream(http:Caller caller) ile /stream yoluna gelen GET isteklerini dinleyen bir kaynak tanımlıyoruz. Bu fonksiyona gelen caller nesnesi, istemciyle iletişim kurmak için kullanılır.
3. caller->addHeader(...) metoduyla SSE için gerekli olan Content-Type: text/event-stream ve diğer ilgili HTTP başlıklarını (Cache-Control, Connection) ekliyoruz. Bu başlıklar, tarayıcıya bu bağlantının bir olay akışı olduğunu bildirir.
4. Bir while(true) döngüsü içinde, belirli aralıklarla (bu örnekte 1 saniye) yeni olaylar oluşturuyoruz.
5. Her olay için, SSE'nin standart formatına uygun olarak event:, id:, data: ve isteğe bağlı olarak retry: alanlarını içeren bir string oluşturuyoruz. Unutmayın, her olay bloğu bir veya daha fazla boş satırla bitmelidir.
6. caller->writeStream(...) metodunu kullanarak oluşturulan bu string'i istemciye gönderiyoruz. Bu metod, bağlantı açık olduğu sürece veriyi akış halinde göndermeye devam eder.
7. writeStream'den gelen hata kontrolü, istemcinin bağlantıyı kapatması gibi durumları yakalamak ve sunucu tarafında temiz bir şekilde çıkış yapmak için önemlidir.

Bu basit yapı, Ballerina'nın SSE akışlarını ne kadar kolay yönetebildiğini göstermektedir. Geliştiriciler, bu temeli alarak karmaşık gerçek zamanlı veri yayınlama senaryolarını kolayca inşa edebilirler. Ballerina'nın güçlü konkurensi ve ağ soyutlamaları sayesinde, aynı anda binlerce istemciye hizmet verebilen robust SSE servisleri oluşturmak mümkündür.

Bir SSE İstemcisi Nasıl Oluşturulur? Tarayıcı ve JavaScript Kullanımı

Ballerina ile bir SSE sunucusu oluşturduğumuza göre, bu sunucudan gelen verileri tüketmek için bir istemciye ihtiyacımız var. Web tarayıcıları, JavaScript'in yerleşik EventSource API'si sayesinde SSE akışlarını kolayca dinleyebilir. EventSource, tek yönlü bir bağlantı kurar, gelen olayları otomatik olarak ayrıştırır ve ağ kesintilerinde yeniden bağlanma (reconnection) denemeleri yapar. Bu bölüm, basit bir HTML ve JavaScript istemcisi ile Ballerina SSE sunucumuzdan gelen verileri nasıl alacağımızı gösterecektir.

    
    
    
    


    

        
Ballerina SSE Canlı Veri Akışı
        
Durum: Bağlantı Kesik
        

            
        
    

    


  

Bu istemci kodunda önemli noktalar şunlardır:

• new EventSource('http://localhost:9090/events/stream'): Bu satır, Ballerina sunucumuzun yayın yaptığı SSE akışına bir bağlantı kurar. URL'nin doğru olduğundan emin olun.
• eventSource.onopen: Bağlantı başarıyla kurulduğunda tetiklenir. Burada bağlantı durumunu güncelleyebiliriz.
• eventSource.onmessage: Sunucudan yeni bir 'message' olayı geldiğinde tetiklenir. event.data özelliği, sunucudan gönderilen veriyi içerir. Bizim örneğimizde JSON formatında bir string gönderdiğimiz için JSON.parse() kullanarak veriyi ayrıştırıyoruz. event.lastEventId ise, sunucudan gelen son olayın kimliğini içerir; bu, yeniden bağlanma senaryolarında kayıp olayları talep etmek için kullanılabilir.
• eventSource.onerror: Bağlantı hatası oluştuğunda tetiklenir. EventSource otomatik olarak yeniden bağlanmaya çalıştığı için, bu olay genellikle bilgi amaçlıdır ve kullanıcının durumdan haberdar olmasını sağlar. Sunucu tarafında retry: alanını ayarlayarak istemcinin yeniden bağlanma aralığını belirleyebilirsiniz.
• eventSource.addEventListener('customEvent', ...): Eğer sunucunuz varsayılan 'message' eventi dışında özel event tipleri (event: customEvent\n gibi) gönderiyorsa, bunları addEventListener ile dinleyebilirsiniz.

Bu istemci, Ballerina sunucunuzla sorunsuz bir şekilde entegre olur ve gerçek zamanlı veri akışınızı web tarayıcınızda görüntülemenizi sağlar. CSS kodlarındaki medya sorguları, istemci uygulamasının farklı ekran boyutlarına uyum sağlayarak mobil cihazlarda da kullanılabilir olmasını sağlar. Bu sayede, hem masaüstü hem de mobil kullanıcılar için tutarlı bir deneyim sunulabilir. Bu, geliştirme sürecini basitleştirirken, aynı zamanda kullanıcı deneyimini de önemli ölçüde iyileştirir.

Gelişmiş SSE Kullanımı ve En İyi Uygulamalar: Performans ve Güvenlik

Server-Sent Events (SSE) temellerini anladıktan sonra, daha sağlam, performanslı ve güvenli uygulamalar geliştirmek için bazı ileri düzey konulara ve en iyi uygulamalara değinmek önemlidir. Bu bölümde, Ballerina ile SSE kullanırken dikkat etmeniz gereken bazı kritik noktaları ele alacağız: bağlantı yönetimi, yeniden bağlanma stratejileri, olay kimliklerinin (ID) kullanımı, güvenlik hususları ve hata yönetimi.

Bağlantı Yönetimi ve Yeniden Bağlanma

SSE'nin otomatik yeniden bağlanma özelliği büyük bir avantajdır, ancak sunucu tarafında bu bağlantıları yönetmek de önemlidir. Ballerina tarafında, her bir SSE bağlantısı bir HTTP akışı olarak ele alınır ve http:Caller objesi üzerinden yönetilir. Sunucunuzda, bağlı istemcileri izlemek ve gerektiğinde bağlantıları kapatmak için bir mekanizma oluşturmanız gerekebilir. Örneğin, bir kullanıcının oturumu sona erdiğinde veya belirli bir olaya artık abone olmak istemediğinde, sunucu bu bağlantıyı kapatabilmelidir. İstemci tarafında, EventSource API'si, sunucudan gelen retry: alanı ile otomatik yeniden bağlanma aralığını yapılandırmanıza olanak tanır. Sunucu olarak bu değeri mantıklı bir şekilde ayarlamak, ağ kesintilerinde istemcinin çok sık veya çok seyrek yeniden bağlanmaya çalışmasını önler.

// Ballerina sunucusunda aktif SSE bağlantılarını tutan bir Map veya Queue düşünebiliriz.
// Örnek: map activeSseConnections = {};
// Bir istemci bağlandığında activeSseConnections[clientId] = caller; olarak ekleyebiliriz.
// İstemci ayrıldığında veya bir hata oluştuğunda map'ten kaldırabiliriz.
// Bu sayede belirli bir istemciye özel mesaj gönderme veya tüm bağlantıları yönetme esnekliği sağlanır.
  

Olay Kimliklerinin (ID) ve Kayıp Olayların Telafisi

SSE protokolü, her olaya bir id: alanı eklemenize olanak tanır. Bu kimlikler, istemcinin bir bağlantı kesintisi sonrası hangi olaydan kaldığını bilmesini sağlar. Yeniden bağlandığında, EventSource nesnesi son alınan olayın ID'sini HTTP isteğinin Last-Event-ID başlığında sunucuya gönderir. Ballerina sunucunuz, bu başlığı kontrol ederek ve buna göre uygun olayları (yani, istemcinin kaçırdığı olayları) göndererek kayıp olayları telafi edebilir. Bu, veri bütünlüğünü sağlamak ve kullanıcının hiçbir önemli güncellemeyi kaçırmamasını sağlamak için kritik bir özelliktir. Bu özellik, özellikle finansal uygulamalar veya kritik bildirim sistemleri gibi verinin anlık ve eksiksiz olmasının zorunlu olduğu senaryolarda hayat kurtarıcıdır.

// Ballerina resource fonksiyonunda 'Last-Event-ID' başlığını kontrol etme örneği
resource function get stream(http:Caller caller, http:Request request) returns error? {
    // ... diğer başlık ayarları ...

    string? lastEventId = request.getHeader("Last-Event-ID");
    int startId = 0;
    if lastEventId is string {
        // Son olay ID'sini bir int'e dönüştür ve ondan sonraki olayları göndermeye başla.
        // Hata durumunda (geçersiz ID) 0'dan başla.
        startId = lastEventId.toInt().orElse(0) + 1; 
        io:println("İstemci Last-Event-ID: " + lastEventId + ", " + startId + " id'den devam edecek.");
    }

    // ... akış döngüsünde 'eventId' yerine 'startId'den başla ...
    int currentEventId = startId;
    while (true) {
        // ... olayları currentEventId ile oluştur ve gönder ...
        currentEventId += 1;
        // ...
    }
}
  

Güvenlik: Kimlik Doğrulama ve Yetkilendirme

SSE akışları da diğer HTTP kaynakları gibi güvenlik altına alınmalıdır. Public olmayan veriler için, istemcinin SSE akışına abone olmadan önce kimlik doğrulamadan geçmesi ve yetkilendirilmesi gerekir. Bu, genellikle ilk HTTP isteği sırasında bir oturum çerezi (session cookie) veya JWT (JSON Web Token) tabanlı bir Authorization başlığı kullanılarak yapılır. Ballerina, HTTP servisleri için yerleşik kimlik doğrulama ve yetkilendirme mekanizmaları sunar. Kaynak fonksiyonunuzun başına bir kimlik doğrulama veya yetkilendirme interceptor ekleyerek, sadece yetkili kullanıcıların akışa erişmesini sağlayabilirsiniz.

Hata Yönetimi ve Loglama

Sunucu tarafında, SSE akışlarını yönetirken oluşabilecek hataları (örneğin, ağ hataları, kaynak verisi hataları) doğru bir şekilde loglamak ve ele almak çok önemlidir. Ballerina'nın hata yakalama mekanizmaları (try-catch-finally veya check anahtar kelimesi) bu süreçte size yardımcı olacaktır. İstemciye de hata durumlarını bildiren özel olaylar (event: error\n data: ...\n) göndermek, istemcinin kullanıcıya anlamlı geri bildirimler sunmasını sağlayabilir.

Bu en iyi uygulamaları Ballerina SSE uygulamalarınıza dahil ederek, sadece işlevsel değil, aynı zamanda güvenilir, ölçeklenebilir ve güvenli gerçek zamanlı çözümler oluşturabilirsiniz. Ballerina'nın sağlam altyapısı ve dil özellikleri, bu ileri düzey konuların çoğunu kolayca ele almanızı sağlar.

Vaka Analizi: Canlı Bir Dashboard Uygulaması - Ballerina ile Monitörizasyon

Gerçek zamanlı veri akışının en pratik kullanım alanlarından biri, canlı bir dashboard veya gösterge panosu oluşturmaktır. Bu tür bir dashboard, sunucu kaynaklarının durumunu, uygulama performans metriklerini, IoT cihazlarından gelen verileri veya finansal piyasa hareketlerini anlık olarak görselleştirebilir. Bu vaka analizinde, Ballerina ve Server-Sent Events (SSE) kullanarak basit bir sistem monitörizasyon dashboard'unun nasıl oluşturulabileceğini inceleyeceğiz.

Senaryo: Bir şirket, kritik sunucularının CPU ve bellek kullanımını anlık olarak izlemek istiyor. Bu verilerin bir web arayüzünde, saniyeler içinde güncellenen grafikler ve metinlerle gösterilmesi gerekiyor. Veri akışı, sunucudan tarayıcıya tek yönlü olmalı ve istemcinin sunucuya veri göndermesi gereksiz. Bu senaryo, SSE için biçilmiş kaftan. Ballerina sunucumuz, düzenli aralıklarla sahte sistem metrikleri (CPU kullanımı %0-100 arası, bellek kullanımı %0-100 arası) üretecek ve bunları bağlı tüm istemcilere SSE akışı olarak gönderecektir. İstemci tarafındaki bir web uygulaması (HTML/JavaScript), bu verileri alacak ve basit grafikler veya metinlerle görüntüleyecektir.

Ballerina Sunucu Tarafı Uygulaması

Ballerina sunucusu, her saniye yeni metrikler üretir ve bunları JSON formatında bir SSE olayı olarak yayınlar. Her olayın, metrik türünü belirten bir event: alanı ve gerçek veri olarak CPU ve bellek kullanımını içeren bir data: alanı olacaktır. Bu sayede istemci, gelen verinin ne tür bir metrik olduğunu kolayca anlayabilir.

import ballerina/http;
import ballerina/io;
import ballerina/time;
import ballerina/random;
import ballerina/json;

// HTTP servisimizi tanımlıyoruz.
service /dashboard on new http:Listener(9090) {

    // '/metrics' yoluna gelen GET isteklerini karşılayan kaynak fonksiyonu.
    resource function get metrics(http:Caller caller) returns error? {
        check caller->addHeader("Content-Type", "text/event-stream");
        check caller->addHeader("Cache-Control", "no-cache");
        check caller->addHeader("Connection", "keep-alive");

        io:println("Dashboard metrik akışına yeni bir istemci bağlandı.");

        int eventId = 0;
        while (true) {
            // Rastgele CPU ve bellek kullanım verileri oluştur.
            float cpuUsage = random:createRandom().nextFloat() * 100.0;
            float memoryUsage = random:createRandom().nextFloat() * 100.0;

            // JSON formatında veri objesi oluştur.
            json payload = {
                "cpu": cpuUsage.round(), // Ondalık kısmı kaldır
                "memory": memoryUsage.round(),
                "timestamp": time:utcNow().toString()
            };

            // SSE olay formatını oluştur.
            string data = string data: ${payload.toJsonString()}\n;
            string eventType = event: systemMetrics\n; // Özel bir event tipi kullanıyoruz
            string id = id: ${eventId}\n;
            string retry = retry: 3000\n; // İstemci 3 saniyede bir yeniden denesin

            error? result = caller->writeStream({
                content: eventType + id + retry + data + "\n"
            });

            if (result is error) {
                io:println("Dashboard istemci bağlantısı kesildi: " + result.message());
                break;
            }

            eventId += 1;
            time:sleep(1); // Her saniye yeni metrik gönder.
        }
        io:println("Dashboard metrik akışı sona erdi.");
        return;
    }
}
  

İstemci Tarafı Uygulaması (HTML/JavaScript)

İstemci tarafı, EventSource kullanarak Ballerina sunucusundan gelen systemMetrics olaylarını dinleyecektir. Gelen CPU ve bellek verileri, basit bir HTML sayfasında metin olarak veya daha gelişmiş bir senaryoda grafik kütüphaneleri (örneğin Chart.js) ile görselleştirilebilir. Bu örnekte, verileri bir liste olarak göstereceğiz ve bir mobil cihazda da düzgün görünmesi için temel CSS media query'leri kullanacağız.

    
    
    
    


    

        
Ballerina Canlı Sistem Metrikleri
        
Bağlantı Durumu: Kesik

        

            
CPU Kullanımı
            
%0
        

        

            
Bellek Kullanımı
            
%0
        

        

            
Son Güncelleme Zamanı
            
Bekleniyor...
        
    

    


  

Bu vaka analizi, Ballerina ve SSE'nin gerçek zamanlı bir dashboard uygulamasını nasıl basit ve etkili bir şekilde güçlendirebileceğini göstermektedir. Ballerina'nın kolay öğrenilebilir sözdizimi ve yerleşik ağ özellikleri sayesinde, sunucu tarafında veri üretimi ve akışı oldukça basittir. İstemci tarafında ise EventSource API'si, gelen verileri sorunsuz bir şekilde tüketmenizi sağlar. Mobil uyumlu CSS media query'leri, bu dashboard'un tabletler ve akıllı telefonlar dahil olmak üzere çeşitli cihazlarda iyi bir kullanıcı deneyimi sunmasını garanti eder. Bu yaklaşım, sadece sistem monitörizasyonu için değil, aynı zamanda finansal uygulamalar, IoT veri görselleştirmeleri ve sosyal medya akışları gibi birçok gerçek zamanlı senaryo için de uygulanabilir.

Sonuç: Gerçek Zamanlı Geleceğe Adım Atın

Gerçek zamanlı veri akışı, modern web uygulamalarının vazgeçilmez bir parçası haline gelmiştir ve Server-Sent Events (SSE), bu ihtiyacı karşılamak için oldukça güçlü ve basit bir çözüm sunar. Bu makale boyunca, SSE'nin temel prensiplerini, WebSockets ve geleneksel polling gibi alternatiflerle karşılaştırmasını ve Ballerina'nın bu teknolojiyi uygulamak için neden ideal bir platform olduğunu detaylıca inceledik. Ballerina'nın ağ odaklı yapısı, eşzamanlılık desteği ve temiz sözdizimi sayesinde, karmaşık gerçek zamanlı senaryoları bile şaşırtıcı derecede az kodla ve yüksek performansla hayata geçirebileceğimizi gördük. İlk SSE sunucusundan, bir istemcinin nasıl oluşturulacağına ve gelişmiş kullanım tekniklerine kadar adım adım rehberlik ettik.

Gelişmiş bağlantı yönetimi, olay kimliklerinin kullanımıyla kayıp olayların telafisi, güçlü kimlik doğrulama ve yetkilendirme mekanizmaları ile güvenlik ve kapsamlı hata yönetimi stratejileri, Ballerina ile oluşturulan SSE uygulamalarının sadece işlevsel değil, aynı zamanda sağlam ve güvenilir olmasını sağlar. Canlı bir dashboard uygulaması örneğiyle, Ballerina ve SSE'nin birleşimiyle gerçek dünya problemlerine nasıl etkili çözümler üretilebileceğini uygulamalı olarak gösterdik. Bu vaka analizi, SSE'nin sadece teorik bir kavram olmadığını, aynı zamanda pratik ve ölçeklenebilir uygulamalar için güçlü bir araç olduğunu kanıtladı. Ballerina'nın SSE desteği, geliştiricilere, kullanıcılarına anlık, dinamik ve etkileşimli deneyimler sunan uygulamalar yaratma konusunda eşsiz bir kolaylık ve güç sağlamaktadır. Günümüzde veri odaklı uygulamaların önemini düşündüğümüzde, Ballerina ile Server-Sent Events kullanmak, gerçek zamanlı veri akışının getirdiği tüm avantajlardan faydalanarak geleceğin web uygulamalarını inşa etmek için atılacak en doğru adımlardan biridir.

Sıkça Sorulan Sorular

SSE ve WebSockets arasındaki temel fark nedir?

SSE (Server-Sent Events) tek yönlü bir iletişim kanalıdır; sunucudan istemciye veri akışı sağlar. WebSockets ise çift yönlü, tam dubleks bir iletişim kanalı kurarak hem sunucunun hem de istemcinin birbirine istediği zaman veri göndermesine olanak tanır. SSE, istemcinin sunucuya veri göndermesine gerek duymadığı senaryolar (örn. haber akışları) için daha basit ve hafif bir çözümdür, WebSockets ise sohbet uygulamaları gibi iki yönlü iletişimin kritik olduğu yerlerde tercih edilir.

Ballerina'da SSE akışlarını nasıl güvenli hale getirebilirim?

Ballerina'da SSE akışlarını güvenli hale getirmek için HTTP servislerine özgü kimlik doğrulama (Authentication) ve yetkilendirme (Authorization) mekanizmalarını kullanabilirsiniz. Bu, genellikle ilk SSE bağlantısı isteği sırasında bir JWT (JSON Web Token) veya oturum çerezi (session cookie) kullanarak yapılır. Ballerina'nın yerleşik HTTP güvenlik özellikleri, kaynak fonksiyonunuza bir yetkilendirme katmanı eklemenizi veya interceptor'lar kullanmanızı sağlar.

SSE, tüm tarayıcılar tarafından destekleniyor mu?

Evet, EventSource API'si modern tarayıcıların çoğu tarafından geniş çapta desteklenmektedir (Chrome, Firefox, Safari, Edge vb.). Ancak, Internet Explorer gibi eski tarayıcılarda doğrudan destek bulunmayabilir, bu durumda bir polyfill kullanmak gerekebilir.

Bir SSE bağlantısı kesildiğinde ne olur? Otomatik olarak yeniden bağlanır mı?

Evet, Server-Sent Events'in en büyük avantajlarından biri otomatik yeniden bağlanma özelliğidir. İstemci tarafındaki EventSource API'si, ağ kesintileri veya sunucu hataları durumunda bağlantıyı belirli bir gecikmeyle otomatik olarak yeniden kurmaya çalışır. Sunucu tarafında retry: alanı gönderilerek bu yeniden bağlanma aralığı ayarlanabilir.

Ballerina ile birden fazla istemciye aynı anda SSE akışı sağlamak mümkün müdür?

Kesinlikle evet. Ballerina'nın dilin içine yerleşik eşzamanlılık (concurrency) ve ağ soyutlamaları sayesinde, aynı anda binlerce istemciye Server-Sent Events akışı sağlamak mümkündür. Ballerina, her istemci bağlantısını etkin bir şekilde yönetmek için hafif iş parçacıkları (strand'lar) kullanır, bu da yüksek ölçeklenebilirlik sağlar ve sunucu kaynaklarını verimli bir şekilde kullanır.