<?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 Tufan on Medium]]></title>
        <description><![CDATA[Stories by Tufan on Medium]]></description>
        <link>https://medium.com/@tufan?source=rss-5c25c77fce7a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*zKWYPfG30Dc_q9qM-NiRdg.jpeg</url>
            <title>Stories by Tufan on Medium</title>
            <link>https://medium.com/@tufan?source=rss-5c25c77fce7a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:34:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tufan/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[Sucuk Sattığını Bilenlerle AI Çağında Yol Yürümek]]></title>
            <link>https://medium.com/@tufan/sucuk-satt%C4%B1%C4%9F%C4%B1n%C4%B1-bilenlerle-ai-%C3%A7a%C4%9F%C4%B1nda-yol-y%C3%BCr%C3%BCmek-df4847818054?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/df4847818054</guid>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Fri, 04 Apr 2025 19:04:54 GMT</pubDate>
            <atom:updated>2025-07-30T08:43:28.138Z</atom:updated>
            <content:encoded><![CDATA[<h4>Bu yazı, hem bir içsel yüzleşme hem de bu farkındalığı yayma çabası. Sucuk satmak, ne yaptığının ve kime değer sunduğunun farkında olmak demek. Böyle insanların sayısı çok az. Yazının devamında AI çağında neden bu bilincin daha da önemli hale geldiğini anlatmaya çalışırken, yaşadığım ufak bir aydınlanmayı aktaracağım.</h4><p>17 yıllık profesyonel hayatımda birçok projede, farklı dillerle ve farklı milletlerden insanlarla çalıştım. Hayatımın son 3 yılında ise çalıştığım işlerde, ekiplerde ve insanların yaklaşımında bir şeylerin değişmesi gerektiğini daha net görmeye başladım. Özellikle bir gerçek fark ettim: Ne yazık ki ekipteki kimse “biz sucuk satıyoruz” bilincinde değildi.</p><h3>Yazılım ve Bilginin Değişen Değeri</h3><p>Yazılıma profesyonel olarak başladığım ilk yıllardan beri “geleceğin mesleği” söyleminden rahatsız oldum. Bu iş geleceğin değil, bugünün işiydi. Ancak ülkemizde yazılım bir meslekten çok bir persona, bir kimlik olarak görülüyor. “Yazılımcı” olmak neredeyse özel zekayla eşleştiriliyor. Benim tecrübe ettiğim ekiplerdeyse bırakın özel zekayı, vasat zekaya sahip yazılımcılar bile azdı. Yazılımcı enflasyonunun sebebinin de bu olduğunu düşünüyorum. Eskiden doktor yapmaya çalıştıkları çocukları son yıllarda yazılımcı yapmaya çalıştılar.</p><p>Bir diğer konu da bilgiye olan inancımın değişmesi. “Bilgi güçtür” sözüne çok inanırdım ama artık inanmıyorum. Arama motorlarının icadı ile birlikte bilgiye erişim kolaylaştı, bilgi değer kaybetmeye başladı. AI ile bu süreç daha da hızlandı. Artık herkesin ulaşabildiği bir şey değerli değil.</p><h3>Aydınlanma ve Dersler</h3><p>Onlarca başarısız girişimim oldu, henüz “başarılı” sayılabilecek bir şey başarmadım. Ama şu sıralar geleceği parlak bir proje üzerinde çalışıyorum ve belki ileride onun hikayesini anlatırken bu yazıya dönerim. Bu projeyi geliştirirken geçirdiğim 3 yıllık bir farkına varma süreci var. Bu süreçte rahmetli babamın iki sözü sık sık aklıma gelir oldu:</p><blockquote><em>“Parayla yapılan işler bu dünyanın en kolay işleridir oğlum. Parayla ya da parasıyla yanında olan insan, yüreğiyle yanında olan insan kadar değerli değildir.” Buradaki </em>yürekle yanında olmak,<em> ne yaptığının farkında olmak ve hedefin ne olduğunu bilmek, ortak vizyonu paylaşmak. Zor olan bu ortağı, bu yol arkadaşını bulmaktır.</em></blockquote><p>Ve bir diğeri, 24 yaşımda ortağım tarafından dolandırıldığımda söylemişti:</p><blockquote><em>“Bu senin için çok büyük bir şans oldu. Erken yaşta öğrenmek büyük avantaj.”</em></blockquote><p>Gerçekten de o sıkıntılar, bazı şeyleri idrak etmemi sağladı. Yol arkadaşı bulmak bu dünyanın en zor işi.</p><h3>Sucuk Satmak Ne Demek?</h3><p>Geçmişte yaptığım işleri değerlendirdiğimde, birçok şey tamamdı: iyi yazılımcılar, yaratıcı tasarımcılar, yetenekli reklamcılar, finans bilenler… Ama bir şey eksikti: Sucuk sattığının farkında olan bir ekip arkadaşım hiç olmamıştı. Yani ne sattığının, ne iş yaptığının, kimin problemini çözdüğünün, ne ürettiğinin farkında değildi.</p><h3>AI Çağında Kod Yazmanın Kıymeti</h3><p>AI ile birlikte kod yazan amelelerle, ne sattığının farkında olan insanlar arasındaki fark daha da keskin hale geldi. Kod yazmak artık AI’ye bırakılabilir. Ama hangi problemi çözeceğini, hangi değeri sunacağını AI bilemez.</p><p>Kod bilgisinin değeri de aynı bilgi gibi eriyor:</p><blockquote><em>GitHub Copilot gibi araçlarla orta seviye yazılımcıların işi kolaylaştı, hatta bazılarını gereksiz kıldı.</em></blockquote><h3>Yani</h3><p>Arada bir ekibinize sorun: “Ne iş yapıyorsun?” Eğer size sadece kullandığı kütüphaneleri, yazdığı kodları anlatıyorsa… onun yerine bir AI Agent edinin. Ama size çözdüğü problemleri, müşterilere sunduğu kolaylıkları, aldığı keyfi anlatıyorsa, onunla yol yürümeye devam edin, yani yüreğiyle yanınızda olanlarla.</p><p>Ne iş yaptığının farkında olmayan insanlara vizyon aktarmaya çalışırken aklıma sürekli bu video geliyor:</p><p><a href="https://www.youtube.com/watch?v=nhumx8Ii5qs">https://www.youtube.com/watch?v=nhumx8Ii5qs</a></p><p>Eğlenceli bir video, izlemenizi tavsiye ederim.</p><p>AI çağında kod yazan ‘ameleler’ ile sucuk sattığının farkında olanlar arasındaki uçurum büyüyor. Kod bilgisi artık bir fark yaratmıyor; asıl mesele, müşteriye ne sunduğunu bilmek ve o değeri yaratabilmek. Şimdi sıra bizde: Ne sattığımızı fark edip, AI’yi bir araç olarak kullanarak geleceği bugünden inşa edelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PQxdHRlqD4kBokdFnod0xw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df4847818054" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Decade of Growth, Three Projects, One Team]]></title>
            <link>https://medium.com/@tufan/a-decade-of-growth-three-projects-one-team-462932339679?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/462932339679</guid>
            <category><![CDATA[solana-network]]></category>
            <category><![CDATA[depin]]></category>
            <category><![CDATA[uprock]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Fri, 29 Mar 2024 12:11:49 GMT</pubDate>
            <atom:updated>2024-03-29T12:11:49.255Z</atom:updated>
            <content:encoded><![CDATA[<p>A Decade of Growth, Three Projects, One Team</p><p>In October 2013, my journey as a developer took an unexpected turn when I received an email from Christopher regarding my repository, php-apk-parser. Little did I know that this encounter would mark the beginning of a remarkable chapter in my career. Alongside Chris, Jen, and Jesse, I ventured into the world of microservices, PHP, and FFMPEG, creating an encoding queue managed by PHP. This collaboration fundamentally changed my perspective — I learned, made mistakes, and led different aspects of our projects. Every day brought new lessons, both technical and business-related, and I cherished being part of such an inspiring team. While our apk parser project may not have gained widespread recognition, I was grateful to walk the path of the next ten years with the same incredible team.</p><p>With our collective experiences in managing complex app backends, we transitioned to building a golang backend for fully encrypted mobile browsers — the Tenta Browser. This project, aimed at creating a decentralized VPN browser, represented another challenge for our team. Despite the eventual acquisition by Avast and the transformation into Avast Secure Browser, our shared passion for startup life and innovation remained unyielding. While corporate life may have seemed dull, the spirit of creation and exploration kept us going.</p><p>Then came UpRock — a project that felt like the perfect match for our team. Combining blockchain technology, decentralized apps, and mobile distribution, UpRock embodied our shared vision of pushing boundaries and making an impact. As a Hardwareless DePIN with a rapidly growing user base, UpRock aimed to provide a multitude of services, including proxies and data for AI. The thrill of being part of such a groundbreaking journey from the very beginning was indescribable.</p><p>While the road ahead may be challenging, I am confident in our team’s ability to overcome obstacles and achieve greatness once again.</p><p>Reflecting on the past decade, I am filled with gratitude for the opportunity to learn, grow, and create alongside such talented individuals. Same team, ten-plus years, three projects — a testament to the power of collaboration, resilience, and the unwavering pursuit of innovation. As we look towards the future, I am excited to see where our collective journey will take us next.</p><p>I will share more soon</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=462932339679" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RAFT Consensus Algoritması]]></title>
            <link>https://medium.com/@tufan/raft-consensus-algoritmas%C4%B1-ebc96461eda0?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebc96461eda0</guid>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[raft]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Sun, 26 Jul 2020 10:44:54 GMT</pubDate>
            <atom:updated>2020-07-26T10:45:37.849Z</atom:updated>
            <content:encoded><![CDATA[<h4>RAFT, dağıtık sistemlerde son zamanlarda çokça kullanılan, anlaşılması kolay ve iyi tasarlanmış bir replikasyon algoritmasıdır.</h4><h4><strong>Consensus (Uzlaşı) Nedir?</strong></h4><p>Kelime anlamından başlamak gerekirse, dağıtık sistemlerde belli bir veri/durum (state) üzerinde sunucuların uzlaşmasına deniyor. Verilerin tutarlılığı demek, kopyalarını sakladığımız sunucular üzerinde aynı veriye sahip olmak demektir değil mi? En basit örneği ile; 1 master, 1 slave veritabanımız varken, master ile slavein binloglarının eşit olduğu an, consensusun sağlandığı andır.</p><h4>Dağıtık Sistemlerde Uzlaşı Problemleri</h4><p>Öncelikle consensus probleminin ve fault-tolerant ihtiyacının nereden geldiğine bakalım. Dağıtık sistemlerin problemlerini çözemeyeceğiz. Yani güç kaynağının, ağ iletişiminin ya da yazılımsal olarak sunucumuzun ayakta olma garantisini asla veremeyeceğiz. Onlarla yaşamayı öğreniyoruz ve onları uygulamalarımıza ya da kullanıcılarımıza yansıtmamaya çalışıyoruz. Yani bu durumda sunucuları ayakta tutmayla uğraşmak yerine hizmetin devamının garantisinin derdindeyiz. Bu da birden fazla sunucunun tek işi yapabilecek duruma gelebilmesi için iyi bir senkronizasyon ihtiyacı doğuruyor. İşte Consensus algoritmaları burada devreye giriyor. Biz bu algoritmalardan biri olan RAFT’ı inceleyeceğiz.</p><h3>RAFT Nasıl Çalışır?</h3><p>RAFT, veri üzerinde uzlaşıyı log replikasyonu ile yapar. Yani, sunucular aynı loglara sahip olmak zorundadır. Bu loglar verinin değişimiyle ilgili loglar tabi ki. Clusterdaki sunucuların 3 durumu olabilir; Master(Leader), Follower, Candidate. Master, istemcinin (uygulamanızın) muhatap olacağı sunucudur, tüm followerlara düzenli olarak ayakta olduğunu bildirmek zorundadır ve tümüne veri üzerindeki değişiklikle ilgili bilgi vermek zorundadır. Follower masterdan direkt komut alarak verilerini güncelleyen yedek sunucudur. Master’dan ayrıca düzenli ping bekler. Candidate ise follower sunucunun master’dan belli bir süre ping alamadığında, master olmak için geçtiği durumdur.</p><p>Bu üç durumu biraz da başlangıç, çalışma ve fault anına göre inceleyelim sonra tek tek detaylandıracağız.</p><p>Başlangıçta tüm sunucular follower olarak başlar ve bir masterın ping yollamasıni bekler. Yani biz bir cluster başlattığımızda tüm sunucular ortada master varmış gibi bekler. Beli bir süre masterdan bilgi alınmayınca bir ya da birkaç sunucu candidate durumuna geçer ve master olmak için <strong>bildiği</strong> tüm sunuculara haber yollar. Buna election deniyor. Yani oylama başlıyor. Haber yolladığı sunucular henüz Candidate durumuna geçmemişlerse ona bir kabul oyu yollar. Kendileri de adaysa oyu kendilerine verirler. Ve <strong>çoğunluk </strong>(sunucu sayisi / 2 +1)<strong> </strong>oyu alan master olur. Geri kalan tüm sunucular follower durumuna geçerler ve seçilen masterın düzenli bir şekilde onlara ayakta olduğunun bilgisini vermesini beklerler aksi halde bu işlem tekrar başlar. Burada sizin de okurken anlayacağınız gibi 1den fazla aday olması durumunda işler biraz karışabiliyor ama bu da çok basit şekilde çözülmüş; ön tanımlı gelen bir timeout aralığı var (masterdan ping bekleme süresi) bu aralıkta bir süreyi her sunucu kendisi random seçiyor. Genelde 150ms–300ms arasında bir süreyi her sunucu random seçtiğinde bunların farklı zamanlarda timeout olması sağlanır. Buna rağmen 1den fazla aday olabilir, bu durumda, sunucu sayınıza göre çoğunluk oy almak mümkünse ve adaylardan birinin diğerleriyle iletişimi daha hızlıysa bu seçim sağlanır, bu mümkün değilse tekrar timeouta düşecekleri için yeni bir seçim yapılır, sunucu sayısının tek sayı olması bu yüzden tavsiye edilir, eğer değilse, aynı anda 2 aday olduğunda ikinci bir timeout beklenir.</p><p>O halde, gelin 1 adet RAFT consensus algoritması ile hizmet veren database cluster tasarlamaya çalışalım. (3 node hizmet versin) ve bunu adım adım RAFT’i anlayarak tasarlayalım. Ayrı ayrı durumlarda Raft ne yapmalı ya da ne yapar buna bakalım.</p><p>Sunucu durumlarını aşağıdaki renkleri kullanarak belirteceğim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/491/1*vZ1acqclIWvs66P1p5HYOA.png" /></figure><p>Veritabanımız bir key value database olsun. Yani yapı olarak basit veriler tutalım. 3 sunucumuzu başlattığımızda aşağıdaki gibiyiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/593/1*OtC9vGyKvWYH_fk79yHTLA.png" /></figure><p>Bu durumda, tüm sunucular başladığında kendilerine bir timeout süresi belirledirler. Masterdan cevap bekliyorlar. Ortada master olmadığından aşağidaki duruma geçeçeğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*DFjovl7jyS9A2ELBOwa_Bg.png" /></figure><p>Timeout süresi en kısa olan S2 aday durumuna geçti bile. Şimdi kendisine bir oy verip diğer sunuculardan oy isteyecek. Yani şöyle bir oy işleminden sonra master durumuna geçecek;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/869/1*48Y2NMBRz7f_Bp97ht_ZUA.png" /></figure><p>Oylarını verdiler ve yeni bir timeout süresi başlattılar. Bu süre içinde master’ın onlara ping yollamasını bekliyorlar. Tabi bununla beraber varsa veri güncellemelerini de.</p><p>Şimdi işin içine 1 adet client koyalım. O da master ile iletişime geçsin ve veri güncellesin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QpAWi0lWa8OV0XpZpvpbTA.png" /></figure><p>Şu an 3 sunucumuzda da 1 adet işlem var. Loglar eşit, veriler eşit. Buna <strong>logindex</strong> diyelim ve bu her sunucunun işlediği komut sayısı olsun. Şu an hepsi için 1. Bu önemli bir detay, çünkü master’a işlenen veriler ancak çoğunluk tarafından alınırsa <strong>commited </strong>sayılmalı, yani bir veriyi sadece masterın alması yetmiyor, (sunucu sayısı/2 +1) kadarının o veriyi işlemiş olması gerekiyor. Bir sonraki seçimler artık <strong>logindex+1</strong> oy ile başlayacak ve log sayısı olarak en önde olan seçime önde başlayacak. Bu, veri olarak ya da log olarak geride kalmış bir kopyamızın master olmasını engelleyecek.</p><p>Şimdi, bir kayıt daha ekleyip s3&#39;ü geride bırakalım ve tekrar bir seçim yaptıralım. Bu durumda S3 ile S2 arasında bir baglanti kopuklugu oldugunu varsayiyoruz ve aşağidaki gibi bir durum ortaya çıkıyor</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DxUZzxwwNOZ_9Y7igAlDww.png" /></figure><p>Bu durumda, s2 ve s1 için LogIndex=2 iken, s3 için LogIndex=1. s3 sunucusu bu durumda master’dan da haber alamayacağı için kendisi aday durumuna geçecek ve network probleminin çözüldüğünü düşünürsek, oy isteyecektir. Hatta bu durumda tüm node’ları tekrar ayağa kaldırdımızı düşünelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RLp38ErOiSYMBvjRq5TOhQ.png" /></figure><p>Bu durumda, s3 hepsinden önce timeout olmuş ve oy istemiş varsayarsak, s1 ve s2 oy vermeyi reddedecektir, çünkü veri olarak daha ilerdeler. Yeni bir timeout süresi beklenecektir. Böylelikle, yeni master seçimi, network problemleri ve veri tutarsızlığını uygulamamıza yansıtmadan “aramızda” çözmüş olduk.</p><p>Distributed systems problemleriyle ilgili her konu açıldığında şu güzel yazı ve bu cümlesi gelir aklıma okumanızı tavsiye ederim;</p><blockquote>You can’t avoid the CAP theorem, but you can isolate its complexity and prevent it from sabotaging your ability to reason about your systems.<br><a href="http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html">http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebc96461eda0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Zero Allocation Hashing]]></title>
            <link>https://medium.com/@tufan/zero-allocation-hashing-3082edda443d?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/3082edda443d</guid>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Wed, 29 Apr 2020 13:40:38 GMT</pubDate>
            <atom:updated>2020-04-29T13:51:57.418Z</atom:updated>
            <content:encoded><![CDATA[<p>I have been playing with a <a href="https://github.com/tufanbarisyildirim/balancer">balancer machine</a> for a few days. I wanted to optimize deciding machine for each policy it supports (roundrobin, consistent hashing, least time, least connection etc..) All best practices worked fine and I see them in benchmark results. But, I saw that I can’t get rid off a few bytes of allocation from consistent hashing. I have checked golang source gode to see what happens there. I see that there is a small allocation <a href="https://github.com/golang/go/blob/07d9ea64abf9f98c525155f4f22776512d4d835d/src/hash/fnv/fnv.go#L44">here</a>.</p><p>Since it is a function that can be inlined easily, I did it and rewrote the hash32a function like;</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/51c9e01f722179edb8274b05fff5bd20/href">https://medium.com/media/51c9e01f722179edb8274b05fff5bd20/href</a></iframe><p>It dramatically increased the performance by almost 60% and we got rid of any allocation.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2e4309d3a2f8967da3c378fd009775d/href">https://medium.com/media/f2e4309d3a2f8967da3c378fd009775d/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3082edda443d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Distributing a Messaging Queue]]></title>
            <link>https://medium.com/@tufan/distributing-a-messaging-queue-b0572779c1b9?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0572779c1b9</guid>
            <category><![CDATA[queue-management]]></category>
            <category><![CDATA[scaling-microservices]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[microservice-architecture]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Tue, 28 Apr 2020 15:16:13 GMT</pubDate>
            <atom:updated>2023-04-02T21:02:01.458Z</atom:updated>
            <content:encoded><![CDATA[<p>Messaging queues are very important for any app that does heavy tasks need to be done in background. We prefer posting tasks to a queue and having one or more workers to get them done. This helps to scale our apps by having multiple workers that can do same type of jobs asynchronously. Like any other thing in distributed systems, having multiple workers or multiple queues comes with some problems. In this post, I would like to share a few advice about distributing large topics of messages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uDPT-WHYBY2IiY3x_IFSTg.png" /><figcaption>Simple, 1 app(producer) 1 queue(broker) and 1 worker (consumer)</figcaption></figure><p>At the beginning, most of apps start with one simple app which produces jobs, one queue which holds messages and one worker which consumes messages from that queue. Some great messaging tools help us here like kafka, nsq, rabbitmq, sns, redis etc. Also, the more we talk about microservices the more messaging is getting important to make services talking each other asynchronously. The basic idea here is to keep messages (jobs) somewhere else that any consumer can reach and do what we need. So, pub/sub mechanism and microservices communication could be another post. Let’s talk about heavy(mostly) background jobs and more of computation, not messaging.</p><p>The problem starts when our messages or background jobs are too big for 1 server. Maybe your messages are too big, or you are producing and consuming messages too fast for 1 server. Besides all these, computers may get down, right? You add more servers to increase your availability or delivery rate. So, let’s say you have version 1.0 of your messaging and queue system in previous graph. What about v2.0? It would probably be something like;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7mgRVXUZkkRGe5DXcY39gQ.png" /><figcaption>1 distributed app or multiple apps, multiple brokers, multiple consumers.</figcaption></figure><p>This sounds like a correctly scaled messaging system. Although, whilst distributing it, the problem starts and we lose consistency and message ordering here.</p><blockquote>With multiple consumers, order of processing cannot be guaranteed anymore</blockquote><p>As shown in example above, Job4 is processed before Job3. Think that the same type of Jobs (blue ones) need to be done in the order we produce them. Let’s say, we have an application from audiences and we need to pick the first N of them or we have a location reporter IOT device that sends its own location. If we have some lazy workers and we process an old location after some time we get a new location which gives us an inconsistent latest location somewhere.</p><p>One of message ordering problem solvers is having consistent brokers and workers for some type of our jobs (topics). Like;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lQBITDFbFbjI2nBLnQ4dXg.png" /><figcaption>multiple producers, multiple brokers, multipe consumers but with a guaranteed order</figcaption></figure><p>Keeping topics on different brokers(queues) would help you to scale a bit. But, still, we need a better scaling, like what if we have 1 topic that is too big for 1 computer? Here, what helps us is topic partitioning. When we partition the topics we need one consistent identifier that can say which broker we should pass through. What we need to do is hashing them consistently and decide which broker we should go on. So, final messaging queue should look like;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bo8Ptu5IUlIuEKKICOgUwA.png" /></figure><p>We use any simple <a href="https://en.wikipedia.org/wiki/Consistent_hashing">consistent hashing </a>algorithm to send same jobs in same buckets (like, same user, or same ip address or same customer whatever) Think that J1 and J2 are different sets of jobs (messages) that need to be in the same order we produce. So, we send all J1.x to the same broker. Solved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HAlsTBmiDyCbLAk0SPhaVg.jpeg" /><figcaption>broker := brokerPool[ hash( userId ) % len(brokerPool) ]</figcaption></figure><p>Distributing a system especially distributing a messaging queue is not just spreading jobs to workers like we do for pull-only http services when we have some jobs that their orders matter. Consistent hashing which is used by the most popular distributed databases, balancers, etc. — helps us a lot to always find the same and correct broker to send our messages on.</p><p>Hope you liked it.</p><p>In my next blog, I am willing to write about monitoring a queue, planning its capacity and measuring utilization.</p><p>See you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0572779c1b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chromium Development On Mac using Visual Studio Code]]></title>
            <link>https://medium.com/@tufan/chromium-development-on-mac-using-visual-studio-code-650b0886a115?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/650b0886a115</guid>
            <category><![CDATA[c-plus-plus-language]]></category>
            <category><![CDATA[browsers]]></category>
            <category><![CDATA[visual-studio-code]]></category>
            <category><![CDATA[chromium]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Fri, 10 Apr 2020 09:00:50 GMT</pubDate>
            <atom:updated>2020-05-18T23:16:39.019Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KCDOy5cgiYVKWXHvFJE6Jg.png" /></figure><p>I have been thinking switching to Visual Studio Code for a long time. It was feeling like a huge task. Today, I finished migrating all my development (except Android projects) to Visual Studio Code. It is free, feeling lighter than other IDEs I used to use, works for any language.</p><p>What actually triggered me to start migration was that I needed to play with chromium codebase and I needed to look for a suitable development environment. I found this <a href="https://chromium.googlesource.com/chromium/src/+/master/docs/vscode.md">post</a> from Chromium developers which is very helpful to setup a dev env for myself. So, I want to share my chromium development experiences starting with setting up a development environment, useful extensions for vs-code, usage tips and any addition to the post that chromium developers shared. So, the outline will be same with that post that contains my additional notes only.</p><h4>Visual Studio Code Installation</h4><p>Follow the steps on <a href="https://code.visualstudio.com/docs/setup/mac">https://code.visualstudio.com/docs/setup/mac</a> to run it on you Mac.</p><h4>Useful Extensions</h4><ul><li>All extensions from this list: <a href="https://chromium.googlesource.com/chromium/src/+/master/docs/vscode.md#useful-extensions">https://chromium.googlesource.com/chromium/src/+/master/docs/vscode.md#useful-extensions</a></li><li><a href="https://github.com/rokoroku/vscode-theme-darcula"><strong>Darcula Theme</strong></a><strong>:</strong> For developers migrated from IntelliJ IDEs</li><li><a href="https://github.com/alefragnani/vscode-bookmarks.git"><strong>Bookmarks:</strong></a> Chromium repo is huge, you will need it :)</li><li><a href="https://github.com/kasecato/vscode-intellij-idea-keybindings"><strong>IntelliJ IDEA Keybindings</strong></a><strong>: </strong>For IntelliJ users again to feel more comfortable with your shortcuts.</li><li><a href="https://github.com/kasecato/vscode-intellij-idea-keybindings"><strong>vscode-icons</strong></a>: again, chromium repo is huge, this great extension iconize your explorer.</li></ul><p><strong>Get The Codemium!</strong></p><p>We are ready to use VSCode, let’s get chromium code and start playing with its source code. I assume you have a 64-bit Mac running 10.14+ and you installed Xcode 11+</p><p><strong>Install depot_tools</strong></p><p>depot_tools is a collection of tools for dealing with Chromium development. The Chromium depot_tools suite contains many tools to assist/augment the Chromium development environment. The tools may be downloaded from <a href="https://chromium.googlesource.com/chromium/tools/depot_tools.git">here</a>.</p><pre>git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git</pre><p>Add depot_tools to the end of your PATH (you will probably want to put this in your ~/.bash_profile or ~/.zshrc). Assuming you cloned depot_tools to /path/to/depot_tools (note: you <strong>must</strong> use the absolute path or Python will not be able to find infra tools):</p><pre>$ export PATH=&quot;$PATH:/path/to/depot_tools&quot;</pre><p>There are two primary categories of tools. Some of these tools are <em>essential</em> to the development flow, in the sense that you cannot successfully develop Chromium without them.</p><p>Other tools are merely <em>helper</em> tools. Not required, but they can substantially ease the development workflow.</p><p>A set of useful tutorials can be found <a href="https://commondatastorage.googleapis.com/chrome-infra-docs/flat/depot_tools/docs/html/depot_tools_tutorial.html">here</a></p><h3>Clone te repo</h3><p>Ensure that unicode filenames aren’t mangled by HFS:</p><pre>$ git config --global core.precomposeUnicode true</pre><p>Create a chromium directory for the checkout and change to it (you can call this whatever you like and put it wherever you like, as long as the full path has no spaces):</p><pre>$ mkdir chromium &amp;&amp; cd chromium</pre><p>Run the fetch tool from depot_tools to check out the code and its dependencies.</p><pre>$ fetch chromium</pre><p>If you don’t need the full repo history, you can save time by using fetch --no-history chromium. You can call git fetch --unshallow to retrieve the full history later.</p><p>Expect the command to take 30 minutes on even a fast connection, and many hours on slower ones.</p><p>When fetch completes, it will have created a hidden .gclient file and a directory called src in the working directory. The remaining instructions assume you have switched to the src directory:</p><pre>$ cd src</pre><p><em>Optional</em>: You can also <a href="https://www.chromium.org/developers/how-tos/api-keys">install API keys</a> if you want your build to talk to some Google services, but this is not necessary for most development and testing purposes.</p><h3>Setting up the build</h3><p>Chromium uses <a href="https://ninja-build.org/">Ninja</a> as its main build tool along with a tool called <a href="https://gn.googlesource.com/gn/+/master/docs/quick_start.md">GN</a> to generate .ninja files. You can create any number of <em>build directories</em> with different configurations. To create a build directory:</p><pre>$ gn gen out/Default</pre><p>If you get sth like below</p><pre>➜  src git:(df8860521316) ✗ gn gen out/Default<br>********************************************************************************<br> WARNING: The NaCL SDK is 32-bit only. macOS 10.15+ removed support for 32-bit<br>          executables. To fix, set enable_nacl=false in args.gn, or downgrade to<br>          macOS 10.14. For more information, see <a href="https://crbug.com/1049832">https://crbug.com/1049832</a>.<br>********************************************************************************<br>ERROR at //components/nacl/features.gni:40:3: Assertion failed.<br>  assert(false, &quot;NaCL SDK is incompatible with host macOS version&quot;)<br>  ^-----<br>NaCL SDK is incompatible with host macOS version<br>See //BUILD.gn:18:1: whence it was imported.<br>import(&quot;//components/nacl/features.gni&quot;)<br>^--------------------------------------</pre><p>Open `out/Default/args.gn` and put;</p><pre>enable_nacl = false</pre><ul><li>You only have to run this once for each new build directory, Ninja will update the build files as needed.</li><li>You can replace Default with another name, but it should be a subdirectory of out.</li><li>For other build arguments, including release settings, see <a href="https://www.chromium.org/developers/gn-build-configuration">GN build configuration</a>. The default will be a debug component build matching the current host operating system and CPU.</li><li>For more info on GN, run gn help on the command line or read the <a href="https://gn.googlesource.com/gn/+/master/docs/quick_start.md">quick start guide</a>.</li></ul><h3>Faster builds</h3><p>Full rebuilds are about the same speed in Debug and Release, but linking is a lot faster in Release builds.</p><p>Put</p><pre>is_debug = false</pre><p>in your args.gn to do a release build.</p><p>Put</p><pre>is_component_build = true</pre><p>in your args.gn to build many small dylibs instead of a single large executable. This makes incremental builds much faster, at the cost of producing a binary that opens less quickly. Component builds work in both debug and release.</p><p>Put</p><pre>symbol_level = 0</pre><p>in your args.gn to disable debug symbols altogether. This makes both full rebuilds and linking faster (at the cost of not getting symbolized backtraces in gdb).</p><h4>CCache</h4><p>You might also want to <a href="https://chromium.googlesource.com/chromium/src/+/master/docs/ccache_mac.md">install ccache</a> to speed up the build.</p><h3>Build Chromium</h3><p>Build Chromium (the “chrome” target) with Ninja using the command:</p><pre>$ autoninja -C out/Default chrome</pre><p>(autoninja is a wrapper that automatically provides optimal values for the arguments passed to ninja.)</p><p>You can get a list of all of the other build targets from GN by running gn ls out/Default from the command line. To compile one, pass the GN label to Ninja with no preceding “//” (so, for //chrome/test:unit_tests use autoninja -C out/Default chrome/test:unit_tests).</p><h3>Run Chromium</h3><p>Once it is built, you can simply run the browser:</p><pre>$ out/Default/Chromium.app/Contents/MacOS/Chromium</pre><h3>Running test targets</h3><p>You can run the tests in the same way. You can also limit which tests are run using the --gtest_filter arg, e.g.:</p><pre>$ out/Default/unit_tests --gtest_filter=&quot;PushClientTest.*&quot;</pre><p>You can find out more about GoogleTest at its <a href="https://github.com/google/googletest">GitHub page</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=650b0886a115" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservice Monitoring Zorlukları ve Kullanışsız Uptime Servisleri]]></title>
            <link>https://medium.com/@tufan/microservice-monitoring-e583af3fc8?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e583af3fc8</guid>
            <category><![CDATA[monitoring]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[microspector]]></category>
            <category><![CDATA[uptime]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Sat, 18 Jan 2020 16:14:14 GMT</pubDate>
            <atom:updated>2020-01-20T07:47:50.566Z</atom:updated>
            <content:encoded><![CDATA[<p>Mikroservisler sayesinde koca yapıları parçaladık, böldük, ekiplere dağıttık ve neler kazandık çok iyi biliyoruz hepimiz. Neleri zorlaştırdık ve nelere ihtiyacımız oldu, bizim bir ihtiyacımız ile ürettiğimiz çözüm neydi? Bunlara değineçeğim fakat microservice monitoring website monitoring ile aynı ilkellikle devam etmemeli artık, bunun için de kolları sıvadık, baştan spoiler vermiş olayım.</p><p>Monitoring, teknik alt yapılarda hayati önem taşıyor, mikro servisler ise diğer dağıtık olmayan yapılara göre daha kompleks bir monitoring yapısına ihtiyaç duyar. Monolitik yapıların tersine, başka servislerden ve hatta çağırılma zamanına göre bile farklı veriler isteyebilir bir servis.</p><h4>Mikro Servisleri Neden İzlemeliyiz?</h4><p>Aslında herhangi bir sistemi neden izliyorsak o yuzden, sistemlerimiz her an hataya düşebilir. Bir hatanın meydana gelmesi en temel sebep olsa da tek başına bu değil bizim sebebimiz, bir sistemin sadece up ya da down olması çoğu zaman yeterli değil.</p><p>Neden yeterli değil? Size en iyi uptime servislerinden birini (pingdom) neden artık kullanmadığımızı anlatmak istiyorum.</p><p>Her şeyden önce şunu söylemeliyim ki günümüz mimarileri için bir servisin yayında olması onun doğru çalıştığı anlamına gelmiyor. Ya da sadece o anki isteğe cevap veremediğini bilmek (down alert) bizi probleme götürmeye yetmiyor. <em>Geliştirme ve problem çözme sürelerini düşürmek için geçtiğimiz bu dağıtık yapıda problemi tespit etme sürelerimizi uzattık</em>. Servislerin ayrı ayrı çalışıyor olması onların entegreyken de her istekte ve her şartta çalışıyor olduğu anlamına gelmiyor ve biz aynı durumu sağlayamadığımız sürece problemi tespit edemiyoruz.</p><p>Gelelim hikayeye;<br>Mikro servislerimiz tamamen düzensiz ama sürekli down alert veriyordu (2 yıl sürdü, şaka değil) Bu downdan haberimiz uptime servisi sayesinde oluyordu ama ne yazık ki uptime servisi down olduktan sonra tekrar kontrole gidip bize rapor sunmak istediğinde servis çoktan geri gelmiş oluyordu (~30 saniye) biz o down anında, günde bi kaç defa gelen ama asla bir işareti olmayan o down anında ne oluyor hiç bir fikrimiz yoktu. Değişik monitoringler denedik, zaten izlediğimiz bir alt yapı var ve asla anormal bir şey yok vs. Her şey şu grafikte bir düzen olduğunu farketmekle başladı;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kL3VV91Yt4t7sbiNlgQhEg.png" /></figure><p>Ne yazık ki bu servisi artık kullanmadığımız için göstermek istediğim detayın grafiği yok elimde. Burada servislerimizin artık down olmasa da belli araliklarla yavaşladığını farkettik. Yani problem devam ediyor sadece sunucular biraz daha buyudugunden şu an ayakta kalabiliyoruz. Bu grafiğe zoomladığımızda en yavaş response time’ların yine tam düzenli olmasa da sadece saat 5 ve katlarında, 05:XX, 10:XX, 15:XX oldugunu farkettik, onun biraz altinda yine düzensiz ama sadece 3ün katlarında olan başka yavaşlayan zamanlar var. Bu grafik bize zamanlanmış görevlerimizin bir tıkanmaya sebep olduğunu düşündürdü ve ne tesadüfse tüm zamanlanmış görevlerimizin bu downlara denk gelme ihtimalleri vardı çünkü 1,3,5 saatte bir calisan backuplarimiz, fatura bildirimlerimiz vs var. Tum zamanlanmış işlemlerin saatlerini değiştirdik ortak katlarının gün içinde çok denk gelmemesi için hesaplar yaptık. Grafik değişti ama ne yazık ki yine bir standartı yoktu bu down messajlarının. Ve backup anında makinada bir load dahi oluşmuyordu.</p><p>Bu aslında servislerimizin en stabil hali, yani neredeyse down mesajı almıyoruz (bazen login 2 saniyeye cikiyor tabi) bu tarih aralığında. Çünkü bir çok şeyi optimize ettik, sunucu büyüttük, ayırdık bağımsız makinalara vs. Bu grafik bizim alt yapımızın en temel servislerinden biri olan Auth Servis, kullanıcı(profil) işlemlerinin yapıldığı, kimlik doğrulama ve yetkilendirme servisimiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_IXeuyiyiIr18Ri2JOJZAA.png" /><figcaption>Veritabanlarımızdan birinin bandwith grafigi</figcaption></figure><p>Burda da benzer bir grafik var, kısalar saat3, uzunlar saat5, bizim response time ile örtüşen bir grafikti, bunun üzerine daha fazla gitmek istedik, veritabanı sunucusunda tcp connection başına düşen bandwidthi izlemek istedik, orda da şoyle bir grafik vardı sadece backup anlarında zıplayan, doğal olarak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NyJtdl0l46IJG4CgN5nepg.png" /><figcaption>memory usage per tck socket in use</figcaption></figure><p>Başka bir i/o monitor grafiği bize yine buna yakın bir desen verse de 24 core cpu ortalaması ya da 24 core’dan 1 tanesinin i/o waitinin tavan olması bize bunu yaşatabileceğini düşünmedik</p><p>Biz bu süreçte çokca makine ekleyip çıkardık veritabanlarını farklı makinelere (daha buyuguna, 1den fazlaya, daha kucugune vs.vs.) taşıdığımız için bu süreçlerin hangisinde en stabildik acaba diye düşünüp şöyle daha geniş bir zaman aralığında sunucularımızın aktif / pasif olma tarihlerini ayırarak bakmak istedik. en verimsiz dönemleir tek sunucu varken geçirmişiz ama garip olan şu ki biz bu süreçlerin hiç birinde load goremedik hatta son makinenin 24 core + 64gb ram oldugunu dusununce hiç de diğerlerinden daha kötü çalışabileceğini düşünemedik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lpZyAgVi_plu4rHYNhDk-Q.png" /></figure><p>Makineleri kıyaslamak istedik, en hızlı CPU 4&#39;teydi, en yavaş CPU’lar (nasılsa dagitiyoruz makinelere diye) 2 ve 3 aralıklarındaki makinelerdeydi. Burdan çıkarabileceğimiz tek 1 sonuç var, çok garip, daha iyi CPU bize downtime yaşatıyor, sıklığı artmış mesela bu downtime’ların ama süreleri kısalmış. Down olmasıyla geri gelmesi arasında daha kısa zaman var artık.</p><p>Naparsak yapalım, tahminden öteye gidemeyeceğimiz için başka bir şeye karar verdik, bu downtime’ı manuel yaptırabilmek için senaryolar denedik, tüm zamanlanmış görevleri (evet tüm jenkins tasklerini) aynı anda başlatıp bir de login API’ya apache benchmark ile load gönderdik. Tahmin ettiğimizden daha çok load ile bile down alert alamadık! Bu kadar iyi bir şeyin bu kadar kötü hissettirmesinin ne demek olduğunu anlatamam.</p><p>Load testler vs bittikten kısa bir süre sonra down alert aldık :(</p><p>Şimdi sıkı durun :), Redis tek threadde calisan bir yapı ve bizde de sadece 2 redis var bu makine uzerinde, biri cache biri persistent database, biz persistent database’i de ayıralım dedik (tamamen random bi karar, bunun etki edeceğini bilemezdik çünkü cpu da yetiyor, ram de yetiyor asla yüklenme yok rediste) bunları ayırdıktan sonra down grafiğindeki desen değişti artık 3 ve 5 degildi bu downtimelar, 2 6 (salladim) gibi bir seydi. Bunun redisle ilintili olduğunu düşünmeye başladık artık ve redisin bgsave ayarlarini degistirmeyi denedik. Bingo, ufacık bir data (15GB + 10 GB) bgsave anında diski çok kısa bir süreliğine cevap veremeyecek hale getiriyordu. Disk read/write benchmark testleri yaptık sonuçlar inanılmaz iyiydi bir SSD diskten beklenebilecek en iyi performansı alıyorduk peki sorun neydi? Sorun o 1 tane CPU’nun tek başına 15GB bile olsa diske yazarken diskin tüm i/o kapasitesini doldurabilecek kadar güçlü olmasıydı. Tabi ki her servise io limiti vermek gibi çözümler vardı ama kaynak sorunumuz bu optimizasyona girişecek ya da bunu kısıtlayacak kadar yoktu. Kullanamadığımıza yandığımız kaynakları artık kullanmalıydık:) disk ekledik. Eğer bu çıkarımımız doğruysa redisleri ayrı ayri 2 diske mysql’i ayrı diske aldığımızda bu sorun çözülmeliydi.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J3CQn5ly2BF8M-e75gqLuA.png" /></figure><p>Yukarıdaki grafiği yorumlamama gerek yok sanırım. Bu bizim için inanılmaz bir tecrübeydi, aslında 24 core CPU’ya ihtiyacımız yokmuş :) Şimdi sunucularımız daha küçük, artık servislerimizi planlarken kategorize etmeyi de öğrendikcomputing optimized, i/o optimized(network optimized)</p><p>Şimdi gelelim uptime servislerinin neden kullanışsız olduğuna, pingdom’a tam olarak aylık $80 veriyorduk. Ne diye? HTTP 200 alamiyorsa haberimiz olsun diye :) Aynısını tamamen açık kaynak bir uptime uygulaması olan <a href="https://github.com/tufanbarisyildirim/statping">Statping’i</a> kendi script dilimizi entegre ederek kendi inframız dışında bir yere ($4&#39;lık aws ec2 instance) kurarak yapabiliyorduk. Yaptık. Şimdi bize 1 adım ötesi gerekiyordu, entegrasyon testleri, hem de production’da çünkü test ortamlarımızın hepsinde üretilen data mükemmeldi (biz olusturuyorduk) ama production ortamındaki veri kullanıcı tarafından oluşturuluyor ve değişik ihtimallerde servisler arası entegrasyon sorunu olabiliyordu. Örnek yukardaki grafikte sadece login sonucunun 200 oldugunu biliyoruz, bu login sonucu aldığımız JWT’nin başka servisimizde düzgün çalışacagının bir göstergesi de değil, çok gereksiz bir test bu.</p><h4>Klasik Monitoring Servisleri</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*jtWHBbph1cUBqUpoVmuxOw.png" /></figure><p>Alternatiflerin, browser emulator dışında yapabildikleri ^</p><h4>Olması Gereken :</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*Map2mpm1Bbw9Ymqsv4RXfg.png" /></figure><p>Biraz karışık mı? Olmalı, çünkü yapı olarak karmaşıklaştık, bunu yapamayan servislere veda etmeye hazır olun :)</p><p>Sadece API çağıran değil, aynı zamanda aldığı sonuçla başka API’lar çağırabilen, aldığı sonuçları değerlendirebilen başka bir yapıya ihtiyacımız vardı, bunu dinamik yapabilmek adına şöyle bir scripting language geliştirdik : <a href="https://github.com/microspector/microspector"><strong>microspector</strong></a> (Micro Service Inspector) Bir dahaki yazıda microspector ile api flow, integration testleri ve transactional testler anlatacağım.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e583af3fc8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Her Yönüyle JWT]]></title>
            <link>https://medium.com/@tufan/her-y%C3%B6n%C3%BCyle-jwt-2578b402052?source=rss-5c25c77fce7a------2</link>
            <guid isPermaLink="false">https://medium.com/p/2578b402052</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[jwt]]></category>
            <category><![CDATA[authorization]]></category>
            <dc:creator><![CDATA[Tufan]]></dc:creator>
            <pubDate>Sat, 11 Jan 2020 16:41:22 GMT</pubDate>
            <atom:updated>2021-07-19T17:39:22.940Z</atom:updated>
            <content:encoded><![CDATA[<p>Medium’daki ilk yazım, uzun zamandır (7 senedir) bir şeyler yayınlamıyorum. Umarım devamı gelir.</p><p>JWT’nin (JSON Web Token) ne olduğundan çok ne olmadığından bahsetmek istiyorum aslında çünkü en çok amacı dışında kullanıma denk geliyorum. Kod örneği vermeyeceğim, dileyen diledigi dilde/şekilde yazsın. Yine de nedir bu JWT bir değineceğim. Web teknolojilerine yeni başlamış ya da token, key, secret key, signed request kavramlarını tam oturtamamış birileri okuyor gibi yaklaşağım, dedeye anlatır gibi anlatacağım, şimdiden uyarmış olayım :)</p><p>JWT, içinde okunabilir limitsiz JSON veri barındıran, URL safe, kriptografik olarak imzalanan bir veri taşıma yöntemidir. Elimizde bir JWT varsa ve bunu doğrulayacak key de varsa içindeki veri güvenilirdir diyoruz. Neden içinde okunabilir bir JSON taşıyor ve nasıl güvenli oluyor ya da güvenli olmak zorunda mı ona da değineceğim.</p><p>İlk önce stateless ve stateful kavramlarını biraz açıklayarak buna neden ihtiyaç duyuldu fikir sahibi olalım.</p><h3>Stateful</h3><p>Normal bir websitesinde kullanıcı özel bilgileri session store’da, session kimligi (session id) de cookie’de saklanır. Session id aslında web uygulamamızın state değiştirmesini sağlayan token’dir. Biz <em>session_id=1 </em>olarak geldiğimizde sunucu <em>session_id=1</em> için ne kaydetmişsek o state’e geçiyor. Buna stateful design deniyor. Aslında HTTP tamamen statless bir yapıdır ama stateful davranabilsin diye icat edilmiş şeyler vs. Yani bir baglantiyla birden fazla kullaniciyi taniyabilme gibi bir yeteneği zaten yoktur. Yine de biz buna stateful design diyeceğiz farkı anlamak açısından.</p><h3>Stateless</h3><p>Günümüzde ise servisler ve uygulamalar arası iletişimler arttıkça bu iletişim hep daha küçük veriler ile yapılsın istediğimizde, client ayrı bir id saklasın, server bunun için ayrı oturum bilgisi saklasın istemiyoruz ve istek yapan kullanicinin kim/hangi cilent oldugu degil bize neyle geldigi önemli dediğimizde de client /oturum bilgisi (state) saklamayacak şekilde tasarlıyoruz. Buna da stateless design deniyor. Eğer REST API tasarlarken de stateful tasarlamak isteseydik, bu API cagiran clientların aynı zamanda bizim clienta cevaben ilettiğimiz cookie bilgisini vs saklaması gerekecekti. REST iletişimi ayrı bi işkence olurdu.</p><p>O halde stateless servislerin bir anahtara ihtiyacı var. Gelen isteğin kimliğinin doğrulanıp doğrulanmadığı ya da bu kimliğin yetkili olup olmadığını anlamamızın bir çok yolu var, bunlardan biri de JWT. Onun dışındaki çözümlere de değinmiş olalım. Örneğin API Key, kullanıcıya ya da o servise özel bir anahtar sayesinde belli verilere ulaşabilme yöntemine deniyor. Bu sadece client ve serverin bildigi random bir uretilmiş bir şey olabilir, kullanıcı bazli uretilen bir şey olabilir, sizin tasarımınıza ve ihtiyacınız kalmış. Bir başka yöntem; Signed request. Siz sunucuya belli parametrelerle beraber 1 tane de bu parametreleri kullanarak oluşturduğunuz bir hash yolluyorsunz. Bu hash’i oluşturan key sadece client’ta ve serverda oldugundan ayni hashi (signature) server da oluşturuyor ve gelen isteğin yetkili birinden geldiğini doğruluyor.</p><blockquote>Bu örneklerin hepsinde ve JWT’de güvenli, hızlı ve iyi tasarım size bağlıdır. Yani bu yöntemleri ancak sistem içinde güvenli kullanırsaniz güvenli olur, hızlı çalışcak şekilde tasarlarsanız hızlı çalışır. Bu yöntemlerin çözmek istedikleri neredeyse aynı şeyler. Kıyaslarken dikkat edelim. “X güvensizdir” dendiği zaman aldırış etmeyiniz :) Biz bu yazıda JWT öveceğiz o ayrı.</blockquote><h3>Authentication &amp; Authorisation</h3><p>Bu iki kavramı bir birine karıştırdığınız zaman her hangi bir yöntem ile verimsiz ya da güvensiz olabilirsiniz. Nedir ikisi arasındaki fark? Gerçek hayattan örnek verelim. Elinizde 1 kimliğiniz var, kimliğiniz doğrulanabilir, ya da sahte olduğu anlaşılamaz ve siz “<em>authenticated</em>” olursunuz. Yani kimliği doğrulanmış farzediyoruz. Senin, elindeki kimlikte yazan kişi olduğunu kabul ettik. Ahmet’sin. Authorisaton ise yetkidir, elinizde sizin yetkinizi belirten başka bir evrak olduğunu düşünelim, başkası adına işlem yapacağınıza dair size verilmiş bir vekaletname düşünelim. Ve bir işlem yapmak için bankaya/noter’e gidiyorsunuz. Burada “<em>auhtorized</em>” olup olmadığınız artık bankanın ya da noterin sorumluluğundadır. Her birini devletin bir servisi olarak düşünürsek, auth servisi (nüfus) sizi “<em>authenticate</em>” eder. Bu programalama dünyasında genelde aynı servise yaptırılsa da aslında policy servisleri farklıdır gerçek hayatta. Her iş için başka kurum sizi “<em>authorize</em>” eder. Gittik hesabın gerçek sahibi ile noter huzurunda bir vekaletname aldık ve buna bir süre koyduk (expiring token). Elimde zamanı geçebilen bir yetki belgesi var. Bu süre zarfı içinde bu yetkileri kullanırım. Dikkatsizlik sonucu bu süre dışında bize bir bankanın ya da noterin işlem yaptırmış olması “<em>vekalet</em>” sistemini güvensiz yapmaz, o sorumlu kurumu güvensiz / dikkatsiz yapar. Yani önceki paragrafta bahsettiğim şeye tekrar değinecek olursam “jwt güvensizdir” diyen bir geliştiricinin uygulamalarında bolca güvenlik zafiyetleri vardır.</p><h3>JWT’nin Yapısı</h3><p>JWT, 3 parçadan oluşur ve bu parçalar birbirinden nokta ile ayrılır. Bu parçaların ilki “<em>Header</em>” ikincisi “<em>Payload</em>” üçüncusu “<em>Signature</em>”. Bu üç bölüm de <strong>base64UrlEncode</strong> <em>base64encode değil</em>, çünkü base64 encode sonucunda bize URL’de taşınamayacak (/, +, = gibi) karakterler çıkabilir, urlencode ile bunlar da bertaraf edilir ve biz de bunu url’lerde vs taşırken sorun yaşamayız.</p><h4>Token Örneği:</h4><pre><strong>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9</strong>.eyJzdWIiOiIxIiwibmFtZSI6IlR1ZmFuIEJhcsSxxZ8gWcSxbGTEsXLEsW0iLCJpYXQiOjE1MTYyMzkwMjIsImV4cCI6MTUxNjIzOTEyMn0.<strong>QVp6WpyHw3ewSZAwxA4dwYKxG2G61PKtKjUq1UL32pM</strong></pre><h4>Decoded:</h4><pre><strong>Header:<br></strong>{ &quot;alg&quot;: &quot;HS256&quot;, &quot;typ&quot;: &quot;JWT&quot; } <br><strong>Payload</strong>: <br>{ &quot;sub&quot;: &quot;1&quot;, &quot;name&quot;: &quot;Tufan Barış Yıldırım&quot;, &quot;iat&quot;: 1516239022, &quot;exp&quot;:1516239122 } <br><strong>Signature</strong>: <br>QVp6WpyHw3ewSZAwxA4dwYKxG2G61PKtKjUq1UL32pM</pre><h4>Header</h4><p>Header, bilgisayar dünyasında hemen her şeyde olduğu gibi burda da elimizdeki şeyi tanımlayan, metaverileri taşıyan bölümdür. Kisaca alg= algoritma, JWT = json web token. Biz 3 parcanin ilkini base64urldecode ile decode ettikten sonra sonraki kısımlar hakkında bilgi veriyor. Elimizde bir json web token var, imza HS256 hash methodu ile oluşturulmuş.</p><h4>Payload</h4><p>İkinci bölümde ise token içinde taşımak istediğimiz verileri veriyoruz. Biz burada kullanıcı verisi taşımaya örnek verdik. JWT’de bazı field’lar standartlaşmış ve bunları başka amaçlarla kullanmamızı tavsiye etmiyorlar, zaten bir çok hazır kütüphane siz bunları yanlış kullandığınızda hata veriyoru. iat = issued at (olusturulma tarihi) exp = expires at, sub =subject (muhatab) gibi.</p><h4>Signature</h4><p>Son bölüm ise imza, diğer verilerin değiştirilip değiştirilmediğini ya da bu imzayı bizim (güvendiğimiz kurumun) oluşturup oluşturmadığını bu imzadan anlıyoruz, iyi de kardeşim imza doğru ama içerik yanlışşa? Demiyoruz, çünkü bu imza diye adlandırdığımız şey yani hash diğer veriler kullanılarak oluşturuluyor ve farklı bir veri ile farklı hash olusur. Biz bu token’i doğrulamak istediğimizde aynı verileri ve gizli 1 adet anahtarı kullanarak imza oluşturduğumuzda aynı imzayı elde ediyorsak 2 şey soyleyebiliyoruz, ya bu veriler gerçek ya da sahteyse bile bizim anahtarımızla (key) imzalanmış. Güvenmekten başka çaremiz yok :) Hiç kimsede olmayan bir mühür düşünün, o mühür (secret key) ne kadar güvendeyse sisteminiz o kadar güvendedir.</p><h3>JWT kullanım alanları</h3><p>JWT, birden fazla sunucunun dahil olduğu, merkezi bir session server olmadığı zamanlarda, bağımsız sunucuların aralarında token paylaşarak authentication ve authorization işlemlerini yapabilmek için kullanılır. Yani, zaten bir merkezi session sistemine dahilseniz, bir session key yerine JWT kullanmak size fayda sağlamayacaktır, aksine kucuk bir key yerine buyuk bir token gondermis olacaksiniz her istekte. JWT’nin en temel kullanım şeklini şu grafikle açıklayabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jiEGbY-pqzqzNE3fR_ShGg.png" /><figcaption>Basic usage of JWT</figcaption></figure><p>Dağıtık bir servis yapımız olduğunu varsayıyoruz, video ve auth servislerimiz birbirinden ayrı sunucularda ve ayrı veritabanları ile çalışıyorlar belki de ayrı dillerde yazıldılar. Bu iki servis arasında bizim önceden paylaşacağımız tek şey var. Secret Key. Token’in imzasını doğrulamak için kullanacağımız anahtar yani. Bu durumda merkezi bir oturum sistemi yapmadan, yatayda ölçekleyebileceğimiz, daha doğrusu, ölçeklemek zorunda kalmayacağımiz bir oturum doğrulama mekanizmamız oldu. Her sunucu elindeki anahtar ile bu Token’in auth service tarafından oluşturulduğunu garanti edebiliyor ve kullanıcıyı içeri alıyor.</p><h4>Dağıtık Servislerde Authorizaton</h4><p>Yukardaki örnekte kimlik doğrulamasından sonra video servisinde yetkili olduğumuzu varsaydık. Ama asıl önemli olan kimlik doğrulama sonrasında token ve token sahibi kullanıcının yetkilerinin gözetilmesi. Yani burda authorizationdan sorumlu olan servis artık Video servisi. Kritik işlemlerde ne yapacağı da yine bu servisin sorumluluğunda. Policy servisi olarak Auth servis de kullanılabilir, yetkilerin yönetildiği bambaska bir policy servis de üretilebilir. Şimdi bir video delete işleminde video servisin yapması gereken şeyi basitçe ekleyelim yukardaki akışa</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qKSBCZpyuyvgHssZ5Woh1g.png" /></figure><p>Bu seferki bir DELETE işlemiydi ve video servisi bu işlemden önce Auth servise bu kullanıcının hala aktif olup olmadığını ve bu işlemi yapmaya hala yetkili olup olmadığını sordu. Bunu şöyle düşünebiliriz, yine en başta verdiğim örnekten gidersek, biz bir bankaya gidip vekaleten işlem yapmak istediğimizde evrak üzerinde her şey doğru görünse dahi noteri “güvenli bir yolla” arayıp, bu vekaleti ve geçerliliğini teyit etmesine benzetebiliriz. Teyit etme gereği duymayabilir. Bu bizim tasarımımıza ve ya o anki işleme bağlı. Bu haliyle de henüz tam güvenli değil tabi, ona da değineceğim.</p><h4>JWT Scope</h4><p>Bir diğer basit policy mekanizması da JWT icinde scope taşımak. Tüm yetkileri tüm detaylarıyla taşıyamacağımız için ya da bazı clientlara (3rd party uygulamalar olabilir) sınırlı yetkiler vermek isteyebileceğimizden farklı microservislerimizde geçerli olabilecek farklı tokenlar oluşturabiliriz. JWT içine payload kismina bir de scope:[&quot;edit_videos&quot;,&quot;show_profile&quot;] gibi kendi belirlediğimiz ilgili servislerimizde belli yetkileri temsil edecek belirteçler de taşıyabiliriz. Bu yetkisiz olduğu aşikar tokenları authorization servisine gitmeden önce reddedebilmeyi sağlayacaktır. Bununla beraber farklı yetkilerde ama aynı kullanıcılara ait farklı tokenlar uretebilmemizi saglar.</p><h4>JWT’de zaman aşımı</h4><p>JWT, aslında belli bir süre geçerli olsun, bu süre içinde auth (ve mümkünse policy) servislerini meşgul etmeden diğer servislerde işlem görebilsin diye tasarlanmıştır. Bu yüzden bir expire date, yani son kullanma tarihi (json içindeki “exp”) olması beklenir.</p><h4>Auto Token Renew</h4><p>Elimizdeki JWT’yi kısa ömürlü yaptık, peki her seferinde kullanıcıdan login mi isteyeceğiz? Bu yine tamamen kendi seçimimiz olmakla beraber, bunun için de refresh token oluşturma çözümü var. Refresh Token kısaca; 1 oturum için oluşturulmuş veritabanımızda bir karşılığı olan (username/şifre yerine geçen) ve geçerlilik süresi yine bize kalmış başka bir token. Yani senaryomuz burda biraz değişiyor. Login anında 2 adet token oluşturuyoruz, Access Token ve Refresh Token. Access ve Refresh Token’ları birlikte kullanıcıya (clienta) yolluyoruz ama sadece refresh token’i — tercihen sadece hashini — veritabanımızda saklıyoruz. Access Token’ımızın suresi doldugunda bu refresh token’i kullanarak (tekrar sifre sormamak icin) yeni kısa sureli bir access token yaratiyoruz. Ve client’ta bunu sakliyoruz. Bunun invalidate olması durumunda (şifre değiştirme, logout, kullanıcı silme vs.) bu kritik işlemi de o an engelliyoruz.</p><h4>JWT Invalidation</h4><p>Bir token, zamanından önce geçersiz olsun isteyebiliriz, bu JWT’nin çıkış noktası olmadığından ve dağıtık yapıya pek uymadığından (tüm istekleri merkezi bir mekanizmayla doğrulamak) hazırda böyle bir standartı yok. Bu gibi durumlarda token suresini kısa tutup tekrar olusturmanizi bekler. Bu kısa sürenin dahi olmasını istemiyorsanız Access Token’in kendisini DB’de tutmak dışında — ki bunu asla yapmayin — 3 seçeneğiniz kalıyor;</p><p>a) Bir access token blacklist oluşturmak.<br>b) Kritik işlemlerde refresh tokenı da doğrulatmak.<br>c) Kritik işlemlerde access token içinde taşıdığımız oturumun hala aktif olup olmadığını kontrol etmek.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Oca7LpETc7w5zsnfX0AW7w.png" /></figure><p>Bu grafikte A ve B durumlarını aynı anda çizdik. C durumunu sonraki grafikte açıklayacağım. Refresh token invalidate edildi mi (logout, ban, permission change vs) ve Access token blacklistte mi sorgusunu temsili olarak auth servise yaptirdim, bu bambaşka bir servis de olabilirdi, video servisinin kendisi de baska yerden o bilgiyi alip kendi uzerinde saklayabilirdi vs.</p><p>Şimdi bir de şu an merkezi bir auth mekanizmasini JWT’ye geçirerek nasıl authentication ve authorization yükünü servislere dağıttık ve ölçeklenebilirliğin önündeki engelleri kaldırdık kısaca grafikle anlatayım ilk önce grafiği sunayım buyrun;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jYDy5ywYxu8G9GXosR3Zgw.png" /></figure><p>C durumunda da biz bu access token’in imzasına güvendiğimiz için (içindeki verinin değişme ihtimali olmadığından) içinde 1 adet Session ID koyduk ve kritik doğrulama işlemlerinde bu oturumun geçerli olup olmadığını Auth Service sorduk, bu oturum baska cihazdan veya yönetici tarafından sonlandırılmışsa kritik işlemleri yaptırmıyoruz. Bir işlemin kritik olup olmadığına her servis kendi karar veriyor. Diğer taraftan aktif bir client access token her expire oldugunda ya da olacakken (client tasarimimiza bagli) elindeki refresh tokeni auth servise gonderip yeni bir (ayni oturum numarasi ile) access token alıyor. Yani kısa kısa izinlerle işlemlerine devam edebiliyor ve servisler auth icin her zaman degil ama lazım oldukça auth servise gidiyor.</p><p>Biraz daha somut olsun diye veritabanında Session tablosunda sadece şu kayıtlar var. Başka da bir şeye ihtiyacımız olmadan güvenli bir auth mekanizması kurmuş oluyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_s3neYTw1sVbEtV05y38NA.png" /></figure><h3>Sonuç</h3><p>JWT kullanımımızı güvenli hale getirmek için yaptıklarımız;<br><strong>1-</strong> Güçlü bir kriptografi algoritması kullanmak, (RSA gibi)<br><strong>2-</strong> Access Token’lara mümkün olduğunca kısa ömür vermek. (Ne kadar kısa o kadar iyi demek değil ama biz bir kullanıcıların appte kaldığı süreye göre revize etmeyi tercih ettik, appi sürekli kullanan kullanicilarimiz arasinda appte durma ortalamamiz 16 dakika 45 saniye, biz de token ömrünü buna göre ayarladık, yani buyuk ihtimalle appten cikinca access token da ömrünü tamamlamış oluyor, daha uzun sureler icin de access token yenileyen mekanizmamiz zaten devrede. <br><strong>3-</strong> Burda temel kaygı kullanıcı verisi olduğundan, olusturdugumuz refresh token ve access token sadece ama sadece client uzerinde olmalı. Sunucularımızda değil. Biz veritabanında “refresh_token” alanında kullanıcıya gönderdiğimiz refresh tokenin sha256 hashini tutuyoruz. Boylelikle bize gelen bir access tokeni hashleyip veritabanımızda karşılığını buluyoruz. Tahmin edilmesi imkansizlaşsın diye olusturdugumuz 200 karakter token yerine 64 karakter bir hex tutmus oluyoruz. Yine içinde bir suru veri saklama ihtimalimiz olan yuzlerce karakter uzunlugundaki base64 encoded olan access tokeni hic tutmuyoruz.</p><p>Access tokeni, refresh tokeni veritabanımızda tutsak, bunlara doğru expire date vermezsek, güclü algoritma kullanmazsak (ya da guclu algoritma ama kısa key kullanırsak, HS256 kullanıp 10 karakter key yapmak gibi) Access tokenı kritik işlemler yapmak istediğinde bir policy servisi ile dogrulayacak bir yapı oluşturmazsak güvenli olamayız.</p><p>Varsa yazı hakkında geribildirimlerinizi yorumla bildirebilirsiniz. Şimdilik bu kadar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2578b402052" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>