Best of Microservices — November 2024

  1. 1
    Article
    Avatar of asayerasayer·1y

    API Gateway Patterns and Practices

    API gateways consolidate and manage incoming client requests to various backend services, handling tasks such as routing, rate limiting, authentication, and monitoring. They simplify front-end integration with backend services, optimize performance through caching and load balancing, and enhance security by centralizing authentication and authorization. Common patterns include Backends for Front-ends (BFF), API Gateway Aggregation, and Circuit Breaker for resilience. Best practices involve scalability consideration, implementing security measures like JWT authentication, caching strategies, and comprehensive logging and monitoring.

  2. 2
    Article
    Avatar of theburningmonktheburningmonk.com·1y

    When to use Light Events vs. Rich Events in Event-Driven Architectures

    Choosing between light and rich events in event-driven architectures involves trade-offs. Light events, containing minimal information, are cost-efficient but may increase complexity for subscribers needing additional data. Rich events include more information, reducing the need for extra calls by subscribers but increasing data transfer and storage costs. Domain events, often benefitting from light events, are shared within the same domain, while integration events, suited for rich events, are shared across domains. Understanding these differences helps optimize event design and system efficiency.

  3. 3
    Article
    Avatar of bytebytegoByteByteGo·1y

    How McDonald Sells Millions of Burgers Per Day With Event-Driven Architecture

    McDonald's has developed a unified, event-driven platform to handle its global operations efficiently. The platform supports scalability, high availability, performance, security, reliability, consistency, and simplicity. Core components include AWS Managed Streaming for Kafka (MSK), a schema registry, a standby event store, custom SDKs, and an event gateway. The system ensures data integrity and efficient processing through schema validation and robust error-handling mechanisms. Key techniques include data governance, cluster autoscaling, and domain-based sharding. Future enhancements include formal event specification, transition to serverless MSK, and improved developer tooling.

  4. 4
    Article
    Avatar of venturebeatVenture Beat·1y

    Why microservices might be finished as monoliths return with a vengeance

    Many organizations are re-evaluating the trend towards microservices and returning to monolithic architectures. This change is driven by the difficulties encountered during the transition, such as defining domain boundaries, managing deeply coupled data, and handling complex data migrations. Despite the theoretical advantages of microservices, practical implementation challenges often outweigh the benefits, leading to issues like increased system complexity, data integrity problems, and unclear team ownership.

  5. 5
    Article
    Avatar of communityCommunity Picks·1y

    How To Build A Containerized Microservice in Golang: A Step-by-step Guide with Example Use-Case

    Learn how to build a cloud-native application using Golang and microservices architecture. The guide covers setting up microservices, leveraging the Go-Kit framework, developing APIs using REST and gRPC, and deploying on Azure. Follow along to create a document watermarking service with three microservices: Authentication, Database, and Watermark Service. Detailed steps include project structure, service implementation, and setting up HTTP and gRPC transports.

  6. 6
    Article
    Avatar of freecodecampfreeCodeCamp·1y

    How to Build Multi-Module Projects in Spring Boot for Scalable Microservices

    The post provides a detailed guide on building a multi-module project in Spring Boot, emphasizing modularity, scalability, and manageability. Key topics include setting up modules, configuring inter-module communication using REST APIs and message brokers like Kafka, implementing JWT-based security, and deploying with Docker. It also covers common pitfalls and solutions, testing strategies, and best practices for maintaining and scaling a multi-module architecture.

  7. 7
    Article
    Avatar of microservicesioMicroservices.io·1y

    Reducing insider trading in a microservice architecture

    Reducing insider trading in microservice architectures involves ensuring loose design-time coupling by avoiding direct database queries between services and using APIs instead. However, APIs alone don't guarantee loose coupling. Encapsulation is crucial, where each service hides its internal data and logic, resembling icebergs. This approach, applied in examples like takeout burritos, helps manage dependencies and improve the maintainability of the system.

  8. 8
    Video
    Avatar of joshtriedcodingJosh tried coding·1y

    What Large-Scale Software Looks Like

    Discover what distinguishes enterprise-scale software from regular applications through an exploration of a viral Next.js monorepo template. This comprehensive template includes features like authentication, billing via Stripe, analytics, SEO, and more, all geared towards rapidly building a SaaS application. Key highlights include the use of a microservice architecture for the API, reusable packages for scalability, and a focus on extendability and reusability to maintain large codebases efficiently.

  9. 9
    Article
    Avatar of cerbosCerbos·1y

    How to pick the right inter-service communication pattern for your microservices

    Efficient inter-service communication is essential for a successful microservices architecture. Different communication patterns, such as synchronous, asynchronous, and event-driven, offer various benefits and challenges. Strategies like retries, circuit breakers, timeouts, and bulkheads can enhance fault tolerance and resilience. Spotify's adoption of Apache Kafka for event-driven communication illustrates a scalable and decoupled microservices environment, supporting independent service evolution and robust failure management.

  10. 10
    Article
    Avatar of cerbosCerbos·1y

    Why external authorization is essential for modern software architecture

    External authorization decouples access control logic from application code by delegating decisions to a centrally managed service within your infrastructure. This approach is particularly valuable during transitions from monolith to microservices architectures but is also beneficial for established systems. It ensures consistent, manageable, and scalable authorization policies, improves security, and facilitates compliance and auditing. Implementing it can be done incrementally, reducing disruption and complexity.

  11. 11
    Article
    Avatar of cerbosCerbos·1y

    Designing service discovery and load balancing in a microservices architecture

    Transitioning from a monolithic architecture to microservices involves navigating numerous challenges, including service discovery and load balancing. Dynamic service discovery mechanisms, such as service registries and service meshes, are essential for maintaining flexibility and resilience. Service registries maintain a centralized database of services, enabling features like load balancing, health checks, and metadata storage. Service meshes take this further by managing service-to-service communication, traffic management, security, observability, resilience, and policy enforcement. Tools like NGINX, HAProxy, and cloud-based load balancers also assist in distributing traffic efficiently. Airbnb's use of a proprietary solution, SmartStack, showcases the effectiveness of these systems in a complex microservices architecture.

  12. 12
    Article
    Avatar of newstackThe New Stack·1y

    How To Fail at Microservices

    Microservices can fail due to numerous reasons, such as delaying problem fixes, using shared databases, making services too small, relying on manual deployments, and focusing only on unit testing. Success requires automating deployments, using various testing techniques, improving local testing capabilities, creating robust tooling, fostering technical proficiency, simplifying complexity, and developing comprehensive documentation. Regular refactoring and a solid, adaptable architectural vision are also vital.

  13. 13
    Video
    Avatar of communityCommunity Picks·1y

    Implementing the Transactional Outbox Pattern from Scratch

    The post discusses the implementation of the transactional outbox pattern, demonstrating how to reliably update the database and publish messages to a queue using an orders API and a shipping API. It explains potential issues with traditional methods where a transaction could leave the system in an inconsistent state. The outbox pattern is proposed as a solution, which involves persisting messages in the database as part of the same transaction and processing them later. The post thoroughly explains how to set up and implement this pattern, highlighting key considerations and potential improvements for reliability.

  14. 14
    Article
    Avatar of mercariMercari Engineering·1y

    Designing a Zero Downtime Migration Solution with Strong Data Consistency – Part I

    This post provides an overview of a planned migration from a single-entry bookkeeping balance microservice (v1) to a double-entry bookkeeping balance microservice (v2) for a payment platform. The v2 service aims to reduce development costs and provide more organized and modern code. The post outlines the tech stack, current architecture, and different aspects of accounting, historical data, and bookkeeping services involved in the migration. The plan is spread across five parts, each covering different stages and elements of the migration.

  15. 15
    Article
    Avatar of cerbosCerbos·1y

    How to address decentralized data management in microservices

    Transitioning from monolithic to microservices architecture includes challenges and benefits in handling decentralized data management. The post discusses the advantages like scalability, flexibility, performance, and fault isolation, alongside challenges such as complex data integration, increased development complexity, latency issues, and security risks. It details patterns and techniques like eventual consistency, Saga pattern, event sourcing, domain-driven design (DDD), and command query responsibility segregation (CQRS) to mitigate these challenges. Uber's case study highlights practical implementation of these methods to maintain data integrity and ensure system reliability.

  16. 16
    Video
    Avatar of communityCommunity Picks·1y

    Stop Hardcoding Service URLs! Service Discovery in .NET Made Easy

    Learn how to implement service discovery in .NET applications to avoid hardcoding service URLs. This guide demonstrates setting up service discovery using Microsoft.Extensions.ServiceDiscovery and YARP for reverse proxying, and even incorporating it into the deployment process with Azure. Enhance your microservices' communication flexibility and ensure seamless scaling and updating by using logical names instead of static URLs.

  17. 17
    Article
    Avatar of telerikTelerik·1y

    Getting Started with Domain-Driven Design in ASP.NET Core

    Domain-driven design (DDD) aligns code structure with business logic to address complex problems. This guide introduces the basics of DDD and steps for creating a microservice using ASP.NET Core, focusing on strategic and tactical design. It covers setting up various layers, including domain, infrastructure, and application, and provides a practical example of a commission processing module, complete with code snippets and explanations.

  18. 18
    Article
    Avatar of bytebytegoByteByteGo·1y

    Uber’s Billion Trips Migration Setup with Zero Downtime

    Uber successfully migrated its complex trip fulfillment infrastructure to a hybrid cloud environment without any downtime. The original system, with its 'pod' architecture, managed millions of transactions daily. However, scalability issues led to a migration that consolidated services and improved data consistency. Key strategies included backward compatibility layers, shadow validation, traffic pinning, and detailed observability tools to ensure a seamless transition. Despite complex challenges, these methods minimized user impact and maintained system stability.

See all Microservices archives