Mohammed Elrasheed

𝗜𝘀 𝗻𝗳𝘁𝗮𝗯𝗹𝗲𝘀 𝘁𝗵𝗲 𝗙𝘂𝘁𝘂𝗿𝗲 𝗼𝗳 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 𝗡𝗲𝘁𝘄𝗼𝗿𝗸𝗶𝗻𝗴? For years, 𝗶𝗽𝘁𝗮𝗯𝗹𝗲𝘀 has been the backbone of Kubernetes networking, ensuring traffic reaches the right destinations. But as clusters scale to thousands (or tens of thousands) of Services, 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗯𝗼𝘁𝘁𝗹𝗲𝗻𝗲𝗰𝗸𝘀 𝗯𝗲𝗰𝗼𝗺𝗲 𝗶𝗺𝗽𝗼𝘀𝘀𝗶𝗯𝗹𝗲 𝘁𝗼 𝗶𝗴𝗻𝗼𝗿𝗲. Enter nftables mode for kube-proxy—a modern, more efficient alternative that eliminates the linear rule-checking delays of iptables and introduces O(1) lookups with verdict maps. 𝗧𝗵𝗲 𝗿𝗲𝘀𝘂𝗹𝘁? 𝗙𝗮𝘀𝘁𝗲𝗿 𝗽𝗮𝗰𝗸𝗲𝘁 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴, 𝗹𝗼𝘄𝗲𝗿 𝗹𝗮𝘁𝗲𝗻𝗰𝘆, 𝗮𝗻𝗱 𝗯𝗲𝘁𝘁𝗲𝗿 𝘀𝗰𝗮𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆—𝗲𝘀𝗽𝗲𝗰𝗶𝗮𝗹𝗹𝘆 𝗶𝗻 𝗹𝗮𝗿𝗴𝗲 𝗰𝗹𝘂𝘀𝘁𝗲𝗿𝘀. 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 1.29 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝗱 𝗻𝗳𝘁𝗮𝗯𝗹𝗲𝘀 𝗮𝘀 𝗮𝗻 𝗮𝗹𝗽𝗵𝗮 𝗳𝗲𝗮𝘁𝘂𝗿𝗲, 𝗮𝗻𝗱 𝘄𝗶𝘁𝗵 𝗶𝘁𝘀 𝗯𝗲𝘁𝗮 𝘀𝘁𝗮𝘁𝘂𝘀 𝗶𝗻 1.31, 𝗶𝘁’𝘀 𝗼𝗻 𝘁𝗿𝗮𝗰𝗸 𝘁𝗼 𝗯𝗲𝗰𝗼𝗺𝗲 𝗚𝗔 𝗶𝗻 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 1.33. 𝗪𝗵𝗶𝗹𝗲 𝗶𝗽𝘁𝗮𝗯𝗹𝗲𝘀 𝘄𝗶𝗹𝗹 𝗿𝗲𝗺𝗮𝗶𝗻 𝘀𝘂𝗽𝗽𝗼𝗿𝘁𝗲𝗱, 𝗻𝗳𝘁𝗮𝗯𝗹𝗲𝘀 𝗶𝘀 𝘀𝗵𝗮𝗽𝗶𝗻𝗴 𝘂𝗽 𝘁𝗼 𝗯𝗲 𝘁𝗵𝗲 𝘀𝘂𝗽𝗲𝗿𝗶𝗼𝗿 𝗰𝗵𝗼𝗶𝗰𝗲 𝗳𝗼𝗿 𝗵𝗶𝗴𝗵-𝘀𝗰𝗮𝗹𝗲 𝗻𝗲𝘁𝘄𝗼𝗿𝗸𝗶𝗻𝗴. 𝗪𝗵𝘆 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿? • Large-scale clusters suffer from 𝗶𝗽𝘁𝗮𝗯𝗹𝗲𝘀' 𝗹𝗶𝗻𝗲𝗮𝗿 𝗰𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆 (𝗢(𝗻)), making rule lookups slower as the number of Services grows. • 𝗻𝗳𝘁𝗮𝗯𝗹𝗲𝘀 𝗺𝗼𝗱𝗲 𝗱𝗿𝗮𝘀𝘁𝗶𝗰𝗮𝗹𝗹𝘆 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝘀 𝗳𝗶𝗿𝘀𝘁-𝗽𝗮𝗰𝗸𝗲𝘁 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 𝘂𝘀𝗶𝗻𝗴 𝗵𝗮𝘀𝗵-𝗯𝗮𝘀𝗲𝗱 𝗹𝗼𝗼𝗸𝘂𝗽𝘀 (𝗢(1)), keeping performance constant regardless of cluster size. • 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗽𝗹𝗮𝗻𝗲 𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝘀, as kube-proxy only updates changed rules rather than rewriting everything. Of course, nftables mode isn’t the default yet—it’s still relatively new, requires Linux 5.13+, and may have compatibility gaps with some CNIs and monitoring tools. I recently wrote about this shift in detail on Medium: https://lnkd.in/euhi6mrq #Kubernetes #CloudNative #DevOps #Networking #nftables #kubeproxy

153

14 Comments

🚀 Microservices Architecture — the full blueprint Microservices isn’t “just breaking apps into smaller apps”… it’s an ecosystem. This graphic shows the core components that make microservices scalable, secure, and observable 👇 ✅ 1) API Gateway – single entry point (routing, rate limiting, auth) ✅ 2) Service Registry – helps services discover each other dynamically ✅ 3) Service Layer – independent services (A/B/C) deployed & scaled separately ✅ 4) Authorization Server – identity + access control (OAuth2/JWT) ✅ 5) Database Layer – decoupled data + replication ✅ 6) Distributed Cache – boosts performance (Redis, etc.) ✅ 7) Distributed Messaging – async communication (Kafka/RabbitMQ) ✅ 8) Metrics + Monitoring – Prometheus + Grafana = visibility ✅ 9) Centralized Logging – ELK stack (Logstash → Elasticsearch → Kibana) 🔥 When done right: ➡️ faster deployments ➡️ fault isolation ➡️ scaling per-service ➡️ real observability + reliability

62

6 Comments

Must-know principles of solution architecture design (explained in under 2 mins): 𝟳 𝗰𝗼𝗿𝗲 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝘄𝗶𝘁𝗵 𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗯𝗹𝗲 𝗯𝗲𝘀𝘁 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲𝘀 for designing solutions: 𝗛𝗶𝗴𝗵𝗹𝘆 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗮𝗻𝗱 𝗿𝗲𝘀𝗶𝗹𝗶𝗲𝗻𝘁 ↳ High availability ensures systems stay operational despite failures; resilience enables fast recovery. ↳ Use active-passive or active-active failover setups to minimize downtime. Build redundancy and synchronize data where needed to maintain continuity during disruptions. 𝗦𝗰𝗮𝗹𝗮𝗯𝗹𝗲 ↳ Systems must handle growth without degrading performance.  ↳ Vertical scaling adds resources to a node, but horizontal scaling (adding nodes) with load balancers offers better flexibility. Use auto-scaling and manage state (e.g. distributed caches) to handle traffic spikes efficiently. 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝘁 ↳ Performance optimization reduces latency and maximizes throughput. ↳ Apply non-blocking I/O, asynchronous processing, and caching to handle concurrency. Use p99 latency metrics to monitor worst-case scenarios and maintain a consistent user experience. 𝗦𝗲𝗰𝘂𝗿𝗲 ↳ Security must be embedded throughout. Implement end-to-end encryption, RBAC, and threat modelling to address risks proactively. ↳ Use OAuth2 or JWT for authentication, and consider Zero Trust Architecture (ZTA) to ensure continuous identity verification. 𝗟𝗼𝗼𝘀𝗲𝗹𝘆 𝗰𝗼𝘂𝗽𝗹𝗲𝗱 ↳ Modular systems scale and adapt more easily. ↳ Use event-driven architectures and asynchronous messaging systems (e.g. Kafka, RabbitMQ) to decouple dependencies. This ensures scalability, fault tolerance, and seamless updates. 𝗘𝘅𝘁𝗲𝗻𝗱𝗮𝗯𝗹𝗲 ↳ Extendable systems grow smoothly over time. ↳ Follow the open-closed principle (OCP) to allow new features without modifying core functionality. Ensure API-first designs are backward compatible to support new integrations without disruptions. 𝗥𝗲𝘂𝘀𝗮𝗯𝗹𝗲 ↳ Reusable components accelerate development and improve maintainability. ↳ Design with composability, using shared libraries, SDKs, or reusable components. Apply domain-driven design (DDD) to promote reusability across business domains. By following these principles, we can build systems that meet today’s demands while staying adaptable to future challenges. Thoughtful architecture ensures scalability, security, and resilience while supporting continuous innovation. -- Thanks to Oracle who keeps our content free to the community. Did you hear about the Oracle26ai release? There’s also a free tier. Check it out (for free): https://lnkd.in/gg4QSV83 -- 🔖 Save this for later. ♻️ Repost it to help others learn system design. 🙋🏻‍♀️ Follow Nikki Siapno • Turn on notifications 🔔

644

41 Comments

Lambda Managed Instances is not just “Lambda on EC2.” It is AWS rewriting the boundary between functions and servers. Here is the thing: 🔹 𝗔 𝗻𝗲𝘄 𝗰𝗼𝗺𝗽𝘂𝘁𝗲 𝗺𝗼𝗱𝗲𝗹 Lambda keeps the serverless experience, but the capacity now comes from EC2 fleets you define. You still write functions. AWS still handles ops. But you choose the "hardware". 🔹 𝗧𝗵𝗲 𝗲𝗻𝗱 𝗼𝗳 𝘁𝗵𝗲 𝗰𝗼𝗹𝗱 𝘀𝘁𝗮𝗿𝘁 𝗲𝗿𝗮 Execution environments stay warm and handle multiple requests at once. This changes how you think about concurrency, state, and performance (when about talking lambda). 🔹 𝗘𝗖𝟮 𝗲𝗰𝗼𝗻𝗼𝗺𝗶𝗰𝘀 𝗶𝗻𝘀𝗶𝗱𝗲 𝗟𝗮𝗺𝗯𝗱𝗮 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 No duration based billing. Your Savings Plans and Reserved Instances apply. For steady workloads this shifts the cost model entirely.

79