Devanshi Choudhary

The https://microservices.io/ patterns cover different areas of microservice architecture: service decomposition, data consistency, service communication, deployment, and reliability. I recommend the following: Decompose by Business Capability and Subdomain: Define each service around specific business capabilities and use DDD for clear boundaries. Database Per Service: Ensure each microservice has an isolated data store. Saga Pattern for Consistency: Use sagas for handling distributed transactions, employing both choreography (event-driven pub-sub) and orchestration as needed. This is the most interesting for me for now! API Gateway and Backend for Frontend (BFF): Manage client access and tailor specific frontends. Circuit Breakers and Health Checks: Maintain reliability and resilience. #grekai #microservices #architecture

5

Checkout my latest post on "Observability in Microservices: Challenges and Solutions"

24

🔄 Navigating Distributed Transactions in Microservices Architecture? 🚀 Achieving ACID properties in a decentralized world of microservices isn't trivial, but with patterns like Saga, Two-Phase Commit (2PC), and Event Sourcing, it becomes feasible to ensure data integrity and consistency. Saga Pattern: Perfect for eventual consistency in long-running workflows with compensation strategies. Two-Phase Commit (2PC): Guarantees atomicity and consistency at the cost of latency—best for critical operations. Event Sourcing: Immutable logs and replayability ensure durability and a clear audit trail. While trade-offs are inevitable, choosing the right approach depends on your business domain, system throughput, and consistency requirements. 🛠 Explore how to maintain data sanity without compromising performance or scalability. #DistributedSystems #Microservices #ACIDTransactions #SagaPattern #EventSourcing #2PC #CloudArchitecture

15

Next on my series about Spring REST API with Java: "Spring REST API: PathVariable, RequestParam, RequestBody and Input Validation: How to remain safe while serving client request" #spring #rest #api #input #validation #security https://lnkd.in/gbqqDktC

4

Hi Folks, Here is today's Byte 💡: Expansion and Improvements in Azure OpenAI Service 🤖 : 🔹Now available in over 20 regions, supporting enhanced text and image analysis. 🔹Fine-tuning now follows token-based billing for easier cost management. 🔹CMK support for AI Assistants in more regions for better compliance and data control. 🔹 Critical dates for retiring older GPT models, allowing customers time to migrate. Area of Implementation 👨‍💻 : ➡ An e-commerce platform can now utilize Azure OpenAI GPT-4o for customer support and product recommendations across multiple languages. ➡ The inclusion of image-based analysis allows for better product categorization from user-uploaded images, improving both inventory management and customer interaction. Hope you find this Byte useful, do share your suggestions for any specific topic/concept 👍 Stay tuned for the next Byte... 🤓 #AzureBytes #azure #azurecloud #microsoft #microsoftazure #microsoftbuild #microsoftinspire #microsoftlearn #openai #ai #ml #gpt4o #keyvault #security #nlp #llm Azure Developer Community OpsTree Solutions

17

1 Comment

Top learnings from my discussion with Kishore Gopalakrishna - Language choice for system development should balance team expertise, hiring potential, and ecosystem maturity. A well-implemented system in a familiar language often outperforms a poorly implemented one in a "faster" language. - Distributed systems are complex - they can fail in unexpected ways, making your own computer useless. This challenge is often underestimated. Understand the failure modes. - When building new systems, design for the long-term (10 years) but plan for the near-term (2-3 years). Implement for current needs while keeping the architecture flexible for future growth. Design for long term, plan for short-medium term. - Testing distributed systems requires going beyond known test cases. Develop test frameworks that generate new scenarios automatically to uncover unforeseen issues. - Cost optimization in data systems often involves trade-offs. Kafka, for example, sacrificed transactionality and exact-once delivery for higher throughput and lower cost per log. Its all about the Trade-offs. You get some, you lose some. - When approaching problems, start with first principles. Understand why something is expensive or inefficient before trying to optimize it. Don't jump on a solution. Understand the real problem first. - Open-source success relies heavily on community building. Foster respectful communication, clear processes for resolving conflicts, and a culture of helpfulness to grow a strong contributor base. There are many communities, but only the ones with good culture thrive. - Real-time analytics can significantly boost user engagement. Even small reductions in data latency can lead to measurable improvements in user experience and product value. - When considering real-time analytics, focus on how it can improve your users' lives rather than just technical capabilities. Many support issues can be eliminated by giving users direct access to real-time data. Product isn't useful if it making users' lives better. - Innovation in data products often comes from changing perspective - instead of asking "Do we need this?", ask "How can this improve our users' experience?" This shift can uncover valuable use cases for real-time analytics. Asking the right questions will help you reach the right answers. - When building data products, consider the long-term evolution of technology. Design choices should anticipate future developments, such as improvements in network speed or storage capabilities. Keep your design extensible. - As users become more data-savvy, there's increasing demand for self-serve analytics tools. Empowering users with direct access to data can reduce support overhead and enable more informed decision-making. Empower users to do more with data quickly. ———————————————————————— In case you haven't watched the episode yet, you can watch it here: youtu.be/SmLlJmU9Daw Also subscribe if you like such discussions.

41

3 Comments

Hi Folks, Here is today's Byte 💡: Azure App Service: Enhanced Autoscaling Capabilities 🌐 : 🔹Automatically adjusts based on application usage, providing enhanced flexibility for scaling vertically and horizontally. 🔹With dynamic scaling, businesses can avoid overprovisioning and reduce operational costs, as the service scales according to actual workload demands. 🔹Create custom scaling rules based on CPU, memory, or custom application metrics, ensuring that applications handle traffic efficiently during high-load periods. 🔹 Azure App Service enhances app performance and availability, reducing downtime during high-traffic surges. Area of Implementation 👨‍💻 : ➡ A global e-commerce platform experiences high traffic surges during promotions and sales. ➡ Using Azure App Service's new autoscaling features, they can dynamically scale up resources to meet demand and scale down during low-traffic periods, ensuring cost-effectiveness and optimal performance. ➡ This avoids unnecessary over-provisioning while maintaining a responsive user experience. Hope you find this Byte useful, do share your suggestions for any specific topic/concept 👍 Stay tuned for the next Byte... 🤓 #AzureBytes #azure #azurecloud #microsoft #microsoftazure #microsoftbuild #microsoftinspire #microsoftlearn #webapps #appservices #azurewebapps #dynamicscaling #ha #observability Azure Developer Community OpsTree Solutions

18

Kubernetes Bin Packing ⚡ First lest understand what is bin packing. In simple terms, bin packing is a way of arranging items so that you use the least number of containers (or bins) possible. Imagine you have a bunch of items of different sizes and you need to pack them into boxes. Bin packing is about figuring out the best way to put those items into the boxes so that you use as few boxes as possible. In Kubernetes, bin packing works similarly but with resources. It means trying to use the available resources on each server or node as efficiently as possible, packing as many workloads as you can onto each node to minimize the number of nodes needed. In today blog, we will look at the following. 𝗡𝗼𝗱𝗲𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀𝗙𝗶𝘁 𝗽𝗹𝘂𝗴𝗶𝗻: It is part of the Kubernetes scheduler framework. Its primary function is to check if a node has sufficient resources to meet a pod's resource requests. For scoring, the NodeResourcesFit plugin can be configured to use any of the following scoring strategies 1. 𝗟𝗲𝗮𝘀𝘁𝗔𝗹𝗹𝗼𝗰𝗮𝘁𝗲𝗱 (Default strategy): This strategy aims to spread out the workload evenly across nodes to prevent any single node from being overloaded. 3. 𝗠𝗼𝘀𝘁𝗔𝗹𝗹𝗼𝗰𝗮𝘁𝗲𝗱 : In this, the scheduler will pick a node that is already using more resources but still has enough available resources for the new pod. 4. 𝗥𝗲𝗾𝘂𝗲𝘀𝘁𝗲𝗱𝗧𝗼𝗖𝗮𝗽𝗮𝗰𝗶𝘁𝘆𝗥𝗮𝘁𝗶𝗼: In this you can give different importance (weights) to different resources like CPUs and memory. For example, you might decide that CPUs are more important than memory for a particular pod. 𝗗𝗲𝘁𝗮𝗶𝗹𝗲𝗱 𝗕𝗹𝗼𝗴: https://lnkd.in/gdeQReXt ♻️ PS: Dont forget to Repost and share with the community. If you have any insights to share, feel free to leave a comment on this post or the blog. 𝗡𝗼𝘁𝗲: Scheduling in Kubernetes is a complex topic with many variables and intricacies. The content here is meant to serve as a starting point and may not cover every aspect or scenario related to pod scheduling. #DevOps #Kubernetes

89

3 Comments

Whenever #LangGraph persistence is discussed, it mostly talks about persisting state across nodes and edges throughout the workflow. It can be achieved even by in-memory persistence which is what is mostly talked, documented about. However, there is an additional subtle aspect to it which is to persist it on disk / in DB. It can help an application pick up where it had left off in case of a crash or restart.   I have done a YouTube video on it with details of how it can be done, its nuances, differentiating it from in-memory persistence, and how it can help any AI application. Appreciate any feedback. #GenAI

10

🌟 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 101: 𝗧𝗵𝗲 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗕𝗹𝗼𝗰𝗸𝘀 𝗼𝗳 𝗠𝗼𝗱𝗲𝗿𝗻 𝗖𝗹𝗼𝘂𝗱 𝗜𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 🌟 💡 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗱𝗿𝗶𝘃𝗶𝗻𝗴 𝗳𝗼𝗿𝗰𝗲 𝗯𝗲𝗵𝗶𝗻𝗱 𝗺𝗼𝗱𝗲𝗿𝗻 𝘀𝗰𝗮𝗹𝗮𝗯𝗹𝗲 𝗮𝗻𝗱 𝗿𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲. 𝗛𝗲𝗿𝗲’𝘀 𝗮 𝗾𝘂𝗶𝗰𝗸 𝗯𝗿𝗲𝗮𝗸𝗱𝗼𝘄𝗻 𝗼𝗳 𝗛𝗼𝘄 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 𝗪𝗼𝗿𝗸𝘀: 1️⃣ 𝗖𝗹𝘂𝘀𝘁𝗲𝗿: The Kubernetes cluster is a set of worker machines, called nodes, that run containerized applications. 2️⃣ 𝗡𝗼𝗱𝗲𝘀: Each node is a unit of computing that runs containerized apps, ensuring scalability. Every Kubernetes cluster has at least one worker node. 3️⃣ 𝗣𝗼𝗱𝘀: Worker nodes host pods, the smallest deployable units, which contain your application’s containers. 4️⃣ 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗣𝗹𝗮𝗻𝗲: This is the brain behind Kubernetes. It manages the worker nodes and pods via the API server, ensuring your application stays in its desired state. 🌐 Whether you’re 𝘀𝗰𝗮𝗹𝗶𝗻𝗴 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀, 𝗱𝗲𝗽𝗹𝗼𝘆𝗶𝗻𝗴 𝗻𝗲𝘄 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀, 𝗼𝗿 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝗺𝘂𝗹𝘁𝗶-𝗰𝗹𝗼𝘂𝗱 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁𝘀, Kubernetes is essential for managing the complexity of containerized applications with ease. #CloudNative #Kubernetes #DevOps #Containers #Microservices #CloudComputing #CloudArchitecture #KubernetesCluster #ITInfrastructure #TechTransformation Azure DevOps AWS DevOps KodeKloud

18

AWS News now supports RSS 🗞️ on custom feeds! Share the RSS link with friends and colleagues and they will automatically stay up-to-date with your updates. Let me know what you think! Link in the comment below.

17

2 Comments

𝐓𝐇𝐑𝐄𝐀𝐃 𝐒𝐀𝐅𝐄𝐓𝐘 - 𝙆𝙚𝙚𝙥𝙞𝙣𝙜 𝙩𝙝𝙚 𝙆𝙞𝙩𝙘𝙝𝙚𝙣 𝘾𝙡𝙚𝙖𝙣 𝙒𝙝𝙞𝙡𝙚 𝙈𝙪𝙡𝙩𝙞𝙥𝙡𝙚 𝘾𝙤𝙤𝙠𝙨 𝙒𝙤𝙧𝙠 𝙏𝙤𝙜𝙚𝙩𝙝𝙚𝙧 👩‍🍳👨‍🍳 🧠 𝐉𝐚𝐯𝐚 𝐁𝐮𝐟𝐟𝐞𝐭 : Day 6 of #30DaysOfJava (Extending analogy of Post 3 : https://lnkd.in/g3uBywUN) Picture a busy kitchen where multiple cooks are working on different dishes. Now, imagine they’re all using the same cutting board, and if they’re not careful, they could end up spilling ingredients everywhere, mixing up their dishes, or even cutting each other’s fingers! This is why we need thread safety in @Java. In Java, thread safety ensures that multiple threads can work with shared resources (like a cutting board) without causing errors or conflicts. Properly managing these shared resources, whether it’s by using locks or other mechanisms, keeps everything organized and prevents mistakes—just like in a well-run kitchen where each cook respects the shared tools and space. 📌 Key Takeaway: Thread safety in Java is like making sure multiple cooks can work together in a shared kitchen without making a mess or hurting each other! #java #Oracle

14

6 Comments

Java, a powerhouse in software development, continues to evolve to meet modern demands. Exciting new features in Java 17 like pattern matching and records enable cleaner, more efficient code. Cloud-native Java thrives with frameworks like Spring Boot and Quarkus, simplifying microservices and Kubernetes integration. Reactive programming with Project Reactor enhances responsiveness and scalability, while big data solutions using Apache Hadoop and Spark leverage Java’s robust performance. Embrace Java’s versatility for enterprise applications and cutting-edge cloud services. Stay innovative with Java! 🚀 #Java #SoftwareDevelopment #Java17 #CloudNative #ReactiveProgramming #BigData #Innovation #Tech

6

Had a long and interesting discussion with Sandeep Raghuwanshi about “Non functional requirements” and how #Devops engineers and teams get to influence them. Long story short: There are no “non functional requirements” today. Especially for GenZ and GenAlpha users who started their internet journey with apps like Insta, YouTube: availability, responsiveness, simplicity of CX, and data privacy are the primary requirements from any app or service. Falter on these fronts and they will walk away. These cannot be an afterthought, however early you are in your app lifecycle.

51

2 Comments

Design systems as if you were the one who will maintain them. Few nuggets to keep handy, while designing a scalable system: https://lnkd.in/g_udCNm3 #systemdesign #scalability #performance

15

Patterns of Legacy Displacement : Effective modernization of legacy software systems When faced with the need to replace existing software systems, organizations often fall into a cycle of half-completed technology replacements. Our experiences have taught us a series of patterns that allow us to break this cycle, relying on: a deliberate recognition of the desired outcomes of displacing the legacy software, breaking this displacement in parts, incrementally delivering these parts, and changing the culture of the organization to recognize that change is the unvarying reality. "It is vital for an organization to agree the outcomes they want to achieve when tackling legacy. While this may seem obvious, all too often different parts of an organization can have quite different views on the desired outcomes." This is an interesting reading: 📖

5

How do you achieve high availability with leader-based replication ? For achieving high availability with leader-based replication ,the system should handle both leader and follower failure . https://lnkd.in/g3wgQEZe

5