<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ömür Uçum on Medium]]></title>
        <description><![CDATA[Stories by Ömür Uçum on Medium]]></description>
        <link>https://medium.com/@omurucum?source=rss-83aaab9dbc9c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*SXfirJIswLqRCMSK.</url>
            <title>Stories by Ömür Uçum on Medium</title>
            <link>https://medium.com/@omurucum?source=rss-83aaab9dbc9c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 12:55:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@omurucum/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[C# 15 Native Union — API Sözleşmelerini Daha Açık Tanımlamak]]></title>
            <link>https://medium.com/@omurucum/c-15-native-union-api-s%C3%B6zle%C5%9Fmelerini-daha-a%C3%A7%C4%B1k-tan%C4%B1mlamak-19f68c619047?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/19f68c619047</guid>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[aspnetcore]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Fri, 11 Sep 2026 13:15:29 GMT</pubDate>
            <atom:updated>2026-09-12T00:16:08.217Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Hiç bir zafere çiçekli yollardan gidilmez. Cennet bile ölüm ister!</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XiH3SsnSNml9p2UDIbakog.png" /></figure><p>Bir API’nin aynı alan için birden fazla veri tipi döndürmesi gerektiğinde C# tarafında genellikle <strong>object </strong>özel bir wrapper ya da harici bir union kütüphanesi kullanıyoruz. Mesela K8s’teki <strong>maxUnavailable</strong> benzeri bir değer hem sayı hem de yüzde olarak ifade edilebilir.</p><pre>2 veya &quot;25%&quot;</pre><p>C# 15 öncesinde bunun en kısa karşılığı <strong>object</strong> kullanmak olabilir.</p><pre>app.MapGet(&quot;/max-unavailable&quot;, () =&gt; (object)&quot;25%&quot;);</pre><p>Bu çözüm çalışıyor fakat contract gereğinden fazla açık kalıyor. Endpoint’in <strong>int </strong>veya <strong>string </strong>döndürmesini beklerken yanlışlıkla <strong>bool</strong>, <strong>DateTime</strong> ya da başka bir nesne dönmesini type sistem engellemiyor. Daha güvenli bir yol aradığımız zaman da basit bir contract için ek kod maliyeti ortaya çıkıyor. C# 15 ile gelen <strong>native union </strong>desteği bu modeli doğrudan dil seviyesinde tanımlamamıza imkan veriyor:</p><pre>public union IntOrString(int, string)</pre><p>Bu tanım sayesinde endpoint’in dönüş tipi de artık açıkça ifade edilebiliyor.</p><pre>app.MapGet(<br>    &quot;/max-unavailable/{asPercentage:bool}&quot;,<br>    IntOrString (bool asPercentage) =&gt;<br>    {<br>        if (asPercentage)<br>            return &quot;25%&quot;;<br><br>        return 2;<br>    });</pre><p>Bu tanım sayesinde <strong>int</strong> ve <strong>string</strong> dışında farklı bir tip döndürmeye çalıştığımız da hata daha uygulama çalışmadan ortaya çıkıyor. Native union’ın bence asıl önemli tarafı yalnızca daha az kod yazılması değil. Sözleşme sınırlarının type system içinde tanımlanmış olmasıdır. Bu durum <strong>switch </strong>kullanımında da kendisini gösteriyor.</p><pre>static string Describe(IntOrString value) =&gt; value switch<br>{<br>    int count =&gt; $&quot;{count} instance&quot;,<br>    string percentage =&gt; percentage<br>};</pre><p>Union’a yeni bir case eklendiğinde ve mevcut kod bu ihtimali ele almadığında compiler eksik case için uyarı verebiliyor. Böylece sözleşme değişikliğinin etkisi yalnızca runtime’da değil, kod derlenirken de görülebiliyor. JSON tarafında union için ilave bir wrapper veya discriminator üretilmiyor. Aktif case hangi tipteyse doğrudan o değer yazılıyor:</p><pre>2 veya &quot;25%&quot;</pre><p>Bu sadelik yazma tarafında geçerli. Okuma tarafında ise durum değişiyor. Aynı <strong>IntOrString</strong> union’ını bir request body olarak kullandığımızda ASP.NET Core’un web JSON ayarları sayıların string’den de okunmasına izin veriyor. Bu durumda <strong>“2”</strong> değeri hem <strong>int</strong> hem de <strong>string</strong> case’ine eşleşebiliyor ve deserialization için custom bir <strong>JsonTypeClassifier</strong> yazmak gerekiyor. Yani <strong>int</strong> <strong>| string</strong> sözleşmesi dönüş tipi olarak ek kod istemezken, giriş tipi olarak kullanıldığında bu kadar zahmetsiz değil. OpenAPI tarafında ise bu sözleşme <strong>anyOf</strong> olarak ifade ediliyor:</p><pre>anyOf:<br>  - type: integer<br>    format: int32<br>  - type: string</pre><p>Burada union ile closed hierarchy arasındaki ayrımı da doğru yapmak gerekiyor. Birbiriyle ilişkili olmayan tipleri veya değiştiremeyeceğimiz discriminator’sız bir JSON sözleşmesini modellemek istiyorsak union daha doğal bir seçenek. Mesela;</p><pre>int | string</pre><p>Ancak kendi kontrolümüzde olan ve ortak bir anlam taşıyan modeller için closed hierarchy daha doğru olabilir:</p><pre>PaymentInitiated<br>PaymentAuthorized<br>PaymentFailed</pre><p>Bu modeller aynı domain kavramına (Payment) farklı durumlarını temsil ettiği için ortak bir base type ve discriminator kullanmak sözleşmeyi daha anlaşılır hale getirebilir. Native union her senaryo için kullanılacak yeni bir varsayılan değil. Resmi dokümandan anladığım bazı sınırları var. Bunlar:</p><ul><li>Query string, route, header ve fırm binding için desteklenmiyor</li><li>Birden fazla case JSON object tipindeyse deserialization sırasında classifier gerekiyor. Yapıları farklıysa built-in <strong>JsonUnionTypeStructuralClassifier </strong>property adlarına bakarak ayırt edilebiliyor. Yapıları ayırt edilemiyorsa custom classifier yazamak gerekiyor.</li><li>Verdiğin <strong>int | string </strong>örneğinde olduğu gibi primitive case’ler bile request body tarafında belirsizliğe düşebiliyor.</li><li>Union’a yeni bir case eklemek contract değişikliği oluşturacağından api’yi tüketenlerinde değişiklik yapmasını gerektirebilir.</li><li>SignalR desteği <strong>System.Text.Json</strong> protokolüyle sınırlı</li><li>C# 15 ve .NET 11 dönemine ait olduğu için production ortamda kullanılan bir yapıdan ziyade değerlendirme aşamasında ki bir feature olarak düşünmek gerek.</li></ul><p>Yine de önemli bir kazanım sağlıyor. Bir API’nin kabul ettiği veya döndürdüğü alternatifleri yorumlarla, runtime kontrolleriyle ya da gereğinden fazla kodla değil bunun yerine doğrudan tip sistemiyle ifade ediyor.</p><p>Peki siz bu tür sözleşmeleri bugün nasıl modelliyorsunuz?</p><p>Buraya kadar okuyup zaman ayırdığınız için teşekkür ederim. Geri dönüşleriniz benim için değerlidir.</p><p><strong>Kaynak:</strong></p><ol><li><a href="https://devblogs.microsoft.com/dotnet/unions-and-closed-hierarchies-in-aspnetcore/">https://devblogs.microsoft.com/dotnet/unions-and-closed-hierarchies-in-aspnetcore/</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19f68c619047" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[API Governance’ı Dokümandan Yürürlüğe Taşımak]]></title>
            <link>https://medium.com/@omurucum/api-governance%C4%B1-dok%C3%BCmandan-y%C3%BCr%C3%BCrl%C3%BC%C4%9Fe-ta%C5%9F%C4%B1mak-2b159a5b5077?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b159a5b5077</guid>
            <category><![CDATA[policy-as-code]]></category>
            <category><![CDATA[togaf]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[api-governance]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 01:05:12 GMT</pubDate>
            <atom:updated>2026-08-31T01:05:12.752Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Kuralların olmadığı yerde özgürlük değil, güçlü olanın kaosu vardır; gerçek düzen, herkesin sınırlarını bilerek güvenle üretebildiği bir adalet zeminidir.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dB6INeUcxaHEsgkcOlsJcg.png" /><figcaption>Mimari standart, ancak otomatik olarak doğrulanabildiği, uygulanabildiği ve ölçülebildiği kadar vardır</figcaption></figure><h4>Mimari Standart Nerede Yaşıyor?</h4><p>Standartlar yazıldı, dokümante edildi ve büyük bir gururla duyurusu yapıldı. Artık herkes bu standartlara uyacak sanıldı. Ama üç sprint sonra kimse dokümanın yüzüne bile bakmadı.</p><p>Bu, kurumsal mimarinin en tanıdık hikayesidir. Enterprise Architecture ekibi bir API standartı hazırlar. Kimlik doğrulama zorunlulukları, isimlendirme kuralları versiyonlama politikası, trafik profilleri her şey didik didik edilir ve günlerce emek verilik dokümante edilir. Architecture Review Board’da onayıda aldıktan sonra ekiplere duyurusu yapılır. Buraya kadar her şey doğru yapılmıştır.</p><p>Sonra zamanla doküman ile production arasında açılan bir mesafe oluşur. Bu mesafe de nelerin olduğunu biliyorsunuz aslında. Standartlar okunmaz, okunsa bile farklı yorumlanır. Biri external derken internete açık olanı kastetmiştir ama farklı biri kurum dışı herhangi bir tüketiciyi kasteder. Bazen biri çıkar ve ölüm kalım! meselesi yaptığı bir işi hiçbir kurala uymadığı halde prod ortama taşır ve sonra hallederiz der. Ama asla halledilmez. Test ortamında yapılmış olan bir profil tanımı prod ortama taşınmıştır ama bunu da kimse fark etmez. Zaten istesede fark edemez. Çünkü fark edilecek bir mekanizma yoktur. Belirli bir zaman sonra şu dedikoduları duyarız;</p><ul><li>O doküman güncel değil, sen bir mimariye sor.</li><li>Test’te çalışıyordu prod ortamda profil adı farklıymış.</li><li>Gateway’de elle açmıştık sonra kapatmayı unuttuk.</li><li>Bu API dışarı açık mı? Valla bilmiyorum emin değilim.</li></ul><p>Bu cümlelerin ortak özelliği ise ihmal itirafı olmamasıdır. Hepsi kuralın yaşadığı yer ile kuralın uygulandığı yer arasındaki boşluğu temsil ediyor. İşte bu boşluk kurumların kendileri hakkında yanlış bir şey bilmesine yol açar. Halbuki standart yayınlanmıştır, onaylanmıştır ve imzalanmıştır. Dolayısıyla kurum kendisini uyumlu sanmakta haklıdır. Ama bu uyumun ölçülüp değerlendirildiği hiç olmamıştır. Bunun adı <strong>Beyan Uyumudur. </strong>Daha havalı bir deyimle <strong>Declared Compliance. </strong>Beyan uyumu açık uyumsuzluktan daha risklidir. Çünkü uyumsuzluk bir gün patlar ve görünür. Beyan uyumu ise sorunun görülmesini geciktirir. Şimdi bahsettiğim bu boşluğu Kurumsal Mimarinin cevaplaması gereken tek bir soru üzerinden irdeleyelim. Sorumuz:</p><blockquote><strong>Production’da ki 500 API’nin gerçekten bu standarda uyduğunu nasıl ispatlarız?</strong></blockquote><p>Bu soruya yazı boyunca cevap arayacağız ve sürekli bu soruya döneceğiz.</p><h4>Aynı kelimeyi farklı şeyler için kullanıyoruz</h4><p>Mimari yönetişim tartışmaları çoğu zaman terim karmaşasında boğulur. İlke mi konuşuyoruz standart mı? Kural mı kontrol mü? Bu ayrımlar akademik görünür ama değildir; çünkü her birinin yaşadığı yer ve uygulanma biçimi farklıdır.</p><p>Tek bir örnek üzerinden gidelim.</p><p>Bir kurumun mimari ilkesi şudur: <strong>Secure by Default. </strong>Aslında ilke dediğimiz kavram bir <strong>yön beyanıdır</strong>. Ölçülemez, doğrulanamaz ve doğrudan uygulanamaz. Sadece tartışmayı yönlendirir karar vermez. Mimari standartlar belirlenen bu ilkeden türer.</p><blockquote>Kurum dışına açılan hiçbir API kimlik doğrulama olmadan yayınlanamaz. Standart artık bir yön değil, bir hükümdür. Ama hala insan diliyle yazılmıştır ve yorum gerektirir.</blockquote><p>Standarttan bir yönetişim kuralı (governance rule) türer. Yani aslında belirtmek istediği şey tam olarak şudur:</p><pre>Exposure = External =&gt; SecurityProfile = EXTERNAL_STRICT</pre><p>Kural artık koşul ve sonuç içerir. Belirsizlik büyük ölçüde giderilmiştir. Yukarıda belirttiğim ifadenin neyi anlatmak istediğini birazdan açıklayacağım.</p><p>Kurallardan ise bir teknik kontrol türer artık. CI/CD aşamasında çalışan bir doğrulama adımı ve gateway üzerinde çalışan bir runtime politikası.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IqJxl4pxbE9CZTHSSvA_mA.png" /><figcaption>Yönetişim Süreci</figcaption></figure><p>Daha önce belirttiğim governance rule kısmını detaylandıralım.</p><p>Exposure = External =&gt; SecurityProfile = EXTERNAL_STRICT</p><p>Burada ki (=&gt;) sembolü aslında <strong>if..else..then</strong> kalıbında ki <strong>then’i </strong>temsil etmektedir.</p><p><strong>Exposure</strong> ise bir API’yi kimin çağırabildiğini söyleyen sınıflandırmadır. Teknik bir ayar değildir. Internal, Partner ve External genelde verilen değerlerdir. Bu değerlerin ne anlama geldiğini ise kurum tanımlar ve tanımın netliği kendi başına bir yönetişim işidir. Bir ekip “external” derken internete açık olanı, bir diğeri kurum dışı herhangi bir tüketiciyi kastediyorsa kural doğru çalışsa bile yanlış sonuç üretir.</p><p><strong>SecurityProfile </strong>ise tek bir ayar değildir. Kurumun önceden tanımlayıp adlandırdığı bir ayar grubudur. Aslında yukarıda belirtilen <strong>EXTERNAL_STRICT</strong> içeriği şu şekildedir:</p><pre>EXTERNAL_STRICT<br>  Kimlik doğrulama   : zorunlu<br>  Anonim erişim      : kapalı<br>  TLS                : zorunlu, minimum sürüm sabit<br>  Payload sınırı     : sıkı<br>  CORS               : yalnızca izinli origin listesi<br>  Hata gövdesi       : detay dışarı sızmaz</pre><p>Yapılmış olan bu gruplama aslında bir kolaylık olarak görülmemelidir. Bu bir zorunluluk olmalıdır. Bu altı ayarı her API için tek tek tanımlarsanız 500 API’lik bir portföyde 500 farklı kombinasyon oluşur. Ama bu şekilde bir gruplama yapıldığında bu profili kullanan tüm api’lerin güncellenmesi (SecurityProfile güncellenmesi) çok daha kolay ve güvenli olacaktır.</p><blockquote>Not: Burada belirtilen <strong>EXTERNAL_STRICT </strong>ifadesi zorunlu bir isimlendirme ya da bir dokümanda yazıldığı için verilmemiştir. Her kurum kendi bünyesinde farklı isimlendirme yapabilir.</blockquote><p>Burada anlamamız gereken asıl önemli nokta şudur. Sol tarafı geliştirici belirtir. Sağ tarafı ise platform belirler. Bu ayrımın neden bu kadar önemli olduğuna ise daha sonra geleceğim.</p><p>Çoğu kurumda Yönetişim Süreci görselinde belirttiğim adımların ilk ikisi varken son ikisi yoktur. İlke ve standart yazılıdır ama kural ve kontrol insana ve gözden geçirme toplantılarına havale edilmiştir. Mimari yönetişim dediğimiz şey bu sürecin bütününü yönetme disiplinidir. Mimari uyum ise sürecin sonunda ölçülen şeydir.</p><p>Uyum için vardır ya da yoktur demek bir Kurumsal Mimar için yeterli değildir. O yüzden Mimari Uyum derken tam olarak neyi kastettiğime de kısaca değinmem gerekiyor.</p><p>Uyum ikili bir kavram değildir. TOGAF uyum düzeylerini toplam altı kademede tanımlar. Bunlar; <strong>irrelevant</strong> (ilgisiz), <strong>consisten</strong> (tutarlı), <strong>compliant</strong> (uyumlu), <strong>conformant</strong> (uygun), <strong>fully conformant</strong> (tam uygun) ve <strong>non-conformant </strong>(uygunsuz). Bu kademeler arasındaki fark bir sistemin standardın bazı özelliklerini karşılayıp diğerlerini karşılamaması ya da standardın ötesine geçmesi gibi durumları ayırt etmek içindir. TOGAF’ın kendisi de bu terminolojinin kurumdan kuruma değişebileceğini ancak bir uyum stratejisi kurarken bu ayrımların yararlı olduğunu belirtir.</p><p>Otomasyon ise doğası gereği ikili çalışır: geçti veya geçmedi. Bir kuralı otomatize ettiğimizde o kuralın gri bölgesinden de feragatlık etmiş oluruz. Yani:</p><p>“external API’de kimlik doğrulama var mı?” sorusunun gri alanı yoktur. Ama “bu servisin sınırı doğru çizilmiş mi?” sorusunun cevabı evet/hayır ile sınırlanmayabilir.</p><p>Dolayısıyla mesela “her şeyi otomatikleştirmek” değildir. Burada asıl mesele hangi kuralın hangi kademede olduğunu bilmek ve ikili cevabı olanları insan gündeminden çıkarmaktır.</p><h4>Kural Nerede Yaşıyor?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z6zFv69GnV9gNdocI3iqXA.png" /><figcaption>Doküman olarak yönetişim</figcaption></figure><p>Geleneksel yönetişim süreci görselin solundaki gibidir. Süreç sol tarafta ki gibi olduğunda her katmanda bilgi kaybı oluşur. Doküman kararın gerekçesini değil sonucunu içerir. İnsan yorumu ise bağlama göre değişir.</p><p>Önerilen süreç ise görselin sağındaki gibidir. Bu yaklaşımın sektördeki adı <strong>Governance-as-Code. </strong>Altyapının kod olarak tanımlanması (infrastructure-as-code) ve politikaların kod olarak tanımlanması (policy-as-code) kalıplarının devamıdır. Yönetişim kuralları da versiyonlanabilir, gözden geçirilebilir, test edilebilir ve otomatik uygulanabilir birer artefakt haline gelir. Şunu söylemekte bir sakınca görmüyorum;</p><blockquote>Bir mimari standart, ancak otomatik olarak doğrulanabildiği, uygulanabildiği ve ölçülebildiği kadar vardır. Geri kalanı iyi niyettir ve iyi niyet denetlenemez.</blockquote><p>Buradan şu sonuca varmamak gerekiyor; bütün mimari kararlar otomatikleştirilmelidir. Bizim sorguladığımız otomatikleştirilmesi mümkün olanlar neden hala manuel yapılıyor.</p><h4>Her standardın uygulama noktası aynı değildir</h4><p>Bir API’nin üzerinde konuşulacak onlarca kural vardır. Bunları sınıflandırmadan konuşmak hepsini aynı mekanizmaya sıkıştırma hatasına yol açar. Aşağıdaki tabloda bir API’nin yönetişim yüzeyini ayrıştırmak için basit bir örnektir</p><pre>| Katman             | Standart örneği               | Uygulama noktası     |<br>|--------------------|-------------------------------|----------------------|<br>| Tanım              | Geçerli bir OpenAPI tanımı.   | CI/CD                |<br>| İsimlendirme       | Adlandırma kuralları          | CI/CD (linter)       |<br>| Güvenlik           | Kimlik doğrulama zorunluluğu  | CI/CD + Runtime      |<br>| Trafik             | Rate limit profili            | Runtime              |<br>| Yönlendirme        | Backend adresi değil, alias   | CI/CD + Runtime      |<br>| Gözlemlenebilirlik | Correlation ID zorunluluğu    | Runtime              |<br>| Dayanıklılık       | Timeout ve bulkhead değerleri | Runtime              |<br>| Yaşam döngüsü      | Versiyonlama ve deprecation   | CI/CD                |<br>| Sahiplik           | Owner ve criticality metadata | Metadata doğrulaması |</pre><p>Burada asıl dikkat edilmesi gereken şey tek bir kontrol noktası her şeyi çözmez. İsimlendirme kuralı CI/CD işidir. Tanım derlenmeden önce okunur. Kurala uymuyorsa PR geçmez. Runtime burada bir yorum yapmamalıdır.</p><p>Trafik profili ise direk runtime işidir. CI/CD tarafının tanımda “rate limit profili: HIGH” yazdığını doğrulayabilir ama bu profilin gerçekten uygunladığını ancak gateway bilir. Tanımın doğru olduğu uygulamanın doğru olduğu anlamına gelmez.</p><p>Güvenlik katmanı ise her iki uygulama noktasında da vardır. CI/CD tarafı bir güvenlik şeması tanımı olduğunu kontrol ederken runtime ise bu güvenlik şemasının gerçekten zorunlu kılındığını garanti eder.</p><h4>Aynı yüzeye bilgi açısından bakmak</h4><p>Yukarıda ki tablo teknik bir sınıflandırmadır. Aynı tabloya bir de bilginin nerede yaşadığı açısından bakmak tezimizin sınırını netleştirir. Önce ki yazılarımda bilginin kurumda nerede yaşadığını beş katmanda modellemiştir. Knowledge Ownership Model’de katmanlar şunlardı: mimari bilgi, entegrasyon bilgisi, operasyonel bilgi, konfigürasyon ve tuning, karar gerekçeleri. Modelin amacı, “bu sistemi biliyoruz” cümlesini parçalarına ayırmaktı; çünkü kurumlar genellikle bazı katmanlarda güçlü, bazılarında tamamen boştur.</p><p>API yönetişimini bu mercekten geçirdiğimizde ortaya şu çıkıyor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fcKbu8tmCyDFtjgzI6PFyA.png" /><figcaption>Knowledge Ownership Model’e göre API yönetişim katmanları</figcaption></figure><p>Ortada ki üç katman otomatize edilebilir. Mimari bilgi ve Karar gerekçeleri ise insanda kalır. Burada birde dördüncü katmana dikkat çekmek isterim. Çünkü bir çok kurumun kör noktası burasıdır. Acil gelen bir talep ile gateway üzeride yapılmış olan manuel bir işlem hiçbir dokümanda olmaz ve daha sonra otomasyona dahil edilmez ise zamanla süreç yine baltalanmış olur. Bu katmanı versiyon kontrolüne taşımak Governance-as-Code’un en az konuşulan ama en somut kazancıdır.</p><h4>Geliştirici neyi bilmelidir?</h4><p>Otomatikleştirmede yapılan en büyük hata karmaşıklığı developer tarafına devretmektir. Kurallar oluşturulur ve developerlardan platformun teknik detaylarını belirtmesi istenir. Bu sayede maneul gözden geçirme ortadan kalkmış olur yerine de daha kötü birşey gelmiş olur. Şöyle bir tanım okuduğunuzu düşünün;</p><pre>[ApiPolicy(<br>    RateLimit = 1000,<br>    RateLimitWindow = &quot;1m&quot;,<br>    PolicyTemplate = &quot;TrafficOptimization&quot;,<br>    TimeoutMs = 5000,<br>    AuthScheme = &quot;oauth2-introspection&quot;)]<br>public class PaymentTransferApi { }</pre><p>Burada geliştirme yapan kişinin platformun nasıl çalıştığını bilmesi beklenir. Rate limit değerinin ne olması gerektiğini, hangi politika şablonun uygun olduğunu, timeout’un kaç milisaniye olacağını geliştirici karara bağlıyor. Peki bu bilgileri nereden alacak? Ya dokümandan ya da yanında oturan arkadaşından öğrenecek. Arkadaşı ise ben böyle yaptım diyerek örneği gönderecek. Sonra umud edip sistemin stabil çalışması için dua edeceğiz. Peki aynı tanımın aşağıdaki gibi olduğunu varsayarsak nasıl olur;</p><pre>[ApiGovernance(<br>    Domain = &quot;payments&quot;,<br>    Exposure = Exposure.External,<br>    Criticality = Criticality.High)]<br>public class PaymentTransferApi { }</pre><p>Daha önce belirttiğim kuralın kod tarafında ki karşılığı budur. Geliştirici teknik bir karar vermiyor. Bir mimari niyet belirtiyor. Bu API ödemeler alanına ait, kurum dışına açık ve kritiklik seviyesi yüksek. Bu üç bilgi developer tarafından bilinebilir ve hatta doğru bileceği tek şeydir. Teknik kararı ise platform veriyor.</p><pre>Niyet<br>  Exposure    = External<br>  Criticality = High<br>        ↓<br>Mimari kurallar<br>        ↓<br>Güvenlik         = EXTERNAL_STRICT<br>Trafik profili   = CRITICAL<br>Gözlemlenebilirlik = STRICT</pre><p>Bu ayrım kritiktir. Çünkü niyet <strong>yavaş değişir implementasyon ise hızlı değişir</strong>. API’nin kritikliği yılda bir kez değişir. Rate limit değerleri, güvenlik şemaları ve gateway politikaları çok daha sık değişir. Niyeti kodda, implementasyonu platformda tutmak, ikisinin farklı hızlarda yaşamasına izin verir.</p><p>Sürecin her halaksında niyetin biraz aşındığı duruma <strong>Niyet Kaybı </strong>diyebilirim. kaybın pratik ölçüsü basittir. Geliştiricinin platform detayını ne kadar bilmek zorunda kaldığı. İlk verdiğim örnekte kayıp yüksektir çünkü geliştirici niyeti değil sonucu yazıyor ve bu bilgi kendisinde kalıyor. Burada niyet kaybını azaltmak için kuralları bir dosyada yazılı olarak tutmak güvenlidir.</p><h4>Kural bir dosyada olduğunda</h4><p>Mimari kurallar insan diliyle yazıldığı sürece yorumlanabilir. Otomatik doğrulama sayesinde ise değerlendirilir. Aradaki fark yönetişim bütün ağırlığını taşır. Basit bir kural seti şöyle görünebilir;</p><pre>rules:<br>  - when:<br>      exposure: internal<br>      criticality: high<br>    apply:<br>      security: INTERNAL_STRICT<br>      traffic: HIGH<br>      observability: STANDARD<br><br>  - when:<br>      exposure: external<br>      criticality: high<br>    apply:<br>      security: EXTERNAL_STRICT<br>      traffic: CRITICAL<br>      observability: STRICT</pre><p>Artık bir wiki dokümanı olmaktan çıkmış ve kaynak dosya olmuştur. Kural artık versiyonlanıyor. “Bu kural ne zaman değiştir” sorusunun cevabı atılmış bir committir. “Neden değişti” sorusunun cevabı ise PR açıklamasındadır. “Kim onayladı” sorusuna da review kısmına bakarak cevap verebiliyoruz. Mimari yönetişimin yıllardır toplantı tutanaklarında aradığı izlenebilirlik aslında versiyon kontrolünün bedavaya verdiği bir özelliktir.</p><p>Kural artık test edilebiliyor. Bir kural setine örnek girdiler verip beklenen çıktıyı doğrulayabilirsiniz. “Kritikliği yüksek, dışa açık bir API için hangi profil çıkar?” sorusu bir birim testi olur. Ve kural artık geri alınabiliyor. Yanlış bir yönetişim değişikliği bir sonraki deploy’a kadar beklemek zorunda değil. Elbette sadece bu yapının olması yeterli değildir. Bunun da kontrol edilmesi gerekmektedir. Genelde tavsiyem üç kontrol noktasının oluşturulmasıdır.</p><h4>Üç Kontrol Noktası</h4><p>Kuralların otomatik doğrulaması yetmez. Nerede çalıştığı da önemlidir. Bunu da üç noktada kontrol edebiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Qz1RGPm7qlnyDPtJgZ4MA.png" /></figure><p><strong>Tasarım Anında (Design Time): </strong>API tanımı doğrulanır. Geçerli bir şema var mı, isimlendirme kurallarına uyuyor mu, zorunlu metadata alanları dolu mu? Bu aşama development yapılan ortamda çalıştığında en verimli olduğu andır. Çünkü hata yazıldığı anda görünür.</p><p><strong>Derleme Anında (Build Time): </strong>Mimari uyum kontrol edilir. Niyet okunur ve tanımlanan kurallar ile eşleştirilir. Tanımlanan profil ile beklenen profil karşılaştırılır.</p><pre>Architecture Compliance: FAILED<br><br>  Rule      GOV-SEC-003<br>  API       payment-transfer-api<br>  Violation Dışa açık API&#39;ler ANONYMOUS güvenlik profiliyle<br>            yayınlanamaz.<br>  Required  EXTERNAL_STRICT<br>  Ref       docs/standards/security.md#external-apis</pre><p>Bu çıktısının değeri hatayı bulmasından dolayı değildir. Hatayı <strong>doğru zamanda ve doğru kişiye</strong> göstermesindendir. Aynı ihlalin üç dört hafta sonra bir review esnasında fark edilmesi maliyeti çok daha fazla arttırabilir.</p><p><strong>Çalışma Anında (Runtime): </strong>Burada kural fiilen uygulanır. Kimlik doğrulama, yetkilendirme, rate limiting, yönlendirme vb. CI/CD’nin garantileyemeyeceği kısımlar. Pipeline kısmı konfigürasyonu doğrularken gerçekten uygulandığını kontrol edemez.</p><p>Şunu da belirtmekte fayda var. Bir API tanımının kurallara uyması o kuralların gateway’de uygulandığı anlamına gelmez. Tanım dosyasını denetlemek ile çalışan sistemi denetlemek aynı şey değildir. Birincisi niyeti doğrularken ikincisi gerçekliği denetler. Sadece birincisini kuran kurumlar uyum raporunda yeşil görünürken production’da açıkta kalabilir.</p><p>Peki Governance-as-Code’un bir bedeli yok mu? Birazda bundan bahsedelim.</p><h4>Governance-as-Code’un Bedeli</h4><p>Governance-as-Code’un bana göre üç bedeli vardır.</p><p>Birincisi: oluşturulan rule engine (kural motoru) zamanla eskir. Yazılmış olan kurallar bakımsız kalır ve ekipler kuralı öğrenmektense bu kuralı atlamanın yolunu öğrenir. Bir wiki sayfasında duran doküman eskidiğinde bunu kimse fark etmez ama pipeline tarafında sürekli aynı hatayı görüp düzeltmediğimizde herkesin gördüğü uyarı artık görmezden gelinen ve hızlıca geçilen bir ifadeye dönüşür.</p><p>İkincisi ise yönetişim aracınında bir bağımlılık üretmesidir. Kuralları belirli bir ruleset formatında yazdığınızda o formatın ekosistemine bağlanmış olursunuz.</p><p>Üçüncüsü: <strong>her kural bu maliyeti hak etmez.</strong> Yılda iki kez ihlal edilen bir kuralı otomatikleştirmenin maliyeti, ihlallerin maliyetinden yüksek olabilir. Otomasyon kararı da bir mimari karardır ve gerekçesi yazılmalıdır.</p><h4>İstisnaların Yönetimi</h4><p>İstisnaslar bir arıza gibi görünmemelidir. Bunları bir özellik olarak ele almamız süreçlerin daha hızlı ilerlemesini sağlar. Mimari yönetişim hiçbir zaman herşeyi %100 kurala bağlayıp %0 istisna üzerine bir süreç hayal etmez. Çünkü böyle bir hedef ilk gerçek iş ihtiyacında ya kırılır ya da görmezden gelinir. Yüksek hacimli bir ödeme akışı standart trafik profiline sığmayabilir. Devralınan bir sistem, isimlendirme kuralına bugün uyduramayacağınız bir yüzeye sahip olabilir. Burada bilinmesi gereken istisna olan şeylerin sorun olması değildir. Eğer bu durumlar kayıt altına alınmazsa sorun olur.</p><pre>exceptions:<br>  - rule: TRAFFIC_STANDARD<br>    api: payment-batch-settlement<br>    requestedProfile: CRITICAL<br>    reason: &gt;<br>      Gün sonu toplu mutabakat penceresinde<br>      standart profil yetersiz kalıyor.<br>    owner: payments-platform-team<br>    approval:<br>      architectureDecision: ADR-1427<br>    expires: 2027-01-01</pre><p>Yukarıda “reason” ile bir istisnayı görünür hale getiriyoruz. İstisnasının kime ait olduğunu, gerekçesini, onay kararını, son kullanma tarihini bu yapıda görebiliyoruz. İşin güzel tarafı bu versiyonlandığı için denetim izide kendiliğinden oluşuyor.</p><p>Beş bilgi katmanına geri dönersek: karar gerekçeleri katmanı, makinenin <strong>üretemeyeceği</strong> ama <strong>zorunlu kılabileceği</strong> tek katmandı. İstisna yönetimi tam olarak budur. Makine gerekçeyi yazamaz; ama gerekçe yazılmadan ilerlenmesine izin vermeyebilir. Süresi dolmuş bir istisna, artık istisna değildir.</p><h4>Beyandan Kanıta</h4><p>Bütün bunların sonunda ne elde ediyoruz? Yazının başındaki soruya dönme vakti geldi: production’daki 500 API’nin standarda uyduğunu nasıl ispatlarız?</p><p>Cevap bir tablodur. Ama nasıl bir tablo?</p><pre>Production API sayısı                ~500<br>Mimari uyum                          ~%95<br>Güvenlik uyumu                       %100<br>Trafik profili uyumu                 ~%97<br>İsimlendirme uyumu                   ~%96<br><br>Onaylı istisna                          18<br>Süresi dolmuş istisna                    3<br>Onaysız sapma                            8</pre><p>Yukarıda ki tablonun son üç satırı bilginin olduğu kısımdır. Burada <strong>Onaysız Sapma </strong>olarak belirttiğim kısım aslında “ne kurala uyan ne de onaylı bir istisnası olan konfigürasyonu” temsil etmektedir. Yönetişimin gerçek karneside bu sayıdır. Çünkü uyum yüzde çok hızlı yükseltilebilir. Kuralı gevşetir, kapsamı daraltır ve sert kuralların alarm seslerini kıstığınızda bu yüzde hızlıca artar. Halbu ki oanysız sapma sayısını bu gevşetlemelerle azaltamazsınız. Yz düzeltirsiniz ya da gerekçesini yazıp onaylanmış istisnaya çevirirsiniz.</p><blockquote><strong><em>Mimari yönetişimin olgunluğu, beyan ettiği şeyle kanıtlayabildiği şey arasındaki farkla ölçülür.</em></strong></blockquote><p>Burada bir uyarıda bulunmak istiyorum. Bu tablo eğer bir performans karnesine dönüşürse ölçtüğü şeyi ölçmeyi bırakır. Başka bir yazıda değindiğim Goodhart Yasasını hatırlatmakta fayda var.</p><p>Bir ölçüt hedefe dönüştüğünde ölçüt olmaktan çıakr. Uyum oranı bir KPI haline geldiğinde ne olacağını tahmin etmek için kahin olmaya gerek yoktur. Kurallar yazılır, zor kurallar uyarı seviyesine indirilir, istisna talepleri enflosyana uğrayıp gerekçe alanlarınada “iş gereksimi” yazılıp kapatılır. Altı ay sonra elimizde kağıt üzerinde %99 uyumlu bir portföy ve hiçbir şey ifade etmeyen bir dashboard olur. Bu ölçümün amacı mimari kaliteyi puanlamak değil, nerede durduğunuzu bilmek. Tespit aracı, değerlendirme aracı değil.</p><blockquote><strong>Tespit aracı, bir değerlendirme aracı değildir.</strong></blockquote><p>Peki bu süreçleri otomatikleştirdiğimizde mimarlar işsiz mi kalacak? Ne yapacak bu kadar mimar?</p><h4>Mimarın işi ne olur?</h4><p>Yönetişimin otomatize edilmiş olması mimarın işini azaltmaz sadece değiştirir. Bugün pek çok kurumda mimari kurul, her implementasyonu gözden geçiren bir merci olarak çalışıyor. Gündemin önemli bir kısmı, aslında makine tarafından cevaplanabilecek sorularla geçiyor: bu API’nin kimlik doğrulaması var mı, isimlendirme kurallarına uygun mu, metadata’sı dolu mu?</p><p>Bu sorular gündemden çıktığında geriye kalan iş şu:</p><p>Kuralı tasarlamak. Kuralı yönetmek. Kuralın etkisini ölçmek ve istisnaları karara bağlamak.</p><p>Bunların hiçbiri otomatikleştirilemez, çünkü hiçbiri ikili bir cevaba sıkışmaz. Bir kuralın kuruma uygun olup olmadığı, bir istisnanın gerekçesinin yeterli olup olmadığı, bir sistemin sınırının doğru çizilip çizilmediği, bunlar yargı gerektiren sorular. Otomasyon, mimarı bu sorulara geri gönderiyor.</p><p>Sonuç olarak standart yazılabilir, onaylanabilir ve yayınlanabilir. Ama uygulandığı gösterilemiyorsa o standart sadece bir beyandır.</p><p>Bu yazıda anlattığım model bir araç seçimi değil, bir sıralama önerisi: önce kuralın nerede yaşadığını sorun, sonra nerede uygulandığını ve en sonunda nasıl ölçüldüğünü. Bu üç sorunun cevabı olmadan kurulan hiçbir yönetişim modeli, kurumun kendisi hakkında doğru bilgi üretmez.</p><p>Peki mimari niyeti geliştiriciden minimum efor ile nasıl toplarız? Bu niyeti platformdan bağımsız bir modele nasıl çeviririz? Ve aynı niyeti farklı gateway ailelerinde nasıl aynı sonuca dönüştürürüz? Bir sonraki yazıda bunun çalışan bir implementasyonunu kuracağız. Açık kaynak olarak tasarladığım ve şuanda test ettiğim modülün nasıl çalıştığını irdeleyip çıktısını inceleyeceğiz. Buraya kadar okuyup zaman ayırdığınız için teşekkür ederim. Geri dönüşleriniz benim için değerlidir.</p><h4>Kaynaklar</h4><ul><li>TOGAF — Architecture Compliance (uyum düzeyleri ve uyum gözden geçirme süreci): <a href="https://pubs.opengroup.org/architecture/togaf91-doc/m/chap48.html">https://pubs.opengroup.org/architecture/togaf91-doc/m/chap48.html</a></li><li>OpenAPI Specification: <a href="https://spec.openapis.org/oas/latest.html">https://spec.openapis.org/oas/latest.html</a></li><li>Architecture Decision Records — Michael Nygard, “Documenting Architecture Decisions” (2011, kavramı ortaya koyan özgün yazı): <a href="https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions">https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions</a></li><li>ADR topluluk merkezi: <a href="https://adr.github.io/">https://adr.github.io/</a></li><li>Knowledge Ownership Model — beş katmanlı bilgi modelinin tanımlandığı yazı: <a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0">https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b159a5b5077" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sliding Window’u Ölçmek: .NET + Azure Deney Defteri]]></title>
            <link>https://medium.com/@omurucum/sliding-windowu-%C3%B6l%C3%A7mek-net-azure-deney-defteri-36c58dda621f?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/36c58dda621f</guid>
            <category><![CDATA[rate-limiting]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 02:46:04 GMT</pubDate>
            <atom:updated>2026-08-21T06:46:38.041Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Henüz hedeflediğim yerde olmayabilirim . Ancak dün olduğum yerden daha yakınım…</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eX6lZGQJ3cPHyw_vH_wyhQ.png" /><figcaption>Sliding Window’u Ölçmek</figcaption></figure><p>Bazı şeyleri iddia ederek serinin son yazısına kadar geldik. Ufak çaplı örneklerle de bir önce ki makalede göstermeye çalıştım. Fakat bir şeyi iddia etmek ile ölçerek gerçek veriler üzerinden konuşmak başka bir şeydir.</p><p>Serinin sonunu Azure üzerinde bazı kurulum, özel metrikler ve testlere ayırdım. Toplamda beş deney yaptım. Hangi algoritmanın ne zaman ne yaptığına ve global limit gerçekten global mi bunu ölçtüm.</p><h4>Test Mimarisi</h4><p>Ölçümün güvenilir olabilmesi için ortamın net olması gerekir. Kurulum şu şekilde:</p><ul><li><strong>Azure Container Apps: </strong>API’nin çok replikalı çalıştığı yer. Replika sayısının sabitlemek için min ve max replikayı eşitledim. Yani <strong>autoscaling kapalı.</strong></li><li><strong>Azure Managed Redis: </strong>Replikaların paylaştığı tek ortak state.</li><li><strong>Azure Load Testing: </strong>Yük testini uygulayan servis.</li><li><strong>Application Insights + OpenTelemetry: </strong>Latency, hata oranı ve custom rate-limiter metriklerini toplayan katman.</li></ul><p>Örnek uygulamamızda toplamda dört endpoint vardır. Bunlar: <strong>fixed</strong>, <strong>in-memory (sliding)</strong>, <strong>token-bucket (hepsi replika)</strong> ve <strong>/api/transfers (redis global state). </strong>Böylece her test için doğru algoritmayı doğru endpoint’e yönledirmiş oluyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Rwh78Ee9cInPmoGfrBOWw.png" /><figcaption>Test Ortamının Mimarisi</figcaption></figure><h4>Adil Karşılaştırma Kuralları</h4><p>Yapacağımız karşılaştırmanın anlamlı olması için tüm testlerde bazı değerleri sabit tuttum. Bunlar:</p><ul><li>Aynı Azure region</li><li>Aynı container image</li><li>Aynı CPU/Memory</li><li>Autoscaling kapalı</li><li>Warm-up yapılmış</li><li>Her test öncesi Redis state temizliği</li><li>Replika sayısı test tipine göre ayarlandı. Algoritma davranışını izole eden testler için <strong>1 replika </strong>dağıtık testleri ölçen testler için <strong>3 replika</strong></li></ul><h4>Test Senaryomuz</h4><p>Bu testleri yaparken örnek aldığım senaryo: bir müşteri 60 saniyede en fazla 10 transfer başlatabilir.</p><ul><li>Endpoint: <strong>POST /api/transfers </strong>(algoritma varyantları)</li><li>Partition key: <strong>CustomerId</strong></li><li>Test ortamında <strong>X-Customer-Id</strong> header’ı dikkate alındı. Production ortamda tavsiye etmem.</li></ul><blockquote><strong>Uyguladığım testlerin komutlarını yazının sonunda kaynak olarak paylaşacağım. Görseller ve sonuçlar yazıyı yeterince uzattığı için komutları buraya eklemiyorum. Azure tarafında kurduğum mimarinin kurulum rehberini ve testlerde kullandığım warm-up dosyalarını, açıklamalarıyla birlikte ayrıca vereceğim.</strong></blockquote><h4>Test 1 — Fixed vs Sliding: Sızıntı Testi</h4><p>Kurulum algoritmayı izole etmek için 1 replika olarak yapıldı. Aynı müşteri pencerenin son saniyesinde (zaman diliminin son parçası) 10 istek ve yeni zaman diliminin ilk penceresinde 10 istek atıyor. Yani ~2–3 saniye de 20 istek.</p><p>Burada ki amaç sızıntıyı gerçek bir cloud ortamda göstermek. Fixed Window bu istekleri kabul ederken Sliding Window 429 döner.</p><pre>| Algoritma                   | Gönderilen | Batch arası | Kabul | Red | Sonuç  |<br>|-----------------------------|------------|-------------|-------|-----|--------|<br>| Fixed Window (/fixed)       | 10 + 10    | 60 sn       | 20    | 0   | Pencere resetlendi ikinci grup da kabul edildi (sızıntı davranışı) |<br>| Sliding Window (/in-memory) | 10 + 10    | 30 sn       | 10    | 10  | Batch 1 hala son 60 sn içinde ikinci grup reddedildi |</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qXZilsJmQIoCzJD_U-YTiQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k2urSh8TBf1GCYT6XDtHfw.png" /><figcaption>Test 1 Azure Çıktıları</figcaption></figure><blockquote>Not: .NET içinde yer alan Fixed limiter’ı penceresini ilk isteğe göre başlattığından aynı bekleme süresinde sızıntıyı yakalayamayız. Bu yüzden Fixed tarafında 60 saniye’lik bir bekleme varken Sliding tarafında bu bekleme 30 saniye olarak ayarlanmıştır.</blockquote><h4>Test 2 — Sürekli Trafik</h4><p>Bu testin amacı normal yük altında algoritmaların kabul davranışlarını ve latency değerlerini karşılaştırmaktır.</p><pre>| Algoritma      | Gönderilen | Kabul | Red | p50 (ms) | p95 (ms) | p99 (ms) |<br>|----------------|------------|-------|-----|----------|----------|----------|<br>| Fixed Window   | 120        | 20    | 100 | 0.111    | 0.181    | 0.308    |<br>| Sliding Window | 120        | 20    | 100 | 0.115    | 0.202    | 0.276    |<br>| Token Bucket   | 120        | 24    | 96  | 0.117    | 0.206    | 0.371    |</pre><p>Burada kabul değerinin 20 çıkmasının sebebi testi 60 saniye olarak yapmadık. 120 saniye süren bu teste ikinci pencereye geçiş olduğu için sonuç normal. Bu testten çıkarılması gerekenler:</p><ol><li>Sürekli ve düzgün trafikte Fixed ve Sliding denktir. Aralarında ki farkı sadece boundary ve burst’da görebiliriz. Token Bucket ise 24 kabul ile farkını gösteriyor. 6 saniyede 1 token dolduğundan sürekli olan bir trafikte bu algoritma fazladan geçirir.</li><li>Bence en önemli çıktı bu test için burası. Latency neredeyse yok. p99&#39;da 0.3–0.4 ms, p50&#39;de ~0.11ms. Yani rate limiting kararının kendisi bedava sayılır. İşte bu sonuç bize <strong>algoritma kararının bir performans sebebi değil mimari bir karar</strong> olduğunu net bir şekilde gösteriyor.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h2Yu552VFdSqF1sSopxZhA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1eyHs17xinTgyPvSKW582w.png" /><figcaption>Test 2 Sonuçları</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CZDBFwMTvQbis0KFHauUOQ.png" /><figcaption>Test 2 p50 Sonuçları</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6tcvct-hVsJkTVJMUIDpgg.png" /><figcaption>Test 2 p95 Sonuçları</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oVSQUl8QMNFT10zoB-kZvw.png" /><figcaption>Test 2 p99 Sonuçları</figcaption></figure><h4>Test 3 — Burst Trafiği</h4><p>Replikanın 1 olduğu son testimiz. Aynı müşteri t=0&#39;da tek seferde 100 istek gönderiyor. Sonra ki 59 saniyede istek gönderilmiyor. Burada ki amacımız ani bir yığılmada üç algoritmanında tepkisini ölçmek.</p><pre>| Algoritma      | Burst | Kabul | Red |<br>|----------------|-------|-------|-----|<br>| Fixed Window   | 100   | 10    | 90  |<br>| Sliding Window | 100   | 10    | 90  |<br>| Token Bucket   | 100   | 10    | 90  |</pre><p>Burada üç algoritmanında aynı sonucu verdiğini görüyoruz. Karşılaştırmanın adil olması için nominal hızı sabit tuttum. Token Bucket’ın asıl farkı kapasitesini nominal hızın üstüne çıkardığında burst’e izin vermesidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GfehLcivypJgiYKGOgWDtA.png" /><figcaption>Nominal Limitlerin eşit olduğu anda üç algoritmanın davranışı</figcaption></figure><h4>Test 4 — Multi Replika</h4><p>Artık replika sayısını 3&#39;e çıkardım. Daha önce bahsettiğim gibi eğer global bir limit uygulanacak ise sayacın ortak olması gerekmektedir. Şuanda her bir replika kendi sayacına sahip.</p><pre>| Algoritma                  | Replika | Gönderilen | Kabul  | Red |<br>|----------------------------|---------|------------|--------|-----|<br>| Sliding Window (in-memory) | 3       | 40         | 30     | 10  |<br>| Fixed Window (in-memory)   | 3       | 40         | 30     | 10  |</pre><p>Her bir algoritmaya toplamda 40 istek atıp limiti 10 olarak ayarlamamıza rağmen kabul değerinin 30 olduğunu görüyoruz. Bunun sebebi her bir replika’nın kendi sayacını bulunduruyor olmasıdır.</p><pre>| Replika (instance) | Kendi saydığı kabul |<br>|--------------------|---------------------|<br>| `...-75jr4`        | 10                  |<br>| `...-7nzvp`        | 10                  |<br>| `...-mnqs4`        | 10                  |</pre><p>Limit 60 saniye de 10 iken 3 replikada 30 istek geçmiş oldu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MnW3f0gkIQ1wE-O3P6Ykqg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3-13EmzXx4gE3yfk4hH7cg.png" /><figcaption>Her bir instance için veriyi gösterir</figcaption></figure><blockquote>Not: KQL kodunda gördüğünüz partition startswith “<strong>d4-</strong>” ibaresi yapılan 5 testi ayrı ayrı almak için konulmuş bir ayraçtır. Her bir isteğin header’ına eklenen <strong>X-Customer-Id’</strong>nin değeri bu şekilde ayrıştırılmıştır. Kaynak kod içerisinde gerekli açıklama eklenmiştir.</blockquote><h4>Test 5 — Redis ile Global Limit</h4><p>Replika’nın 3 olduğu yeni ortamda bu sefer sayaç olarak Redis’i kullanıyorum. Aynı müşteriyle 40 istek atıp sonuçları topluyorum. Redis state deney öncesi temizleniyor.</p><pre>| Replika | Gönderilen | Kabul | Red |<br>|---------|------------|-------|-----|<br>| 3       | 40         | 10    | 30  |</pre><blockquote>Not: Redis latency bu test aşamasında ölçülmedi. Amacımız sayacın ortak olduğunda sonucun ne olduğunu görmek. Redis kaynaklı oluşacak olan network latency farklı bir konudur.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mn9tol-3gTdzfQzDGu73LQ.png" /><figcaption>Ortak sayaç sonrası Azure çıktısı</figcaption></figure><p>Son olarak 4. ve 5. testlerin azure tarafında ki verilerine tek ekranda bakalım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*umP-KrPF9kjIy8oFrFW0yg.png" /><figcaption>Test 4 ve 5&#39;in aynı ekranda görüntüsü</figcaption></figure><p>Sonuç olarak aynı kod, aynı 3 replika ve aynı istek yükünde farklı 2 sonuç. Aralarında ki tek fark sayacın bulunduğu yer. Global olarak tanımladığımız bir yapıda bizi şaşırtacak bir sonuç.</p><p>Buraya kadar sabırla okuyarak zaman ayırdığınız için teşekkür ederim. Geri dönüşleriniz benim için değerlidir.</p><h4>Kaynaklar</h4><ol><li><a href="https://github.com/omrcm/article/blob/main/src/rate-limiting/sliding-window-part-2/test-komutlari.md">Test Komutları</a></li><li><a href="https://medium.com/@omurucum/productionda-sliding-window-tek-instance-yetmedi%C4%9Finde-3e16d078354d">Production’da Sliding Window: Tek Instance Yetmediğinde? </a>(serinin önceki yazısı)</li><li><a href="https://azure.microsoft.com/en-us/products/container-apps">Azure Container Apps</a></li><li><a href="https://azure.microsoft.com/en-us/products/managed-redis">Azure Managed Redis</a></li><li><a href="https://learn.microsoft.com/en-us/azure/app-testing/load-testing/overview-what-is-azure-load-testing">Azure Load Testing</a></li><li><a href="https://learn.microsoft.com/tr-tr/azure/azure-monitor/app/app-insights-overview?tabs=webapps">Application Insights ve OpenTelemetry</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=36c58dda621f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Production’da Sliding Window: Tek Instance Yetmediğinde]]></title>
            <link>https://medium.com/@omurucum/productionda-sliding-window-tek-instance-yetmedi%C4%9Finde-3e16d078354d?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e16d078354d</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[sliding-window-algorithm]]></category>
            <category><![CDATA[rate-limiting]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Thu, 06 Aug 2026 17:32:23 GMT</pubDate>
            <atom:updated>2026-08-06T17:32:23.792Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“<strong>Bir kuşu özgür olduğuna ikna edebilmek niye dünyanın en zor işi?</strong>” Jonathan Livingston — Martı</blockquote><p>Tavsiyem “<a href="https://medium.com/@omurucum/sliding-window-token-bucket%C4%B1n-yeterli-olmad%C4%B1%C4%9F%C4%B1-yerler-0423e5607398"><strong>Sliding Window: Token Bucket’ın Yeterli Olmadığı Yerler</strong></a>” yazısının okunduktan sonra devam edilmesidir.</p><p>Tek bir sunucu ya da instance’ta Sliding Window algoritmasını çalıştıran kodun koşması pek canımızı sıkmaz. Çünkü algoritmaya ait olan sayaç kendi içindedir ve limiti buradan yönetir.</p><p>Asıl can sıkıcı kısım o instance çoğaldığında başlar. Uygulamayı ölçeklendirdiğimiz an artık tek bir sayaca değil birbirinden habersiz birçok sayacımız olur. Her biri kendi penceresinden bakar ve “<strong>limit korunuyor” </strong>der.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wKUmZ23D8qBPLlLN3vhtmQ.png" /><figcaption>Ölçeklenmiş sistemlerde Sliding Window neden sorun çıkartır?</figcaption></figure><p>İşte asıl soru bu: ölçeklenebilir bir sistemde Sliding Window nasıl davranır ve neden sorun çıkarır?</p><p>Bu yazıda önce .NET’in içinde yer alan limiter’i production’a yakın bir ortama atacağız sonra da ölçeklendirip neyin bozulduğunu ve onu neyle çözebileceğimizi göreceğiz.</p><p>Serinin ilk yazısında örnekleri yazarken Log ve Counter için kendi kodumuzu yazdık ve süreci daha iyi anladık. Aslında buna gerek yoktu. Kullanmış olduğumuz bir çok gelişmiş framework bu gibi özellikleri paketlerinin içerisinde zaten bulunduruyor. <a href="https://dotnet.microsoft.com/en-us/apps/aspnet">ASP.NET Core</a>, rate limiting’i <a href="https://learn.microsoft.com/tr-tr/dotnet/core/whats-new/dotnet-7">.NET 7</a>&#39;den beri bünyesinde bulunduruyor. <strong>SlidingWindowLimiter’ı </strong>kullanmak için yapılması gereken ise çok basit:</p><pre>builder.Services.AddRateLimiter(options =&gt;<br>{<br>    options.AddSlidingWindowLimiter(&quot;sliding&quot;, opt =&gt;<br>    {<br>        opt.PermitLimit = 10;                 // pencere başına izin<br>        opt.Window = TimeSpan.FromSeconds(60);<br>        opt.SegmentsPerWindow = 6;            // pencereyi 6 dilime böl<br>        opt.QueueLimit = 0;                   // sıraya alma, hemen reddet<br>    });<br>    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;<br>});<br><br>app.UseRateLimiter();<br>app.MapPost(&quot;/api/transfers&quot;, TransferHandler).RequireRateLimiting(&quot;sliding&quot;);</pre><p>Burada belki de en önemli parametre <strong>SegmentsPerWindow </strong>olmalıdır. Çünkü bu parametrede daha önce bahsettiğim Log ya da Counter tabanlı yaklaşım yerine <strong>Segment </strong>bazlı yaklaşım devreye girmektedir.</p><p>Mantık şu: pencere yani 60sn’lik dilimi <strong>SegmentsPerWindow </strong>kadar eşit dilime böler ve hep ileri doğru kayan penceremiz artık dilim dilim ilerler. <strong>Window = 60 saniye</strong> ve <strong>SegmentsPerWindow = 6</strong> dediğimizde limit 10 saniyelik dilimler halinde uygulanır. Her 10 saniyede bir en eski dilim rate limit hesabına dahil edilmeden ilerlemiş olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XU7W-L5gFM4OrR-LYRuVNQ.png" /><figcaption>Segment tabanlı Sliding Window</figcaption></figure><p>Elbette bunun da bir bedeli vardır. <strong>SegmentsPerWindow </strong>bir hassasiyet-maliyet ayarıdır diyebiliriz.</p><blockquote><strong>Az dilim ucuz ama kaba, çok dilim hassas ama pahalıdır!</strong></blockquote><p>Peki gerçek bir senaryoda limiti neye göre uygularız? Genelde kullanıcı başına limitler vererek müşteri bazlı bir adalet gözetiriz. Mesela: bir müşteri herhangi bir 60 saniyede en fazla 10 para transferi başlatabilir dediğimiz de nasıl bir yol izleriz. Burada genellikle izlenen yol limiter’ı <strong>CustomerId</strong>’ye göre gruplamak oluyor.</p><pre>options.AddPolicy(&quot;per-customer&quot;, context =&gt;<br>{<br>    var customerId = context.Request.Headers[&quot;X-Customer-Id&quot;].ToString();<br>    if (string.IsNullOrEmpty(customerId))<br>        customerId = &quot;anonymous&quot;;<br><br>    return RateLimitPartition.GetSlidingWindowLimiter(customerId, _ =&gt;<br>        new SlidingWindowRateLimiterOptions<br>        {<br>            PermitLimit = 10,<br>            Window = TimeSpan.FromSeconds(60),<br>            SegmentsPerWindow = 6,<br>            QueueLimit = 0<br>        });<br>});</pre><p>Yukarıda ki yapıyı elbette direk production’a almıyoruz. Bu test amaçlı. Burada müşteriyi <strong>X-Customer-Id</strong> header’ından okuyoruz. Prod ortamda bunu JWT claimden almak daha doğru olacaktır. Sonuçta kullanıcının kendi kimliğini taklit ederek bir zaafiyete yol açmak istemeyiz.</p><p>Peki madem kullandığımız framework içinde bu yapı var ise neden kendi limiter’ımızı konuşuyoruz. Aslında çoğu uygulama için mevcut çözümler yeterlidir. Tek instance, standart ihtiyaçlar, ekstra bağımlılık istemeyen servis için framework’ün verdiği segment tabanlı limiter en pratik tercihtir.</p><p>Ama uygulamanın sahip olduğu tüm instance’larda global bir rate limit istiyorsak (en önemli neden aslında bu), OpenTelemetry ile özel metriklere ihtiyaç duyuluyor ise, kesin bir Log davranışı isteniyor ise işte o zaman hazır verilen limiter’in yetersiz olduğunu hatta çuvalladığını görebiliriz. Aslında global olarak anlandırdığımız yapıda ki global teriminin <strong>Sahte Global </strong>olduğunu anlarız.</p><h4>Ölçeklendirince Ne Bozulur?</h4><p>Şimdi önce şunu hatırlayalım: SlidingWindowLimiter’ın state’i kendi içinde yaşıyor. Yazının başında buna kısa bir değinmiştim. Tek instance’da bu bir sorun değildir. Ama uygulama ölçeklenip artık üç replikaya sahip olduğunda artık 3 farklı bellek ve sayaç vardır. LB (load balancer) istekleri dağıttıkça her replika yalnız kendine gelenleri sayar. Doğal olarak framework içinde ki limiter’da koyduğumuz limitler kendi içinde tutarlı bir davranış sergiler. Ama hatalıdır!</p><pre>API-1  -&gt; 100 request sayar<br>API-2  -&gt; 100 request sayar<br>API-3  -&gt; 100 request sayar<br>──────────────────────────────<br>Global limit: 100    Gerçekte geçen: ~300</pre><p>İşte bizim global dediğimiz yapı aslında <strong>Sahte Global</strong> ünvanını burada kazanır. Sayaç tek ve ortak olmadıkça <strong>global limit </strong>her replikanın kendi penceresinde ürettiği bir yanılsamadan ibarettir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zEQHefYVWJ--6mPV-0KBgg.png" /><figcaption>Global Limit Sorunu</figcaption></figure><p>İşte bu sorunun çözümü tek ve ortak bir sayaç üzerinden state yönetimini yapmaktır. Her bir mimari kurul burada farklı çözüm önerileri getirebilir. Benim getirdiğim çözüm önerisi bahsi geçen ortak state’in Redis üzerinden yönetilmesine yöneliktir.</p><h4>Redis ile Gerçek Global Limit</h4><p>State’i replikaların dışında ortak bir yere taşıdığımız an gerçek global limiti uygulama imkanımız da beraberinde gelir. Tüm replikalar aynı veriyi okur dolayısıyla tek bir gerçek sayaç oluşur.</p><p>Sliding Window’un Log varyantını Redis tarafında bir <strong>Sorted Set </strong>ile oluşturabiliriz. Ne yapmıştık bu varyantta: zaman damgası oluşturup her bir istek için bu damgayı saklamıştık. Burada da zaman dangasını set ederiz, timestamp alanına score adını veririz işlem tamamlanmış olur. Son 60 saniyeyi say dediğimizde de işlem üç adıma inip eskiyi siler, kalanı sayar ve yeniyi ekler. İşte tam oldu dediğimiz yerde bir race condition durumu vardır. İki replikanın araya girdiği bir anda ikisi de “<strong>sayı limitin altında</strong>” görüp aynı anda ekleme yapabilir. Bu durumun yaşanmaması için üç adımında <strong>tek ve atomik</strong> çalışması gerekir. Bunu redis tarafında lua scriptiyle yapabiliriz.</p><pre>-- KEYS[1] = rate limit anahtarı (örn. rate:customer_42)<br>-- ARGV[1] = now (ms), ARGV[2] = window (ms), ARGV[3] = limit, ARGV[4] = tekil üye<br>local clearBefore = tonumber(ARGV[1]) - tonumber(ARGV[2])<br>redis.call(&#39;ZREMRANGEBYSCORE&#39;, KEYS[1], 0, clearBefore)   -- window dışını sil<br>local count = redis.call(&#39;ZCARD&#39;, KEYS[1])                 -- kalanları say<br>if count &lt; tonumber(ARGV[3]) then<br>    redis.call(&#39;ZADD&#39;, KEYS[1], ARGV[1], ARGV[4])          -- yeni timestamp<br>    redis.call(&#39;PEXPIRE&#39;, KEYS[1], ARGV[2])                -- key için TTL<br>    return 1<br>else<br>    return 0<br>end</pre><p>Yukarıda ki script tek adımda çalışır ve okuma ile yazma arasına başka bir replika giremez. PEXPIRE ile de keylerin TTL süresini belirleyip sonsuza dek sanklanmasının önüne geçmiş oluyoruz.</p><p>.NET tarafında ise bu yapıyı StackExchange.Redis kütüphanesini kullanarak çağırabiliriz.</p><pre>long result = (long)await db.ScriptEvaluateAsync(<br>    SlidingWindowScript,<br>    new RedisKey[] { $&quot;rate:{customerId}&quot; },<br>    new RedisValue[] { nowMs, windowMs, limit, Guid.NewGuid().ToString() });<br><br>bool allowed = result == 1;   // 1 = izin, 0 = 429    </pre><p>Her istek için ayrı bir Guid oluşturarak aynı milisaniyede gelen iki isteğin birbirini ezmesinin önüne geçmiş oluyoruz. Sonuç <strong>1</strong> ise istek geçer <strong>0</strong> ise <strong>429 Too Many Request</strong> döneriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nmUG5s-0h7DWQ1wp1pUV9g.png" /><figcaption>Redis ile Sliding Window Mimarisi</figcaption></figure><p>Üç stateless replika tek bir redis’e bakar ve <strong>ZREMRANGEBYSCORE</strong> — <strong>ZCARD — ZADD — PEXPIRE</strong> süreci tek bir Lua script içinde atomik çalışır.</p><p>Bu kurulumda mimari sadeleşir: load balancer istekleri stateless replikalara dağıtır, replikalar hiçbir sayaç tutmaz ve sayaç artık merkezi olmuştur. Bir replika yeniden başlasa da limit bozulmaz; çünkü hafıza replikada değil, ortak state’te yaşar.</p><h4><strong>Peki bu çözüm kesin çözüm müdür?</strong></h4><p>Merkezi bir sayaç oluşturmak için Redis’i kullanmış olmamız bize 100% sorunsuz bir sistem vaadinde bulunmamaktadır. Burada karşılabileceğimiz bazı sorunları kısaca belirtmek isterim.</p><ol><li><strong>Clock drift: </strong>Eğer timestamp sunucu saatinden alınıyor ise replikaların saatleri birbirinden farklı olabilir. Bu durumda Sliding Window tarafında oluşan pencere aralığı bulanıklaşır. Zamanı sunucudan almak yerine Redis’in kendi <strong>TIME</strong> komutundan almak daha iyi olacaktır.</li><li><strong>Redis latency: </strong>Artık bir katmanın daha olduğunu bilmemiş gerekiyor. Her istek redis tarafına gidip gelecek. Redis’i uygulamaya yakın konumlandırmak ve gereksiz round-trip kaçınmak gerekecektir.</li><li><strong>Replica restart &amp; state consistency: </strong>State merkezi bir yapıya kavuştuğu için artık replikalar rahatça yeniden başlayabilir. Bu bir artıdır. Fakat Redis tek kaynak olduğunda bir failover senaryosunda replikasyonun gecikmesi kısa süreliğine bir çift sayıma sebep olabilir. Rate limitin çok katı olması gereken yerlerde bu ihtimali de dikkate almak gerekir.</li></ol><p>Burada farklı sorunlarda elbette oluşabilir. Her birini tek tek ele almıyorum. Ayrıca bu sorunların varlıklarıda Redis çözümünü çürütmez. Sadece şunu fark etmemizi sağlar:</p><p>Bu listenin hiçbiri Redis yaklaşımını çürütmez. Global limit hazır gelen bir çözüm değil, kendi mühendislik sorularını da beraberinde getiren bir karardır.</p><p>Sonuç olarak tek instance üzerinde sorunsuz çalışan sistem ölçeklendiğinde yanıltıcı çıktılar verebilir. İlk yazıda yüzeysel geçtiğim örnekleri bu yazı da production’a yakın bir şekilde tasarlamaya çalıştım. Fakat bu da cevap için yeterli değil. Serinin son yazısında bu sefer bu iddia’ları Azure ortamında gerçekten çalıştıracağız. Container Apps üzerinde çok replikalı bir API, Managed Redis, Azure Load Testing ve Application Insights ile gerçek bir production ortamının değerlerini görüp önce sorunu sonra da çözümü gözlemleyeceğiz.</p><p>Buraya kadar okuyup zaman ayırdığınız için teşekkür ederim. Geri dönüşleriniz benim için değerlidir.</p><p><strong>Kaynaklar</strong></p><ul><li>Bu yazıdaki örnek kodun <a href="https://github.com/omrcm/article/tree/main/src/rate-limiting/sliding-window-part-2">tamamı</a></li><li>Sliding Window: <a href="https://medium.com/@omurucum/sliding-window-token-bucket%C4%B1n-yeterli-olmad%C4%B1%C4%9F%C4%B1-yerler-0423e5607398">Token Bucket’ın Yeterli Olmadığı Yerler</a> (serinin önceki yazısı)</li><li><a href="https://learn.microsoft.com/en-us/aspnet/core/performance/rate-limit?view=aspnetcore-10.0">ASP.NET Core Rate Limiting Middleware</a></li><li><a href="https://stackexchange.github.io/StackExchange.Redis/">StackExchange.Redis</a></li><li><a href="https://redis.io/glossary/redis-sorted-sets/">Redis Sorted Set</a> ve <a href="https://redis.io/docs/latest/develop/programmability/eval-intro/">Lua Scripting</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e16d078354d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sliding Window: Token Bucket’ın Yeterli Olmadığı Yerler]]></title>
            <link>https://medium.com/@omurucum/sliding-window-token-bucket%C4%B1n-yeterli-olmad%C4%B1%C4%9F%C4%B1-yerler-0423e5607398?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/0423e5607398</guid>
            <category><![CDATA[rate-limiting]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[system-design-project]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 13:59:35 GMT</pubDate>
            <atom:updated>2026-08-04T14:08:22.072Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Talip olduğun yolu yokuşuyla seveceksin!</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J3yQbDTWibSjAdA8kjz9sg.png" /><figcaption>Token Bucket’ın yeterli olmadığı yerde Sliding Window</figcaption></figure><p>Bu yazıyı okumadan önce tavsiyem <a href="https://medium.com/@omurucum/token-bucket-net-ile-rate-limitingin-temel-algoritmas%C4%B1-cd66db171bde">Token Bucket: .NET ile Rate Limiting’in Temel Algoritması</a> yazısını okumanız olacaktır.</p><p>Bir önce ki yazıda Token Bucket’ı kurduk. Kova (Bucket), jetonlar, ve dolum hızını anladık. Ortalama hızı kibarca yöneten, kontrollü bir burst’e nefes payı bırakan sağlam bir algoritma.</p><p>Sistemimizi kullanan bir kullanıcıya “<strong>dakika da 100 istek</strong>” demek çok kolaydır. Peki bu istek zamanın hangi anında geçerlidir. Bunu nasıl tarif edeceğiz. İşte işin zor kısmı budur.</p><p>Peki her problem bir ortalama hız problemi midir? Bu yazının derdi tek bir soruya cevap vermektir.</p><blockquote><strong>Token Bucket’i bildiğimize göre neden başka bir algoritmaya ihtiyaç duyuyoruz?</strong></blockquote><p>Aslında cevap gözümüzün önünde. Sadece oraya bakmıyoruz. Diyelim ki bir servis için limit belirledik ve dakikada 100 istek olarak kuralımızı hayata geçirdik. Aşağıdaki şekilde farklı iki zaman diliminde (buna görsellerde window diyeceğim) belirlediğimiz limite uygun şekilde istekler geldi.</p><pre>10:00:58<br>████████████████████████  100 request<br>        ↓<br>10:01:01<br>████████████████████████  100 request</pre><p>İşte sihir burada başlıyor. Üç saniye de sistem 200 isteği kabul etti. Loglara baktık ve bir ihlal görmedik. Kural neydi? Dakika da 100 istek. İlk 100 istek 10:00 diliminde ikinci 100 istek ise 10:01 diliminde geldi. Ama gerçek dünya da gerçekten böyle mi oldu? Yoksa kullanıcı “<strong>dakikada 100 saniye</strong>” limitini üç saniye de iki katına mı çıkarmış oldu?</p><p>İşin özü kağıt üzerinde limiti koruduk ama sahada başarısız olduk. Hem sahada edindiğim deneyim hem de yaptığım örnekler sonrasında fark ettim ki iki bitişik zaman diliminde her bir zaman dilimi verdiğim kurala uymasına rağmen toplam trafiğin limiti aşılmış oluyor. Buna <strong>Sınır Sızıntısı </strong>adını verdim.</p><p>Peki ama bu algoritmaları bizleri bu gibi durumlara karşı da korusun diye kullanmıyor muyuz? Fixed Window buna neden izin veriyor? İşte burada bilmemiz gereken bu algoritmanın zamanı nasıl yönettiğidir.</p><p>Fixed Window’un mantığı çok basittir. Zamanı sabit dilimlere böler. Örnekte gördüğümüz 10:00:00–10:00:59 aralığı bir dilimdir. Her zaman dilimi bir sayaç tutar ve bu aralık bittiğinde sayaç sıfırlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d0cNCICO1hjBmoVXGPAbEA.png" /><figcaption>Her iki zaman dilimi de kurala uyar ve ~2sn’de 200 request geçer. Bu sızıntı bir teori değildir.</figcaption></figure><pre>public bool TryAcquire(double t)<br>{<br>    long w = (long)(t / _window);          // istek hangi zaman dilimine düşüyor?<br>    int c = _counts.GetValueOrDefault(w);   // zaman diliminin sayacı<br>    if (c &lt; _limit) { _counts[w] = c + 1; return true; }<br>    return false;<br>}</pre><p>İşte sorun tam da “<strong>w</strong>”’nin değiştiği anda olur. Zaman dilimi değiştiğinde “<strong>_counts”</strong> yeni zaman diliminin sayacı olmuştur. Yani kullanıcının önünde tertemiz hiç kullanılmamış bir kota vardır artık. Zaman diliminin son saniyesinde kotasını dolduran kullanıcı yeni dilimin ilk saniyesinde de bu aralığın kotasını tüketip kısa sürede her iki dilime ait kotayı tüketmiş olur.</p><p>Buradan şu çıkarımı yapıyoruz: Fixed Window akışa bakmıyor zaman dilimine bakıyor.</p><p>Peki ilk yazıda çalışma mantığını öğrendiğimiz Token Bucket bu sorunu çözmez mi? Ani bir şekil de gelen istekler (jetonlar) bucket (kova) içinde birikir ve yığılma bir nebzede olsa törpülenmiş olur. Ama Token Bucket’ın asıl işi bu değildir. Token Bucket algoritmasının tasarlanma amacı <strong>ortalama hızı sabit tutmaktır. </strong>Kısacası burst bir kusur değildir bir özelliktir bu algoritma için. Mesela bir OTP servisini düşünelim. Kullanıcının kısa sürede on kod istemesi ile bu on kodu on ayrı dakikada istemesi aynı şey değildir. Eğer burada ortalama hız kullanırsak yanılırız. Bizim için bu örnekte önemli olan herhangi bir zaman diliminde ki tepe değeridir.</p><blockquote>OTP’yi dakikada 100 ile sınırladık ama biri saniyeler içinde 200 kod aldı ve hiçbir alarm çalmadı. Token Bucket yanlış çalışmadı. Sadece yanlış soruya doğru cevap vermiş oldu.</blockquote><h4>Peki Sliding Window Nasıl Çalışır?</h4><p>Sliding yani kayma. Aslında bu kadar basit. Zaman dilimini sabit tutmak yerine kayan bir pencerede yönetmek. Sayaç sıfırlanmaz. Her bir istek geldiğinde algoritma hemen şu soruyu sorar: “Şu andan itibaren son 60sn’de kaç istek geldi?” Eğer cevap limitin altındaysa istek geçer, değilse reddedilir. Zaman çizgisi üzerinde ki pencere hiçbir zaman durmaz. İleri doğru hareket eder. İşte bu hareket sayesinde başta söylemiş olduğum Sınır Sızıntısı sorunu da ortadan kalkar. Peki ama sorduğumuz soruda şuandan itibaren geri dönük 60sn’yi nasıl sayacak? İşte burada iki yöntem var.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CFdFZIeOMXE4AqXXkozszQ.png" /><figcaption>Zaman aralığı sürekli ileri doğru kayar ve 60sn’yi geçen istekler artık sayıma dahil edilmez</figcaption></figure><h4>Yöntem 1: Sliding Window Log</h4><p>Bu yöntem aslında sonucun en doğru hesaplandığı yöntemdir.</p><pre>public bool TryAcquire(double t)<br>{<br>    double cutoff = t - _window;<br>    while (_log.Count &gt; 0 &amp;&amp; _log.Peek() &lt;= cutoff)<br>        _log.Dequeue(); // 60 saniyeden eski kaydı at<br><br>    if (_log.Count &lt; _limit) <br>      _log.Enqueue(t); return true;<br><br>    return false;<br>}</pre><p>Örnekte fark ettiyseniz sıfırlanan bir counter yok. Her bir request öncesinde 60 saniyeden eski kayıtlar temizleniyor ve sonra kalanlar sayılıyor. Bu yöntem çok hassastır ve kesin sonuç verir. Fakat bunun da bir bedeli vardır. Her bir request için zaman damgası (timestamp) saklamak gerekir. Memory gelen request’in hacmiyle birlikte şişer. Bu maliyete bir de eski kayıtların silinmesini de eklemek gerek tabi. Yüksek trafikli sistemlerde bu bir sorundur.</p><h4>Yöntem 2: Sliding Window Counter</h4><p>Bir çok production ortamında kullanılan yöntemdir. Her bir istek için timestamp tutmak yerine iki sayaç vardır. Mevcut ve önce ki zaman dilimi. Sonuç iki pencerenin ağırlıklı bir bileşimiyle tahmin edilir.</p><pre>double elapsedFraction = (t - w * _window) / _window;<br>int prev = _counts.GetValueOrDefault(w - 1);<br>int cur  = _counts.GetValueOrDefault(w);<br><br>double estimate = cur + prev * (1 - elapsedFraction);   // ağırlıklı tahmin<br>if (estimate &lt; _limit) { _counts[w] = cur + 1; return true; }</pre><p>Bu kodda ki en önemli kısım (1 — elapsedFraction) kısmıdır. Eğer mevcut zaman diliminin %25&#39;lik kısmındaysak önce ki zaman diliminin %75&#39;lik sayısı hesaba katılır. Aslında bu bir tahmindir. Kazanç bir önce ki yönteme göre çok büyüktür. Artık memory request arttıkça şişmez, eski kayıtların silinme derdi yoktur. Kayıp ise nispeten daha azdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G8KK39ZoW1fkZW_xDl0gRA.png" /><figcaption>Log kesin değer verir (O(n)) Counter ise tahmini bir değer verir (O(1))</figcaption></figure><p>Bu iki yöntemi ve Fixed Window test ettiğimde elde ettiğim sonuçlarda her şeyi net bir şekilde ortaya koydu.</p><pre>Toplam gönderilen istek : 200  (100 + 100, ~3 saniye arayla)<br>Limit                   : dakika da 100 istek<br>------------------------------------------------<br>Fixed Window            : 200 kabul   &lt;- Sınır Sızıntısı<br>Sliding Window Log      : 100 kabul   &lt;- tam<br>Sliding Window Counter  : 102 kabul   &lt;- yaklaşık</pre><p>Fixed Window 3 saniye içinde aslında 2 dakikada tüketilmesi gereken limiti tüketti. Sliding Window Log yöntemi tam 100&#39;de durdu ve gelen diğer isteklerin hepsini engelledi. Sliding Window Counter ise 102 isteğe izin verdi. İşte burada mimar olarak şu trade-off’ları bilerek bir tercih yamak gerekir.</p><p><strong>Fixed Window</strong> hassasiyet ve memory kullanımı olarak çok düşük ve Sınır Sızıntılarına açık bir yapıdır.</p><p><strong>Sliding Window Log</strong> hassasiyet olarak tam istediğini verir. Memory kullanımı yüksektir fakat Sınır Sızıntılarına karşı kapalıdır.</p><p><strong>Sliding Window Counter</strong> ise yaklaşık bir hassasiyete sahipken memory kullanımı açısından ikinci sırada yer alır. Sınır Sızıntısına karşıda kısmen bir koruma sağlar.</p><p>İşte bu trade-off’ların ışığında seçim yapılması gerekmektedir. Sliding Window, Fixed Window’a göre daha dik bir yoldur. Eğer servislerinize eklediğiniz rate limitinde zaman adaleti gerekirse bu dik yolu seçmek gerekir. Yazının başında da belirttiğim üzere “<strong>Talip olduğun yolu yokuşuyla seveceksin</strong>” :)</p><h4>Peki Sliding Window her zaman doğru cevap mıdır?</h4><p>Burası aslında tek bir doğrunun olmadığını söylemem gereken yer. İhtiyaçlara göre seçimler yapmak gerekmektir. Eğer gelen trafikte kontrollü bir burst’a izin verecekseniz ya da düşük maliyetli veya çok basit bir günlük kota yetiyorsa o zaman bu algoritmayı kullanmak gereksiz olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n5nQNgGgxkjfToFVsotJrA.png" /><figcaption>Burst kabul ediliyor ise Token Bucket, limit tanımı yapılmış ve net ise Sliding Window</figcaption></figure><p>Buradan şu sonuca varmamak gerekiyor. Token Bucket yanlış bir algoritmadır ve kullanmak can sıkabilir. Eğer ortalama hızı ölçüp ilerliyorsanız işinizi görür. Ama limitlere uyum kesin ise işte o zaman Sliding Window öne çıkar.</p><p>Bir sonra ki yazıda bir production ortamında süreç nasıl ilerliyor onu göstermeye çalışacağım. Özellikle .Net’in yerleşik SlidingWindowLimiter’ını daha net göreceğiz. <strong>Window</strong> ve <strong>SegmentsPerWindow</strong> parametrelerinin nasıl bir kolaylık ve alternatif sağladığını beraber inceleyeceğiz.</p><p>Zaman ayırıp okuduğunuz için teşekkür ederim. Geri dönüşleriniz benim için değerlidir.</p><h4>Kaynaklar</h4><ul><li>Bu yazıda ki örnek kodun tamamı: <a href="https://github.com/omrcm/article/tree/main/src/rate-limiting/sliding-window">https://github.com/omrcm/article/tree/main/src/rate-limiting/sliding-window</a></li><li><a href="https://medium.com/@omurucum/token-bucket-net-ile-rate-limitingin-temel-algoritmas%C4%B1-cd66db171bde">Token Bucket: .NET ile Rate Limiting’in Temel Algoritması</a></li><li>ASP.NET Core Rate Limiting Middleware</li><li><a href="https://limits.readthedocs.io/en/stable/strategies.html">Sliding Window</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0423e5607398" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kurumsal Mimarinin Asıl Görevi]]></title>
            <link>https://medium.com/@omurucum/kurumsal-mimarinin-as%C4%B1l-g%C3%B6revi-871636519a9c?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/871636519a9c</guid>
            <category><![CDATA[togaf]]></category>
            <category><![CDATA[knowledge-lock-in]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[kom]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Sun, 26 Jul 2026 08:51:37 GMT</pubDate>
            <atom:updated>2026-07-26T08:51:37.946Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Bir ustanın büyüklüğü yaptığı işle değil, kendinden sonra o işi yapabilenlerle ölçülür.</strong></blockquote><p>Knowledge Lock-in Serisi — 5</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/871/1*6YUvJxrEAiaH-gpYnP1W3w.png" /><figcaption>Kurumsal Mimarinin Asıl Görevi</figcaption></figure><p>Bir mimari kurul toplantısı düşünün. Yeni bir ürün gündemde ve sunumlar yapılıp sorular soruluyor. Bu sorular genelde;</p><ul><li>Maliyet nedir?</li><li>Mevcut standartlarımıza uyuyor mu?</li><li>Güvenlik gereksinimlerini karşılıyor mu?</li><li>Hangi ekip sahiplenecek?</li><li>Legacy sistem ile bir entegrasyon ihtiyacı var mı?</li></ul><p>Hepsi doğru sorular. Ancak neredeyse hiçbir kurum içi toplantıda şu sorulmaz (en azından ben denk gelmedim)</p><blockquote><strong>“Bu teknolojinin bilgisi üç yıl sonra nerede yaşayacak?”</strong></blockquote><p>İşte bu yazıda tam da bu sorunun neden mimari komitelerde olması gerektiğini anlatacağım. <strong>Knowledge Lock-in</strong> Serisinin son yazısı.</p><p>Yazıya başlamadan önce buraya nasıl geldiğimizi kısaca bir hatırlayalım;</p><p>İlk yazıda bir tez ortaya attık ve kurumların asıl riskinin Vendor Lock-in değil <strong>Knowledge Lock-in</strong> olabilir dedik.</p><p>İkinci yazıda bir harita çıkartıp adını <strong>KOM</strong> yani <strong>Knowledge Ownership Model </strong>koyduk. Bilginin katmanları olduğunu ve her bir katmanın sahiplik seviyesini tanımladık.</p><p>Üçüncü yazıda ölçümün nasıl olması gerektiğine değindik. Sinyaller, metrikler ve on soruluk bir öz değerlendirme.</p><p>Dördüncü yazıda artık hareket zamanı diyerek değişimi başlattık. Sözleşmeden çalışma biçimine, kurumsal hafızadan insan yönetimine uzanan bir playbook ortaya çıkardık.</p><p>Şimdi geriye tek bir soru kaldı;</p><blockquote><strong>Peki tüm bunları kim sürdürecek?</strong></blockquote><p>İşte bu final yazısında bu sorunun cevabını vereceğiz. Diyelim ki dördüncü yazıda bahsettiğim playbook’u uyguladınız. ADR yazmaya başladınız. Runbookları güncellediniz. Vendor ilişkisinde reverse pairing’e geçtiniz. Sözleşmeye bilgi transferi maddeleri eklediniz. Kısacası harika bir yıl geçirdiniz. Herkes mutlu. Ama bu harika yılı geçirmenize yardımcı olan kurum çalışanı işten ayrılır, proje biter, ekip dağılır ya da yeni bir kriz gelir ve öncelikler değişirse. Yeni bir vendor gelir ve kimse ona bir yıl önce kazanılmış beklentiyi anlatmazsa. Böyle bir durumda ne olur? Belli bir süre geçer ve kurum içinde şu ses duyulur;</p><blockquote><strong>Biz bunu bir dönem yapıyorduk</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j52RpaGcUa9w9-bcsuoBFw.png" /><figcaption>Playbook neden erir?</figcaption></figure><p>İşte bu Knowledge Lock-in’in en sinsi halidir. Çünkü bu kez kaybolan bilgi değildir <strong>bilgiyi koruma pratiği kaybolmuştur.</strong></p><p>Buradan çıkarılması gereken sonuç nettir. İyi pratikler kişilere ve projelere bırakıldığında erir. Kalıcılık ancak pratik bir yönetişim mekanizmasına gömüldüğünde mümkündür. Ve kurumsal teknolojide bu mekanizmanın adı bellidir. <strong>Kurumsal Mimari</strong></p><h4>Mimari Karar Kapısına Bir Soru Daha Eklemek</h4><p><strong>ADG</strong> yani <strong>Architecture Decision Gate </strong>çok havalı bir tabirdir. Kurumsal mimarinin en somut aracıdır diye bilirim. Yeni bir ürün, yeni bir platform, yeni bir vendor … hepsi bu onay noktasından geçer/geçmelidir. İşte bu onay noktasına tek bir kriter eklemek uzun vadede her şeyi değiştirir. Nedir bu kriter; <strong>Hedef bilgi sahipliği seviyesi.</strong></p><p>Bugün bir çok mimari kurulda karar şöyle çıkar;</p><blockquote><strong>Bu ürünü / vendor’u / teknolojiyi onaylıyoruz</strong></blockquote><p>Oysa şöyle çıkması her şeyi değiştirir;</p><blockquote><strong>Bu ürünü, operasyonel bilgide 24 ay içinde Seviye 3 hedefiyle onaylıyoruz. Bu hedefe nasıl ulaşılacağı proje planında yer alacaktır.</strong></blockquote><p>Küçük bir fark gibi görünebilir ama etkisi büyüktür. Birinci cümlede bilgi sahipliği kimsenin sorumluluğunda değilken ikinci cümlede artık bir hedef, bir plan ve bir taahhüttür. Aslında var olan ADG’ye aşağıdaki üç sorunun eklenmesi yeterli olacaktır;</p><ol><li>Bu teknolojinin hangi bilgi katmanları kritik?</li><li>Bu katmanlarda hedef sahiplik seviyemiz ne ve neden?</li><li>O seviyeye kim, nasıl ve ne zaman ulaştıracak?</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ExKEzFcKi6GDIYFaojqTmQ.png" /><figcaption>ADG’ye eklenecek sorulardan önce ve sonra</figcaption></figure><p>Bunlar bürokratik sorular değildir. Bugün sorulmadığında ilerleyen zamanlarda cevapsız kalacak olan sorulardır. Benim gibi regülasyona tabi sektörlerde çalışanlar için ayrıca bir hususu daha belirtmek isterim. Rügülasyonlara tabi olan kurumlarda dış kaynak kullanımına dair düzenlemeler genel olarak şunu bekler; Kurum, kritik fonksiyonlar üzerindeki kontrol ve gözetim sorumluluğunu <strong>devredemez. </strong>Hizmeti dışarıdan alabilirsiniz ama sorumluluğu dışarıya asla veremezsiniz. Bu beklentinin pratikteki karşılığını çok basit bir test ile ölçebilirsiniz.</p><blockquote><strong>Bir denetim sorusu geldiğinde cevabı kim veriyor?</strong></blockquote><p>Kurum ekibi kendi sistemini kendi kelimeleriyle anlatabiliyorsa kontrol kurumdadır. Ancak cevap için her seferinde vendor’un kapısı çalınıyor ve vendor’un masada olması isteniyor ise bu yalnızca teknik bir eksiklik değil aynı zamanda <strong>yönetişim boşluğudur</strong>. Kısacası <strong>Knowledge Lock-in</strong> regüle sektörlerde aynı zamanda bir <strong>uyum riskidir</strong>. Konuyu üst yönetim gündemine taşımak için belki de en güçlü argümanda bu risktir.</p><h4>KOM’u Yaşayan Bir Envantere Dönüştürmek</h4><p>İkinci yazıda bahsettiğim KOM matrisi bir kere doldurulup sonrada unutulacak bir şablon değildir. Çoğu kurumda zaten bir envanter uygulaması vardır. Sistemler, sahipleri, kritiklik seviyeleri, bağımlılıkları vb. başlıklar bu envanter uygulamasında hazır bulunmaktadır ya da bulunmalıdır. Bu zaten kurumsal mimarinin klasik varlıkları arasında yer alır.</p><p>Önerim çok basit. Bu envantere bir boyut daha ekleyin ve her kritik sistem için mevcut ve hedef KOM seviyelerini yazın. Yılda bir gözden geçirilsin. Bu sayede bilgi sahipliği dediğimiz şey bir kişinin farkındalığından çıkıp kurumun izlediği bir varlığa dönüşmüş olur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ROCLLOqwL4MGdh9TKOKyTw.png" /><figcaption>Kurusal Mimari Envanteri — KOM Sevileri</figcaption></figure><p>Bu aynı zamanda önceliklendirmeyi de kolaylaştırır. Kritikliği yüksek fakat sahiplik seviyesi düşük olan sistemler envanterde kendiliğinden görünür hale gelir.</p><blockquote><strong>Görünmeyen risk yönetilemez. Envanter riski görünür kılmanın en sade yoludur.</strong></blockquote><p>Yavaş yavaş yazının ve serinin sonuna doğru gelirken değinmek istediğim üç konu daha var. Sorunun çözümü ile ilgili önerilerden bahsettik ama bunların sürdürülebilir olması için nasıl bir yol izlemek gerek. Buna da değinmek gerekiyor.</p><h4>Yönetişimin Görünmeyen Yarısı: Teşvikler</h4><p>Bir yönetişim çerçevesi yazabilirsiniz. ARG’lere yeni kriterler de eklenebilir ve envanteri de güncel tutabilirsiniz. Ancak ADR yazmak, bilgi transfer oturumu yapmak, runbook güncellemek gibi işlemler hiçbir performans değerlendirmesinde görünmezse uzun vadede yapılmaz. Bunun nedeni kurumlarda insanlar ödüllendirilen davranışları tekrar ederler. Burada aslında üçüncü yazıda ki uyarıyı hatırlamak gerekiyor.</p><blockquote><strong>Metrik Fetişizm mi</strong></blockquote><p>Eğer ADR sayısını hedef olarak belirlerseniz elinizde boş ADR’lerden başka bir şey olmaz. Burada ödüllendirilmesi gereken şeyin <strong>çıktı yerine yetkinliklik </strong>olması gerektiğini unutmayın. Teşvik doğru yapıldığında dokümantasyon zaten kendiliğinden gelecektir.</p><blockquote><strong>“Kaç ADR yazdınız?” </strong>değil <strong>“Ekibiniz bu sisteme bağımsız müdahale edebiliyor mu?” </strong>motivasyonu daha değerlidir.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eekW4TQyPmezBOeRLQWo1w.png" /><figcaption>Yönetişimin Görünmeyen Yarısı: Teşvik ve Metrik Fetişizm mi</figcaption></figure><p>Bunun yanında kaçınılması gereken ve yıllar içinde tecrübe ettiğim üç tuzaktan da bahsetmek isterim.</p><ol><li><strong>Doküman Polisi Olmak: </strong>Kurumsal mimari ekipleri insanların peşinden doküman kovalayan bir birim haline gelirse iki şeyi kesin kaybeder. Doküman kalitesi ve ekiplerin iyi niyeti. EA’nı rolü <strong>denetlemek değil, mümkün kılmaktır. </strong>Şablonu hazırlar, süreci kısaltır ve doğru olan yolu en güzel seçenek haline getirir.</li><li><strong>Şablon Dolduruculuğu: </strong>Hazırladığınız şablonların düşünülmeden gelişi güzel doldurulmuş olması size sadece <strong>bilgi var hissi verir. </strong>Kolaya kaçmadan düşünülerek ve doğru soruların sorulduğu bir ADR’ye ihtiyacınız olduğunu unutmayın.</li><li><strong>Yönetişimi Bürokrasiye Çevirmek: </strong>Her karar için 5–6 onay gerektiren süreç insanları süreci aşmaya iter. Bilgi yönetişimi ağırlaştıkça etkisi azalır. Kestirme yol arayışı başlar ve yine elinizde içi boş dokümanlar olur.</li></ol><p>Bu 3 tuzağın ortak paydası şudur; yönetişimi bir kontrol aracı olarak kurgulamak. Halbuki amaç kontrol etmekten değil <strong>sürekliliktir.</strong></p><p>Bu seriye bir soru ile başlamıştık. Ya kurumların asıl riski kullandıkları ürün değilde o ürün hakkında ki bilgileri ise? Beş yazı boyunca bu soruyu takip ettik. Sorunu tanımladık, haritasını çıkarttık, ölçtük, harekete geçtik ve son olarak da çözümün kalıcı olması adına yolu belirledik.</p><p>Vardığımız yer ilk yazıda söylediğimiz cümlenin ta kendisi oldu:</p><p>Kurumsal Mimari’nin görevi yalnızca teknoloji standartları belirlemek değildir. Asıl görevi teknoloji bilgisinin kurumsallaşmasını sağlamaktır. Çünkü teknoloji değişir, vendor değişir, ürünler değişir, çalışanlar değişir, mimari yaklaşımlar değişir ancak kurumsal bilgi kaybedildiğinde yerine koymak yıllar alır.</p><blockquote><strong>Ve gerçek teknolojik bağımsızlık ürün sahipliğiyle değil bilgi sahipliğiyle başlar</strong></blockquote><p>Bu seriyi okuduktan sonra yapılacak yüzlerce şeyin olduğunu fark etmişsinizdir. Ama en değerlisi ve ilk yapmanızı tavsiye edeceğim şey ilk fırsatta en kritik sisteminizi seçin.</p><p>KOM matrisini doldurun. Beş katmanın her biri için mevcut seviyenizi dürüstçe işaretleyin. Sonuç sizi rahatsız ederse doğru yerdesiniz demektir. Çünkü bilgi sahipliği yolculuğu bir projeyle değil dürüst bir tespitle başlar.</p><p>Bu beş yazı boyunca beni takip edip okuduğunuz ve geri bildirim verdiğiniz için teşekkür ederim.</p><p>Bu seriyi yazarken amacım hazır bir reçete sunmak değildi. Kurumsal teknoloji dünyasında yetirince konuşulmadığını düşündüğüm bir riski görünür kılmak ve tartışmaya açmaktı.</p><p>Kendi kurumunuzda ki deneyimlerinizi, itirazlarınızı ve farklı bakış açılarınızı duymak beni ayrıca mutlu eder.</p><p><strong>Seri:</strong></p><ol><li><a href="https://medium.com/@omurucum/vendor-lock-in-de%C4%9Fil-knowledge-lock-in-248cdea45b72"><strong>Vendor Lock-in Değil, Knowledge Lock-in</strong></a></li><li><a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0"><strong>Knowledge Ownership Model: Bilgi Gerçekten Kimin?</strong></a></li><li><a href="https://medium.com/@omurucum/knowledge-lock-in-nas%C4%B1l-%C3%B6l%C3%A7%C3%BCl%C3%BCr-075fd8f1cc38"><strong>Knowledge Lock-in Nasıl Ölçülür?</strong></a></li><li><a href="https://medium.com/@omurucum/bilgiyi-geri-kazanma-playbooku-bbbe5162ad53"><strong>Bilgiyi Geri Kazanma Playbook’u</strong></a></li><li><strong>Kurumsal Mimarinin Asıl Görevi</strong></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=871636519a9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bilgiyi Geri Kazanma Playbook’u]]></title>
            <link>https://medium.com/@omurucum/bilgiyi-geri-kazanma-playbooku-bbbe5162ad53?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/bbbe5162ad53</guid>
            <category><![CDATA[togaf]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[dijital-dönüşüm]]></category>
            <category><![CDATA[knowledge-lock-in]]></category>
            <category><![CDATA[kom]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 16:22:26 GMT</pubDate>
            <atom:updated>2026-07-24T18:10:39.695Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>İyi şeyler inandığında, daha iyi şeyler sabrettiğinde ve en iyi şeyler ise hiç vazgeçmediğinde gelir!</strong></blockquote><p>Knowledge Lock-in Serisi — 4</p><p>Şuana kadar yaptığımız yolculukta üç aşamadan geçtik. Önce sorunu tanımladık: <a href="https://medium.com/@omurucum/vendor-lock-in-de%C4%9Fil-knowledge-lock-in-248cdea45b72"><strong>Knowledge Lock-in</strong></a>.</p><p>Sonra bir harita çıkarttık ve adına <a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0"><strong>KOM</strong></a> yani Knowledge Ownership Model dedik. Bu haritayı kullanarak ölçüm yapıp bir öz değerlendirme de bulunduk: <a href="https://medium.com/@omurucum/knowledge-lock-in-nas%C4%B1l-%C3%B6l%C3%A7%C3%BCl%C3%BCr-075fd8f1cc38"><strong>Knowledge Lock-in Nasıl Ölçülür?</strong></a></p><p>Peki ölçümü yaptıktan sonra sonucun pekte iç açıcı olmadığını fark ettiğimiz de ne yapacağız? Önce panik yapmayacaksınız :) Direk kötü haber ile başlayayım;</p><blockquote><strong>Kaybedilen bilgiyi geri satın alamazsınız. Bir bütçe kalemiyle, bir sözleşme maddesiyle ya da bir haftalık eğitimle geri gelmez!</strong></blockquote><p>Ama bir de iyi haber var. Yeniden üretebiliriz. Bunun içinde yeni bir proje beklemenize gerek yok. Mevcut çalıştığınız vendor aslında bilgiyi geri kazanmanızı sağlayacak en ideal çalışma ortamıdır.</p><p>Peki bu ideal çalışma ortamından nasıl faydalanmak gerekiyor. Tek bir yöntemi olmayan bu çözümü dört farklı katmanda ele aldım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fEQHHD3o1J-2-zhuVzTCCg.png" /><figcaption>Bilgiyi Geri Kazanma Playbook’u</figcaption></figure><p>Sözleşme, Çalışma Biçimi, Kurumsal Hafıza ve tabi ki İnsan</p><p>Şunu da unutmamak gerekiyor. Bu bir sihirli değnek değil. Knowledge Lock-in yıllar içinde birikti ve geri gelmesi de zaman alacak. Ama yön belli olduğunda mesafe kısalır!</p><p>Şimdi bu katmanları teker teker detaylandıralım.</p><h4><strong>1. Katman: Sözleşme</strong></h4><p>Genelde üzerinde en çok durulduğu sanılan en az konuşulan fakat en etkili ve önemli olandır. Çoğu vendor sözleşmelerinde <strong>bilgi transferi </strong>bir cümledir. Genellikle yapılan toplantılarda “bilgi transferi/eğitim elbette yapılacaktır” denilir. Fakat bu kime, neyi, nasıl sorularına cevap vermeyen bir ifadedir. İyi niyetlidir fakat işe yaramaz. Çünkü ölçülebilir bir yükümlülük tanımlamaz. Bu katmanda yapılacak olan üç değişiklik büyük fark yaratır.</p><ul><li>Teslim edilebilir olarak “<strong>çalışan sistem</strong>” değil “<strong>çalışan sistem + onu sürdürebilen kurum ekibi”. </strong>Fark incedir fakat kritiktir. Çalışan sistem dendiğinde vendor sadece bir ürün teslim eder. Diğerinde ise <strong>yetkinlik</strong> almış olursunuz. Kabul kriteri de “<strong>sistem çalışıyor mu?</strong>” değil “<strong>kurum ekibi sistemi bağımsız devam ettirebiliyor mu?</strong>” olmalıdır.</li><li><strong>Dokümantasyon için gerçek bir kabul testi. </strong>Dokümantasyonun var olması yeterli olmaz. Asıl soru şudur; kurum ekibinden biri yalnızca bu dokümana bakarak süreçleri ilerletebiliyor mu? Dokümantasyonu vendor değil onu kullanacak olan ekip test etmelidir. Kullanılmayan doküman, olmayan dokümandır.</li><li><strong>Exit senaryosu maddesi. </strong>Sözleşmede “<strong>vendor yarın olmazsa ne olur?</strong>” sorusunun cevabı olmalıdır. Bu sadece bir madde değil düzenli bir tatbikattır. Kurum, ekibin vendor olmadan da sistemi belirli bir süre ayakta tutabildiğini düzenli olarak tatbik etmelidir. Yangın, deprem gibi doğal afetler nasıl gerçekmiş gibi tatbik edilmeye çalışılıyor ise buna da aynı önemin verilmesi gerekmektedir.</li></ul><blockquote><strong>Önemli:</strong> Bu maddeler satın alma ve hukuk süreçlerini doğrudan etkiler. Bu yüzden bunları sözleşmelere eklerken kendi hukuk ve satın alma ekiplerinizle birlikte tasarlamanızı öneririm. Bu fikirler bir başlangıç noktasıdır hazır bir sözleşme metni değildir.</blockquote><p>Almaca da çok güzel ve sevdiğim bir söz var;</p><blockquote><strong>Vertrauen ist gut kontrolle ist besser!</strong></blockquote><p>Yani güven önemlidir; ancak sadece söylenenlere veya başkalarının yaptıklarına dayanarak hareket etmemek gerekir. Gerektiğinde doğrulamak ve kontrol etmek her zaman sağlıklı bir yaklaşımdır.</p><h4>2. Katman: Çalışma Biçimi</h4><p>Peki bilgi nasıl elde edilir. Vendor çalışma yaparken izlemek bilginin geçmesine yeterli olur mu? Kısmen olabilir. Fakat asıl bilgi kazanımı uygulama ile olur. Vendor ilişkisini bu geçişi sağlayacak şekilde tasarlamak mümkündür.</p><p><strong>Shadowing -&gt; Pairing -&gt; Reverse pairing evrimi. </strong>Çoğu kurum shadowing aşamasında takılır. Vendor yapar kurum izler. İzlemek bilgi transferi <strong>değildir. </strong>Gerçek transfer üç aşamadan oluşur. Önce vendor yapar kurum izler (<strong>shadowing</strong>) sonra birlikte yapılır (<strong>pairing</strong>) ve en sonunda kurum yapar vendor izler ve sadece gerektiğinde müdahale eder (<strong>reverse pairing</strong>) Asıl bilgi son aşamada olur. İlk ikisi bu aşamaya gelmek için bir hazırlıktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QIGiqWVF3b_iJ1fxBELY0Q.png" /><figcaption>Sahdowing -&gt; pairing -&gt; reverse pairing</figcaption></figure><p><strong>Incident’larda “yolcu” değil “sürücü” olmak. </strong>Çalıştığım bir çok kurumda tecrübesi az olan arkadaşlar dev, test ortamlarında bile hata yapmaktan çekiniyorlar. Halbuki en kalıcı bilgi uygulayarak öğrenilen bilgidir. Bu ortamlarda edinilen tecrübe ile zamanla kurum çalışanı vendor’ın yolcu olduğu kontrollü bir şekilde sürücü tarafına geçmesine hazırlamak demektir.</p><p><strong>Her değişiklik için “neden” kaydı. </strong>Vendor bir değişiklik yaptığında kurum tarafında küçük bir kayıt tutulmalıdır. Ne, neden değişti? Bu ilerki bölümde değineceğim ADR pratiğinin günlük, düşük maliyetli halidir. Amaç mükemmel bir doküman elde etmekten ziyade karar gerekçelerinin kurumda kalmadır.</p><h4>3. Katman: Kurumsal Hafıza</h4><p>Alışkanlıklar ve disiplin yani çalışma biçimi bilgiyi kuruma taşır. Kurumsal hafıza ise onu kalıcı kılar.</p><p><strong>ADR pratiğini minimum maliyetle başlatmak. </strong>ADR kulağa ağır bir süreç gibi geliyor ama olması gereken tam tersidir. Bir şablon ve kural yeterlidir. Her önemli mimari karar için o kararı verirken 15 dakika ayırıp neyin neden seçildiğini hangi alternatiflerin değerlendirildiğini ve elendiklerini yazmanız yeterli olacaktır. Mükemmel olmasına gerek yok var olması yeterlidir.</p><p><strong>Runbookların incedent’lar sonrasında zorunlu güncellenmesi. </strong>Runbooklar yazıldıkları an eskimeye başlar. Onları canlı tutmanın tek yolu sürekli güncellemekten geçer. Incedent’ların kapanması yeterli olmaz. Runbookların güncellenmemiş olması gerekmektedir. Bunu disiplinli bir şekilde yapmak operasyonel bilginin zamanla kişilerden dokümanlara taşınmasını sağlar.</p><p><strong>Bilgi borcu kavramı. </strong>Yazılımda <strong>technical debt </strong>kavramını zaten biliyoruz. Proje başladığında hızlı ilerlemek adına ertelenen ve sonra faiziyle ödenen borçtur. Dokümante edilmeyen her karar, yapılmayan her bilgi transferi bir borçtur ve zamanla faiziyle birikir. Önerim bu borcu görünür kılmaktır. Tıpkı teknik borç gibi her sprint veya her çeyrekte bilinçli olarak task listesine eklenerek eritilmelidir. <strong>Görünmeyen borç ödenmez!</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KhSrgbgURifJYBoRtzd8JA.png" /><figcaption>Bilgi Borcu: Teknik borç gibidir. Bugün ertelenir yarın faiziyle ödenir!</figcaption></figure><h4><strong>4. Katman: İnsan</strong></h4><p>Belki de bu dört katman içerisinde ki en zorudur. Çünkü en az kontrol edilebilir olanıdır. Bilgi kişide kaldığı sürece kurumsallaşamaz. Bir sistemi yalnızca bir kişi biliyorsa o kişi ne kadar yetenekli olursa olsun bu bir güç değil risktir. KOM diliyle bu Seviye 1&#39;dir.</p><p><strong>Bilinçli rotasyon. </strong>Tek kişi bilir durumlarını kırmanın en etkili yolu bilgiyi taşıyan ikinci bir kişiyi bilinçli olarak yerleştirmektir. Bu ilk başlarda yavaşlık getirsede uzun vadede kurtarır. Tek uzmana sahip olmak konforlu gibi görünse de o konfor kırılgandır.</p><p><strong>İç eğitim ve bilgi paylaşımı. </strong>Bilginin kişiler arasında transferi için aksiyonların olması gerekmektedir. Bunlar; iç teknik sunumlar, birlikte kod/mimari inceleme oturumları, kurum içi yazılı paylaşım. Bu gibi aksiyonlar zaman kaybı gibi görünür ama aslında bilgi borcunu ödeyen etkinliklerdir.</p><p><strong>Bir gerçeği kabul etmek. </strong>İnsanlar farklıdır. En iyi mühendis bile bir gün başka bir yere gider. Bu bir ihtimal değil kesinliktir. Kurumsal hafıza tam da bu kesinliğe karşı bir sigortadır. Kişilere yatırım yapmak önemli ve gereklidir ama bilgiyi kişilere emanet etmek kurumsal hafıza açısından problemdir.</p><blockquote>Bu katmanda vurgalamak istediğim bir konu daha var. Bilgi yönetimi literatüründe <a href="https://en.wikipedia.org/wiki/Tacit_knowledge"><strong>tacit knowledge (örtük bilgi)</strong></a> adında bir tanım vardır. Kişinin deneyiminde yaşayan tam ifade edilemeyen bilgi olarak geçer. Önemli bir gerçek şudur; tacit bilginin bir kısmı doğası gereği dokümante edilemez. İşte bu yüzden insan katmanı dokümantasyonun alternatifi değil ulaşamadığı yerin tamamlayıcısıdır.</blockquote><p>Şimdiye kadar dört katmanı ve onlarca pratiği ele aldık. Ama unutmayalım ki hepsini aynı anda yapmaya çalışmak hiçbirini <strong>yapmamanın</strong> en kibar yoludur.</p><h4><strong>Peki Nereden Başlamalı?</strong></h4><p>Önceliklendirme için tavsiyem <a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0">KOM matrisine</a> geri dönün. Her sistemi iki eksende düşünün. Kritikliği yüksek ama sahiplik seviyesi düşük olan sistemler kırmızı bölgenizdir. İşte başlangıç yeri tamda burasıdır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w9O3uhkPe0sRAEWwDAwqOQ.png" /><figcaption>Nereden başlamalı</figcaption></figure><p>Bir ofis aracının bilgi Seviyesi 1 olabilir. Bu bir felaket değildir. Ancak gelir üreten, müşteriye dokunan veya regüle edilen bir sistemin operasyonel bilgi Seviyesi 1 ise tüm playbook’u önce oraya uygulayın. Bilgiyi geri kazanmak bir “<strong>bir bang</strong>” projesi değildir. Sabırlı olun ve en kritik sistemde en zayıf katmandan başlayın.</p><p>Kısacası;</p><ul><li>Knowledge Lock-in’den çıkış vendor’u koymakla olmaz aksine vendor’la çalışma biçimini değiştirmekle olur.</li><li>Sözleşme içerisinde ki küçük değişiklikler bilgi transferini bir dilekten çıkarıp yükümlülük haline getirebilir.</li><li>Çalışma biçiminde kurum içinde ki ekiplere sürücü olma fırsatını vermek izleyen bir ekipten uygulayan bir ekibe dönüşümün sağlayabilir.</li><li>Kurumsal hafıza bilginin kişilerden dokümanlara taşınmasını sağlayabilir.</li><li>Ve en önemlisi insan katmanı. Hiçbir sistemin tek bir kişiye bağlı kalmamasını sağlar.</li></ul><p>Bu maddelerin hiçbiri tek başına yeterli değildir. Ama beraber bilgiyi yeniden kuruma kazandırmakta harika birer takım oyuncusu olurlar.</p><p>Peki tüm bu pratikleri kim kontrol edecek kim sürdürecek? Bir sonra ki projede unutulup göz ardı edilmeyeceğini kim garanti edecek? İşte burada devreye yönetişim girmektedir. Çünkü artık konu basit bir playbook değildir. İşte serinin son yazısında da bu konuyu ele alacağım. Bu pratiklerin kişilere ve projelere bırakıldığında neden eridiğini ve kalıcılığın neden kurumsal mimari yönetişimine gömülmekten geçtiğini ele alacağım.</p><p>Sabırla okuyup zaman ayırdığınız için teşekkür ederim. Geri dönüşlerinin benim için değerlidir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bbbe5162ad53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Knowledge Lock-in Nasıl Ölçülür?]]></title>
            <link>https://medium.com/@omurucum/knowledge-lock-in-nas%C4%B1l-%C3%B6l%C3%A7%C3%BCl%C3%BCr-075fd8f1cc38?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/075fd8f1cc38</guid>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[togaf]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[itil]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 07:05:55 GMT</pubDate>
            <atom:updated>2026-07-24T08:25:39.494Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Karanlığın derinliğini bilmeyen, ne kadar muma ihtiyacı olduğunu da bilemez.</strong></blockquote><p>Knowledge Lock-in Serisi — 3</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZNofVwDMzHwR8h03hcNY1Q.png" /></figure><p>İlk iki yazıda sorunu tanımlayıp bu sorunun nasıl ölçülebileceğine yönelik bir haritanın tanımını yaptık. <a href="https://medium.com/@omurucum/vendor-lock-in-de%C4%9Fil-knowledge-lock-in-248cdea45b72">Knowledge Lock-in</a> ve <a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0">Knowledge Ownership Model</a> yazılarına göz atabilirsiniz.</p><p>Peki sırada ki adım ne? Modeli makul bulan bir yöneticinin soracağı ilk soru şu olacaktır; “Mevcut durumu nasıl ölçeceğiz?”. Çok yerinde ve haklı bir sorudur. Çünkü <strong>ölçülmeyen</strong> risk, <strong>yönetilmeyen</strong> risktir. Ancak burada önemli bir ayrım var. <strong>Knowledge Lock-in</strong> CPU, I/O vb. kullanımları ölçüp okuduğumuz bir dashboard değildir. Hem nicel hem de nitel göstergeleri bir arada dinlemeyi gerektirir. Bu yazıda her ikisine de değinmeye çalışacağım.</p><h4>Kitlenme Belirtileri Nasıl Anlaşılır</h4><p>Knowledge Lock-in’in en dürüst sinyalleri koridorlarda ki fısıltılarda gizlidir. Bunları ölçmek için öyle pahalı araçlara gerek yoktur. İyi bir dinleyici olmak yeterlidir.</p><p>1. Sinyal — “<strong>Bunu vendor’a soralım</strong>” frekansı. Bu cümle bir toplantıda bir kez geçebilir. Bu normaldir. Fakat aynı sistem hakkında her toplantıda tekrar ediyor ise artık bilgi kurumda değildir. Frekans arttıkça sahiplik düşer</p><p>2. Sinyal — “<strong>Incident’ta ilk aranan numara kimin?</strong>” Gece 02:30&#39;da alarm çaldığında ekibin ilk refleksi ne? Runbook’mu açıyor yoksa vendor’un acil destek hattını mı arıyor? Bu refleks, operasyonel bilginin nerede yaşadığının en dürüst tespitidir. Çünkü kriz anında kimse rol yapmaz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*isbhy02p8_EFSOIkJeQ2uA.png" /></figure><p>3. Sinyal — “<strong>Vendor toplantısında kurum tarafı soru mu soruyor, cevap mı veriyor</strong>” Eğer toplantılarda kurum çalışanları sürekli soru soran taraf ise bilgi asimetrisi vendor lehine demektir. Eğer kurum ekibi cevap veren, yönlendiren, hatta itiraz eden tarafsa bilgi sahipliği kurumdadır. Roller her iki yönde de işleyebilir. Önemli olan hangi yönde olduğunun farkında olmaktır.</p><p>4. Sinyal — “<strong>Yeni bir talep geldiğinde efor tahminini kim yapıyor</strong>” Bir iş birimi yeni bir gereksinim getirdiğinde efor tahminini kurum ekibi mi yapıyor yoksa “<strong>vendor’a sorup dönelim mi?</strong>” deniyor. Efor tahmini yapabilmek, sistemi yeterince bildiğinizin en pratik göstergesidir. Yapamıyorsanız, o sistemi bilmiyorsunuz demektir. Kullanıyor olmak bilmek anlamına gelmez!</p><p>Bu sinyallerin hiçbiri tek başına bir teşhis değildir. Ancak üç ya da dördü bir arada görünüyorsa <strong>Knowledge Lock-in</strong> artık bir olasılık değil mevcut bir durumdur.</p><p>Nitel sinyaller farkındalık yaratır, ancak yönetim kararlarını sayılar yönlendirir. Knowledge Lock-in sistemini ilk oluşturduğumda hangi metriklerin belirleyici olması gerektiği hakkında çok düşünüp istişare etme şansım oldu. Son noktada ise beş metriği kontrol edilmesini öneriyorum.</p><h4>Sayılarla Konuşmak</h4><p><strong>Bus factor ve vendor factor. </strong><a href="https://medium.com/kodcular/yaz%C4%B1l%C4%B1m-d%C3%BCnyas%C4%B1n%C4%B1n-g%C3%B6z-ard%C4%B1-edilen-riski-bus-factor-f2ca49de42dc">Bus factor</a> yazılım dünyasında bilinen bir kavramdır. Bir proje de kaç kişi “otobüsün altında kalırsa” proje durur? Ancak Knowledge Lock-in bağlamında ben buna bir boyut daha ekledim. Bu <strong>vendor factor. </strong>Belirli bir vendor ilişkisi sonra erdiğinde kaç sistem operasyonu risk altına girer? Bus factor kişi bazlı kırılganlığı, vendor factor ise tedarikçi bazlı kırılganlığı ölçer. İkisine birlikte bakıldığında bilgi yoğunlaşmasının nerede olduğu görünür hale gelir.</p><p><strong>ADR kapsama oranı. </strong>Architecture Decision Record çok havalı bir söylemi var. Mimari kararların neden alındığını kayıt altına alan kısa dokümanlardır. Metrik basit: kritik sistemlerdeki büyük mimari kararların yüzde kaçı bir ADR ile kayıtlı? Bu oran düşükse karar gerekçeleri katmanı (<a href="https://miro.medium.com/v2/resize:fit:1400/format:webp/1*H2vwGRiPmJCbUKPAwkE_Yg.png">KOM’un beşinci satırı</a>) büyük olasılıkla Seviye 0 veya Seviye 1&#39;dedir.</p><p><a href="https://medium.com/@umutt.akbulut/runbook-tasarlamadan-mimari-bitmez-%C3%BCretimde-sistemi-ayakta-tutan-operasyon-modeli-7969261da22e"><strong>Runbook</strong></a><strong> kapsama oranı. </strong>Operasayonel senaryoların yüzde kaçı kurum için bir <a href="https://medium.com/@umutt.akbulut/runbook-tasarlamadan-mimari-bitmez-%C3%BCretimde-sistemi-ayakta-tutan-operasyon-modeli-7969261da22e">runbook</a> ile dokümante edilmiş? Burada “var/yok” yetmez. Güncel ve kullanılabilir olması önemlidir. Altı ay önce yazılmış ve güncellenmemiş bir runbook olmayan bir runbook’tan sadece biraz daha iyidir.</p><p><strong>Bağımsız müdahale olayı. </strong>Son 12 ayın incident’larına bakıldığında yüzde kaçı vendor desteği olmadan çözülmüş? Bu metrik operasyonel bilgi katmanının (KOM’un 3. satırı) gerçek seviyesinin sayısal karşılığıdır. Oran yükse ise Seviye 3 veya üzeri, düşük ise başka şeylerin konuşulması gerekmektedir.</p><p><strong>Bilgi transferi yaşı. </strong>Son <strong>gerçek</strong> bilgi transferi toplantısı ne zaman yapıldı? “<strong>Gerçek</strong>” kelimesini özellikle bold yapıp vurguladım. Yapılan söyleşmelerde çoğu kurum bu maddenin varlığından bile haberdar olmayabilir. Sözleşmelerde var olan bu madde pratikte hiç gerçekleşmemiş bile olabilir. Bu metriğin yaşı arttıkça transferin etkinliği geometrik olarak düşer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DdRJiV4IM_PZyj9_gjSMLw.png" /><figcaption>Knowledge Lock-in Radar</figcaption></figure><p>Aşağıdaki soruları, yıllar içinde farklı kurumlarda edindiğim deneyime dayanarak hazırladım. Teorik bir kontrol listesi değil; sahada Knowledge Lock-in’in gerçekten nerede ortaya çıktığını görmüş biri olarak sorduğum sorular. Bu yüzden öz değerlendirmeyi çok daha isabetli kıldığına inanıyorum.</p><p><strong>On Soruluk Öz Değerlendirme</strong></p><ol><li>Bu sistemde bir incedent olduğunda ekibimiz vendor’ı aramadan müdahale edebilir mi?</li><li>Sistemin mimari kararlarını ve gerekçelerini anlatan güncel bir doküman var mı?</li><li>Entegrasyon kurallarında değişiklik yapmamız gerektiğinde bunu bağımsız bir şekilde yapabiliyor muyuz?</li><li>Konfigürasyon parametrelerinin neden mevcut değerlerinde olduğunu bilen birisi kurum içinde var mı?</li><li>Son 1 yılda bu sistem için vendor’dan bağımsız bir bilgi transferi oturumu yapıldı mı?</li><li>Vendor ilişkisi yarın sona erse sistemi altı ay içinde farklı bir ekiple sürdürebilir miyiz?</li><li>Yeni bir ekip üyesi bu sistemi mevcut dokümantasyon ile üç hafta içinde devralabilir mi?</li><li>Bu sistemle ilgili efor tahmini vendor’a danışılmadan yapılabilir mi?</li><li>Geçmişte bu sistem için değerlendirilen ama seçilmeyen alternatifler ve gerekçelerini biliyor muyuz?</li><li>Bu sisteme ait runbook’lar var mı en son ne zaman güncellendi?</li></ol><p>Eğer bu soruların 7 tanesi ve üzerinde “evet” diyebiliyorsan KOM’da Seviye 3 ve üzerindeyizdir. 4–6 arasında kısmı sahiplik söz konusudur. En zayıf halkanın bulunup düzenlemenin oradan yapılması gerekir. 3 ve altında ise ciddi Knowledge Lock-in riski var demektir. Bilgi büyük ölçünde vendor tarafındadır. 1–2 projeyle düzeltilebilecek bir yapıdan ziyade yapısal olarak ciddi değişimin olması gerektiğini gösterir.</p><p>Tabi bu ölçüm ve çıkarımların bir de tuzağı var. Bu “öz değerlendirme” çıktısı bir efor ölçme değildir. ADR oranı hedef haline gelir ise boş ADR’ler, runbook sayısı KPI olduğunda kullanılmayan runbooklar ortaya çıkar. Aslında bu durum bilindik bir yasadır. <a href="https://tr.wikipedia.org/wiki/Goodhart_yasas%C4%B1">Goodhart Yasası</a>; bir ölçüt hedefe dönüştüğünde ölçüt olmaktan çıkar demektedir. Metriklerin amacı <strong>tespit yapmaktır performans değerlendirme değildir.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cj-7J92vZ_Jr2KopRd2ziQ.png" /><figcaption>Knowledge Lock-in Ölçüm Tuzağı</figcaption></figure><blockquote><strong>Knowledge Lock-in’i ölçmenin amacı bir rapor üretmek değildir. hangi katmanda hangi seviyede olduğunuzu bilmek ve oradan hareket etmektir.</strong></blockquote><p>Sonuç olarak Knowledge Lock-in soyut bir endişe değildir. Doğru ve dürüst bir şekilde analiz edildiğinde ölçülebilen bir yapıdır. Peki ölçümleri yaptık metrikleri karşımıza aldığımızda sonucun kötü olduğunu gördüğümüz de ne yapacağız. Bir sonra ki yazıda bilgiyi geri kazanmak için yapılması gerekenleri anlatmaya çalışacağım. Sözleşmeden çalışma biçimine, dokümantasyondan insan yönetimine uzanan bir <strong>Knowledge Lock-in’den Çıkış Playbook’u</strong> sunacağum.</p><p>Buraya kadar okuyup zaman ayırdığınız için teşekkür ederim. Geri dönüşleriniz benim için değerledir.</p><p>Kaynaklar;</p><ol><li><a href="https://tr.wikipedia.org/wiki/Goodhart_yasas%C4%B1">Goodhart Yasası ile ilgili detaylı bilgi</a></li><li><a href="https://miro.medium.com/v2/resize:fit:1400/format:webp/1*H2vwGRiPmJCbUKPAwkE_Yg.png">KOM Haritası Görseli</a></li><li><a href="https://medium.com/@omurucum/vendor-lock-in-de%C4%9Fil-knowledge-lock-in-248cdea45b72">Vendor Lock-in Değil, Knowledge Lock-in</a></li><li><a href="https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0">Knowledge Ownership Model: Bilgi Gerçekten Kimin?</a></li><li><a href="https://medium.com/@erdemkosk">Erdem Köşk</a> tarafından yazılmış olan <a href="https://medium.com/kodcular/yaz%C4%B1l%C4%B1m-d%C3%BCnyas%C4%B1n%C4%B1n-g%C3%B6z-ard%C4%B1-edilen-riski-bus-factor-f2ca49de42dc">Bus Factor</a> yazısı</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=075fd8f1cc38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Knowledge Ownership Model: Bilgi Gerçekten Kimin?]]></title>
            <link>https://medium.com/@omurucum/knowledge-ownership-model-bilgi-ger%C3%A7ekten-kimin-9a36028ac7d0?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a36028ac7d0</guid>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[itil]]></category>
            <category><![CDATA[togaf]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 07:15:16 GMT</pubDate>
            <atom:updated>2026-07-24T08:25:16.471Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>Kökü sende olmayan hiçbir ağacın gölgesine güvenme. Rüzgar estiğinde sana sadece yaprakları kalır, meyvesi değil!</strong></blockquote><p>Knowledge Lock-in Serisi — 2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i0dT4m_qzZZCIk56SD4dMA.png" /><figcaption>Knowledge Ownership Model — KOM</figcaption></figure><p>Bir önce ki yazıda asıl sorunun ne olabileceğini yorumlamaya çalışıp farklı bir soru ile dikkatleri <strong>Knowlodge Lock-in</strong> tarafına çekmiştik. Peki bu bilgi dediğimiz şey tam olarak nedir? Bilgi bizde mi yoksa dışarıda mı sorusuna tam olaran Evet/Hayır cevabını vermemiz kolay değildir. İşte burada devreye sorunu parçalara bölmek ve her bir parçayı anlamlandırmak gerektiğini fark ettim. Bilgi tek parça değildir. Bu yazıda tam da bunu çözmeye çalışacağım: bilgiyi katmanlarına ayırmak, her katmanın sahiplik seviyesini tanımlamak ve tüm bunları tek bir haritada birleştirmek.</p><p>Bu haritanın adı: <strong>Knowledge Ownership Model (KOM)</strong></p><h4>Bilgi Tek Bir Parçadan Oluşmaz</h4><p>Çalıştığınız kurumda ki kritik bir uygulamayı düşünün. “Bu sistemin sorumluluğu bize mi ait, bu sistemde işi kim yapacak” sorusu sorulduğunda tartışmalar başlar. Kaynak kodu bizde diyen farklı bir katmandan yeni bir geliştirme ya da özelliğin kullanımı hakkında destek talep edildiğinde farklı bir katmandan bahsettiğimizi çoğu zaman fark etmeyiz.</p><p>Peki <strong>sistemi biliyorum</strong> dediğimiz de aslında neyi kast ediyoruz? KOM ile bildiğimizi söylediğimiz <strong>bilgi</strong>’nin katmanlarını derinlemesine inceleyeceğiz. Bir teknoloji hakkında ki bilgi beş farklı katmanda yaşar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y_haMn8dA7LJ0FMpRTWX8Q.png" /><figcaption>Bilginin Katmanları</figcaption></figure><p>Bu katmanlar; Mimari Bilgi, Entegrasyon Bilgisi, Operasyonel Bilgi, Konfigürasyon ve Tunning, Karar Gerekçeleri olarak gruplanır.</p><p><strong>Mimari Bilgi: </strong>Sistemin neden bu şekilde tasarlandığıdır. Hangi alternatifler değerlendirildi? Neden bu topoloji seçildi? Neden bu pattern? Bu katman kaybolduğunda kurum, kendi sisteminin <strong>arkeolojisini</strong> yapmak zorunda kalır.</p><p><strong>Entegrasyon Bilgisi: </strong>Sistemin nasıl yaşatıldığıdır. Incident geldiğinde ilk nereye bakılır? Restart sırası nedir? Hangi log hangi sorunun habercisidir? Bu bilgi çoğu zaman hiçbir dokümanda yazmaz; yaşanarak öğrenilir ve yaşayanla birlikte kurumdan çıkar.</p><p><strong>Konfigürasyon ve Tuning Bilgisi: </strong>Neden bu parametrelerdir. Thread pool neden 50? Timeout neden 30 saniye? Cache TTL neden bu değer? Bu katman genellikle <strong>çalışıyor, dokunma</strong> refleksiyle korunur ve arkasındaki gerekçe zamanla buharlaşır.</p><p><strong>Karar Gerekçeleri: </strong>Nelerin elendiği ve neden elendiğidir. Seçilmeyen alternatifler, denenip vazgeçilen yaklaşımlar, reddedilen teklifler. Bu katman belki de en kolay kaybedilen katmandır. Sonuç zaten ortadadır ve kimse tercih edilmeyenleri nedenleriyle saklama gereği duymaz. Oysa bir sonraki mimari kararın kalitesi geçmişte neyin neden elediğini bilmeye bağlıdır.</p><p>Bilgiyi katmanlarına ayırdığımıza göre artık bu katmanların sahipliklerini belirleyerek haritalandırma adımına geçebiliriz. KOM’un ikinci ekseni de bu kısmı 5 seviyede ele alır.</p><blockquote><strong>Her Katmanın Bir Sahiplik Seviyesi Vardır</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LeKEJzrCBxfbIjr6VQEgVA.png" /><figcaption>Sahiplik Seviyeleri Katmanları</figcaption></figure><p><strong>Seviye 0 Tüketici:</strong> Bilgi tamamen kurum dışındadır. Kurum sistemi kullanır ama nasıl çalıştığını bilmez.</p><p><strong>Seviye 1 Tercüman:</strong> Bilgi hala dışarıdadır, ancak kurum içinde tek bir kişi vendor ile kurum arasında köprü kurar. O kişi karar verici değildir sadece vendor ile kurum arasında bir köprü görevi görür. <em>“Onu bir Ahmet Bey bilir.”</em></p><p><strong>Seviye 2 Anlayan:</strong> Ekip sistemi anlıyor, mimariyi tarif edebiliyor, sorunu teşhis edebiliyor. Ancak bağımsız olarak değişiklik yapamıyor; bir şeyi değiştirmek için hala vendor’a ihtiyaç var.</p><p><strong>Seviye 3 Bağımsız:</strong> Ekip değişiklik yapabiliyor, incident’ı bağımsız çözebiliyor, yeni gereksinimi implemente edebiliyor. Vendor/Danışman hala danışılan bir kaynak olabilir ancak operasyonel bir bağımlılık yoktur.</p><p><strong>Seviye 4 Kurumsallaşmış:</strong> Bilgi kişiden bağımsızdır. Dokümante edilmiş, aktarılabilir durumdadır, ekip üyesi değişse bile bilgi kurumda kalır.</p><h3>KOM Matrisi: İki Ekseni Birleştirmek</h3><p>Artık elimizde hem bilginin katmanları hemde bu katmanların sahiplik seviyeleri vardır. Bundan sonra yapılması gereken bu iki eksini birleştirmektir.</p><p>Her satır bir bilgi katmanı, her sütun bir sahiplik seviyesi. Kritik bir sisteminizi seçip her katman için mevcut seviyenizi ve hedef seviyenizi işaretlediğinizde, bilgi sahipliğinizin durumunu görebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H2vwGRiPmJCbUKPAwkE_Yg.png" /><figcaption>KOM Matrisi</figcaption></figure><p>Bu matris üzerinde iki işaret kullanıyoruz. Bunlar; mevcut seviye ve hedef seviye. İkisi arasında ki mesafe o katmanda ki bilgi açığını gösterir. Peki yukarıda örnek bir senaryoya göre hazırlanmış matrisin seviye seviye açıklaması nedir?</p><p><strong>Mimari bilgi, Mevcut Seviye 1, Hedef Seviye 3:</strong> Platform yıllar önce kurulmuş, mimari kararları bilen tek kişi kurum tarafında bir teknik lider. O kişi ayrılırsa mimari bilgi tamamen kaybolur. Hedef, bu bilginin en az ekip seviyesinde anlaşılır ve bağımsız karar verilebilir olması.</p><p><strong>Entegrasyon bilgisi, Mevcut Seviye 2, Hedef Seviye 3:</strong> Ekip hangi servisin hangi servisi çağırdığını biliyor, mapping kurallarını okuyor. Ancak yeni bir entegrasyon eklemek veya mevcut bir kuralı değiştirmek için vendor’a danışmak zorunda. Hedef, bu işlemleri bağımsız yapabilmek.</p><p><strong>Operasyonel bilgi, Mevcut Seviye 1, Hedef Seviye 4:</strong> Incident geldiğinde ilk aranan numara vendor’un destek hattı. Kurumdaki tek kişi vendor ile iletişim kuruyor ama çözüm üretemiyor. Bu katman en kritik açık ve hedef operasyonel bilginin kişiden bağımsız doküman’larla desteklenmiş ve aktarılabilir olması.</p><p><strong>Konfigürasyon ve tuning, Mevcut Seviye 0, Hedef Seviye 3:</strong> Parametre değerleri vendor tarafından ayarlanmış, gerekçeleri hiçbir yerde kayıtlı değil. Kurum <strong>çalışıyorsa dokunma</strong> modunda. Hedef, parametrelerin nedenlerinin bilinmesi ve gerektiğinde bağımsız ayarlanabilmesi.</p><p><strong>Karar gerekçeleri Mevcut Seviye 1, Hedef Seviye 3:</strong> Platformun neden seçildiği, alternatiflerin neden elendiği tek bir kişinin hafızasında. O kişi ayrıldığında bir sonraki büyük mimari kararın kalitesi düşer çünkü geçmişte neyin neden denenip vazgeçildiğini bilen kimse kalmaz.</p><p>Tabi bu matriste hedefin her zaman 4 olması pek olası bir durum değildir. Her katmanın kendine özgü ihtiyaçları vardır. Seviye 4 bilginin iyi bir şekilde dokümante edilmesi, aktarılabilir olması ve kişilerden bağımsız yaşayabilmesi için en ideal seviye olsa bile bu çok ciddi bir yatırımdır.</p><p>Burada hedef seviye bilginin kritikliği ile orantılı olmalıdır. Bir ofis uygulamasında Seviye 2&#39;nin olması yeterli olabilecekken müşteriye dokunan, gelir üreten veya regüle edilen bir sistem için Seviye 3&#39;ün altı risk demektir.</p><p>KOM matrisi doldurmak aynı zamanda bu önceliklendirmeyi görünür kılmaktır. Hangi sistemde hangi katmanda ne kadar yatırım yapılacağını bilinçli bir şekilde belirlemek nihai hedef olmalıdır.</p><p>Artık bilgiyi katmanlarına ayırıp her katmanın sahiplik seviyesini belirledikten sonra bunları birleştirerek KOM matrisini oluşturduk.</p><p>Peki bu haritayı nasıl dolduracağız? Mevcut durumu nasıl ölçeceğiz? Bilgi sahipliğini <strong>hissediyorum </strong>yerine <strong>ölçüyorum </strong>diyebileceğimiz noktaya nasıl geleceğiz?</p><blockquote><strong>Bir kurumun bilgi sahipliğini ölçmenin ilk adımı, bilgiyi katmanlarına ayırmaktır. İkinci adımı ise her katmandaki seviyeyi dürüstçe kabul etmektir.</strong></blockquote><p>Bir sonraki yazıda bu soruları yanıtlayarak sürecin nasıl işlediğini beraber göreceğiz.</p><p>Zaman ayırıp okuduğunuz için teşekkür ederim.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a36028ac7d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vendor Lock-in Değil, Knowledge Lock-in]]></title>
            <link>https://medium.com/@omurucum/vendor-lock-in-de%C4%9Fil-knowledge-lock-in-248cdea45b72?source=rss-83aaab9dbc9c------2</link>
            <guid isPermaLink="false">https://medium.com/p/248cdea45b72</guid>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[itil]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[togaf]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <dc:creator><![CDATA[Ömür Uçum]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 14:19:13 GMT</pubDate>
            <atom:updated>2026-07-24T08:24:50.353Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>İyi şeyler inandığında, daha iyi şeyler sabrettiğinde ve en iyi şeyler ise hiç vazgeçmediğinde gelir!</strong></blockquote><p>Knowledge Lock-in Serisi — 1</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3kKnFdl5HO9UrAMHk4yzLA.png" /><figcaption>Kurum Sınırı ve Vendor’ın Yeri</figcaption></figure><p><a href="https://www.opengroup.org/togaf-standard-version-92-overview">TOGAF 9.2</a> ile <a href="https://www.opengroup.org/togaf">TOGAF 10</a> arasında ki yenilikleri ve bu yeniliklerin getirdiği esnekliği öğrenmeye çalıştığım bir dönemde kurumsal teknoloji dünyasında yıllardır konuştuğumuz <strong>Vendor Lock-in</strong> kayramının gerçekten bu kadar odaklanacak bir konu olup olmadığını düşünmeye başladım. Ya bu kavrama ayırdığımız odak aslında bize farklı bir sorunu görmemize engel oluyor ise? Ya kurumların asıl bağımlılığı kullandıkları ürünler değil de, o ürünler hakkındaki bilgi ise? İşte bu makaleyi yazmak istemem de ki asıl motivasyon bu sorular oldu. Tam olarak odağın nasıl paylaştırılması gerektiğine geçmeden önce şunu da belirtmekte fayda var; <strong>Teknoloji Satın Almak Yanlış Değildir. </strong>Bu yazı da her uygulamanın kurum içinde geliştirilmesi gerektiğine veya vendorların gereksiz olduğuna kanaat getirmek amacında değildir. Sorun teknoloji satın almak değildir. Asıl soru;</p><blockquote><strong>Teknolojiyi satın aldıktan sonra bilgi kimin elinde kalıyor?</strong></blockquote><h4>Satın Alınan Ürünler, Devredilen Kararlar</h4><p>Bir çok kurumda süreç aslında benzerlik gösteriyor. Önce ürün satın alınıyor sonra implementasyon için vendor devreye giriyor. Zamanla mimari kararlar bile vendorlar tarafından alınıp süreç devam ettiriliyor ve kurum içinde ki çalışanlardan şu cümleler duyulmaya başlanıyor;</p><blockquote>“Bunu vendor’a soralım.”</blockquote><blockquote>“Bu sistemi onlar daha iyi biliyor.”</blockquote><blockquote>“Bu değişikliği ancak onlar yapabilir. Kendi kurdukları sistemi en iyi onlar bilir.”</blockquote><p>İşte tamda burada teknoloji kurumun olsa bile bilgi kurumdan çıkmaya başlamış oluyor.</p><h4>Peki Vendor Lock-in Gerçekten En Büyük Risk mi?</h4><p>Vendor Lock-in önemli bir risktir. Ancak çoğu zaman görünen sonuçtur; asıl neden olmayabilir. Şöyle düşünelim; Ürün değişebilir, sözleşme feshedilebilir, platform göç edebilir. Peki yıllar içerisinde oluşmuş bilgi birikimi? Bunun bir migration aracı ya da fesih maddesi yoktur. Görev ya da iş değişikliği sırasında yapılan kısa süreli aktarımların ne kadar faydalı olduğu da zaten ayrı bir konudur. İşten ayrılmaya yeni bir iş planı oluşturmuş personelin bu aktarımı ne seviye de doğru ve eksiksiz yaptığı aktarımı alanın ise ne seviye de anladığı ve hangi tecrübelerden geçtiği ayrı bir konudur. İşte burada devreye <strong>Knowledge Lock-in </strong>tanımı devreye giriyor.</p><h4>Knowledge Lock-in Nedir?</h4><p>Bir kurum yıllardır kullandığı entegrasyon platformunu yenilemeye karar verir. Proje başlar başlamaz ilk soru gelir: “Bu routing kuralı neden böyle yazılmış?” Cevabı bilen kimse yoktur. Çünkü kuralı yazan vendor çalışanı 1–2 yıl önce ya başka projeye geçmiştir ya da işten ayrılmıştır. Alınan kararın gerekçesi hiçbir yerde kayıtlı değildir. Kurum kendi sisteminin yapısını dışardan satın almak zorunda kalır. İşte bu senaryonun devamında kurumlarda sıkça duyduğumuz o güzel cümle gelir:</p><blockquote><strong>“Bu işi farklı bir firmaya veremeyiz/vermeyelim”</strong></blockquote><blockquote>Neden?</blockquote><blockquote><strong>“Çünkü sistemi onlar kurdu en iyi onlar bilir.”</strong></blockquote><p>İlk başta bu durumda bir gariplik yok gibi gelir. Peki ya soruyu değiştirirsek farklı bir soru sorarsak:</p><blockquote><strong>“Neden sadece onlar biliyor?”</strong></blockquote><p>Eğer bir sistemi yalnız mevcut vendor sürdürebiliyorsa problem yeni vendor değildir. Problem, kurumun bilgi sahipliğini zaman içinde kaybetmiş olmasıdır. İşte gerçek bağımlılık ve kitlenme burada başlar.</p><p>Knowledge Lock-in tek bir projede bir anda oluşmaz. Her projede parça parça büyür. Bu parçalar;</p><ul><li>Dokümantsyon eksik kalır</li><li>Mimari kayıtlar kayıt altına alınmaz</li><li>Bilgi transferi ertelenir ya da eksik yapılır</li><li>Operasyon tamamen vendor tarafına bırakılır</li><li>Yeni projelerde yine aynı vendor tercih edilir</li></ul><p>Dikkat edilirse bu maddelerin hiçbiri tek başına bir karar değildir. Herhangi bir kurumda çalışan hiç bir çalışan “<strong>bilgiyi kurum dışına taşıyalım</strong>” demez. Her madde günün koşuluna göre haklı görünen önceliklendirmelerdir. Projenin teslim tarihi yaklaşmıştır, ekip çok yoğundur (her zaman yoğundur zaten) dokümantasyon en önemsiz görünen kısımdır ve “<strong>sonra</strong>” yazılacaktır. İşte Knowledge Lock-in’i sinsi yapan da tam olarak budur. Kötü bir kararın sonucunda oluşmamıştır. Küçük bir kar tanesi olarak başlayıp çığa dönüşür. Buda yıllara yayılan bir süreçtir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*91uPxmgQPK2hc2g-otbE0w.png" /><figcaption>Zamanla oluşan Knowledge Lock-in süreci</figcaption></figure><h4>Peki Kurumsal Mimari Açısından Bakıldığında</h4><p>KM’nin görevi yalnızca teknoloji standartları belirlemek değildir. Asıl görevi, teknoloji bilgisinin kurumsallaşmasını sağlamaktır. Çünkü teknoloji, vendor ya da ürün değişebilir. Ancak kurumsal bilgi kaybedildiğinde yerine koymak çoğu zaman yıllar alır.</p><p>Sonuç olarak artık tüm suçu vendorlara atmak yerine yönetici/sorumlu olarak çalıştığımız kurumlarda bilgi sahipliği fikrini daha sık dile getirmemiz gerekmektedir. Çünkü gerçek teknolojik bağımsızlık ürün sahipliğiyle değil <strong>bilgi sahipliğiyle </strong>başlar.</p><blockquote><strong>Bir kurumun en değerli teknolojik varlığı kullandığı ürünler değil, o ürünler hakkında sahip olduğu bilgidir.</strong></blockquote><p>Peki kurumlar bu riski nasıl ölçebilir. Bilgi gerçekten kurum içinde mi yoksa dışında mı yaşıyor nasıl tespit edilir. TOGAF sertifikasyon ve 9.2&#39;den 10.0 standartlarını/farklarını çalıştığım ve ITIL ile de harmanladığım zamanlarda fark ettiğim bir boşluktan yola çıkarak geliştirdiğim <strong>Knowledge Ownership Model (KOM)</strong> bu soruna çözüm olacaktır. Sektörel olarak kabul görmüş devasa standartların (TOGAF ve ITIL) pratik hayattaki kör noktalarını ya da kısıtlarını gidermek adına geliştirdiğim yeni bir sentez model/yaklaşım önerisidir.</p><p><strong>KOM</strong>’u anlattığım bir sonra ki yazımda görüşmek üzere. Geri dönüşleriniz benim için kıymetlidir. Zaman ayırıp okuduğunuz için teşekkür ederim.</p><p>Kaynaklar</p><ol><li><a href="https://www.opengroup.org/togaf-standard-version-92-overview">https://www.opengroup.org/togaf-standard-version-92-overview</a></li><li><a href="https://www.opengroup.org/togaf">https://www.opengroup.org/togaf</a></li><li><a href="https://www.itil.com/">https://www.itil.com/</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=248cdea45b72" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>