#Microservices
34 notas · última:
Jonas Bonér on the Actor Model, Akka, Reactive Programming, Microservices and Distributed Systems
Jonas Bonér presents Akka as a JVM toolkit for distributed systems, links the Actor Model to message passing and fault handling, and frames microservices as full systems built for resilience.
Breaking It Down: How to Migrate Your Modular Monolith to Microservices
The article says to migrate one module at a time, first tightening boundaries and data ownership, then extracting a low-coupling module, switching communication to HTTP or messaging, and adding an API gateway and data migration plan.
Revisiting the Outbox Pattern
The article revisits the outbox pattern for microservices, explains how it keeps database updates and event publication atomic, and compares it with polling, CDC, 2PC, and other alternatives.
What Is Service Discovery?
The article explains service discovery as the process of finding healthy service instances in a microservice system, compares implementation options, and recommends using a replicated service registry for scalable setups.
How to end-to-end test microservices across bounded contexts?
The article explains how E2E testing across bounded contexts should be split between microservice teams, QA, and full-stack teams, and compares hosted services with mocks for cross-team integration tests.
Death By a Thousand Microservices
The article argues that microservices often add complexity, tooling, coordination, and testing costs without matching scale needs, while monoliths and simpler service boundaries often work better.
8 Must-Know Distributed System Design Patterns
The page lists common distributed system patterns and what each one addresses: offloading cross-cutting tasks, handling failures, separating reads and writes, partitioning data, coordinating services, and replaying state changes.
Implementing API Gateways with Ocelot - .NET
The page explains how Ocelot forwards upstream requests to downstream microservices, how configuration.json defines routes, and why multiple API gateways and BFFs can better fit autonomous teams.
Patterns & Best Practices in Event-Driven Systems — Kogan.com Dev Blog
The text presents EDA patterns such as event notification, ECST, event sourcing, choreography, and orchestration, as well as practices for idempotency, versioning, schema management, and correlation IDs.
The Best Microservices Design Patterns Explained Like You’re Ordering Pizza
The article explains 11 microservices design patterns with a pizza analogy, showing how each one maps to service boundaries, requests, data storage, failures, workflows, legacy migration, and frontend-specific backends.
A Go Microservices Demo using Go kit And API Gateway Pattern
The article shows how to turn go-kit stringsvc3 into a more practical demo by adding Consul-based service discovery, an API gateway client, Docker images, and round-robin load balancing.
Micro And Macro Software Architectures, Why You Need Both
Draws the line between macro architecture decisions a company makes once for everyone and micro architecture decisions each team makes for itself, and argues both need to be explicit.
From Microservices to Modular Monoliths
Argues that teams stuck in microservice hell should migrate back to modular monoliths, keeping modularity without distributed-system overhead.
Why I Built Things-Kit: A Spring Boot Alternative for Go
The author explains how repetitive Go microservice setup led to Things-Kit, a modular framework on Uber Fx that packages configuration, logging, HTTP, database, cache, and lifecycle handling.
Just Enough Distribution (JED) on Monoliths and Microservices
The post rejects extreme claims about monoliths and microservices, saying the right architecture depends on context, constraints, team expertise, cost, reliability, and time to market, with a middle-ground approach preferred.
What I learned from Software Architecture: The Hard Parts
The post highlights the book’s focus on tradeoff analysis, modularity drivers, and two ways to break a monolith into microservices, while noting the lack of implementation detail and the abstract, fictional structure.
Discussing Backend For Front-end
The post explains why mobile clients and microservices make over-fetching expensive, and presents Backend For Front-end as a client-specific layer that fetches, filters, aggregates, and returns the needed data.
Distributed Transaction Management in Microservices — Part 1
The article explains why distributed transactions are hard in microservices, compares them with monoliths, and outlines 2PC and 3PC before motivating asynchronous Saga patterns.
An Alternative to Outbox Pattern for Microservices Architecture
The article proposes a 2-phase message built on DTM as an alternative to Outbox. It uses Prepare and Submit plus a check-back service to keep business execution and message submission atomic.
Building Microservices With Security in Mind
The article says microservices, open architecture, DevSecOps, and observability help banks and fintech teams ship faster while keeping security checks, testing, and monitoring inside the delivery flow.
Orchestration and choreography - ByteByteGo System Design
The page contrasts choreography and orchestration in microservices, showing orchestration as centralized control with transaction management and easier rule changes, but also higher latency and a single point of failure.
10 Books Every Senior Engineer Should Read
Semaphore lists ten books that shaped its engineering culture, covering agile practice, delivery pipelines, remote work, project management, data systems, SRE, microservices, and modern software engineering.
Moving to Microservices at SoundCloud with Lukasz Plotnicki
An episode of Software Engineering Daily where Lukasz Plotnicki discusses SoundCloud’s move from a monolith to microservices, the technical debt it created, and the lessons learned about architecture.
If You've Written Java Code in 2015 – Here Are The Trends You Couldn't Have Missed
The post reviews five 2015 Java trends: Java 8 adoption, Java 9 progress, microservices, Docker and Alpine images, log management, and related work in Scala, Spark, and automation.
Stories of Elixir in the Wild: Interview with Johnny Winn
Interview with Johnny Winn about his Elixir projects, a company move toward microservices, what he values in Elixir, the main difficulty he hit, and resources he recommends.
Elixir in times of microservices
The post argues that Elixir and the Erlang VM already provide the abstractions, process isolation, and communication model needed to manage distributed systems and grow applications without premature microservice splits.
MonolithFirst
The page argues for starting new applications as a monolith, since microservices add overhead, depend on stable boundaries, and are easier to adopt later after the system’s shape becomes clearer.
Where does Elixir/erlang fit into the microservices approach?
The post asks how Elixir and Erlang relate to microservices, Docker, hot code upgrades, and deployment patterns such as blue/green and canary releases. The accepted answer frames OTP as a distributed-systems platform that already models isolated units, communication, and deployment choices.
Microservices
The article defines microservices as a way to build an application from small, independently deployable services and explains why this can reduce monolith pain through clearer boundaries, automation, and decentralized decisions.
Architecture is abstract until operationalized
The post argues that software architecture is only a snapshot until it is implemented, upgraded, monitored, and able to survive real operational conditions. DevOps, continuous delivery, and microservices make those concerns part of design.
My Answers for Microservices Awkward Questions
The author frames his microservices experience as a report about reducing accidental coupling, then answers questions about deployment, ownership, monitoring, tracing, and what counts as a production-ready service.
Managing your Microservices on Heroku with Netflix's Eureka
The article shows how to deploy Netflix Eureka on Heroku, register a microservice client, and add replica server instances for redundancy using Spring Cloud and Heroku config.
The Death of the SLA
The article argues that negotiating cloud SLAs is a waste of time because providers already focus on availability, penalties are limited, and the legal approach distracts from technical design for failure.
Why Microservices Matter
Heroku argues that microservices help large teams scale by splitting applications into smaller services, but they also add operational overhead, testing complexity, and integration costs.