USE vs RED - which is the better methodology for analyzing the performance of microservices 🤔? 🧵
Begin observing the performance characteristics of apps before the production rollout using Google's four golden signals. #ShiftLeft ibm.com/garage/method/…
The RED method takes an externally-visible (request-driven) view of the workload. For every workload, it checks request rate, error-rate, time each request takes. weave.works/blog/the-red-m…
The USE method takes an internal, resource-centric view of the workload. For every resource, it checks utilization, saturation, and errors. The goal is to understand how these resources behave in the presence of the load. brendangregg.com/usemethod.html
➡️ Start with RED and treat the services as a black box. Best for request-driven apps.
➡️ Combine with USE to check stateful/non-request-based systems and components as white box.
➡️ If none helps, check logs and traces too. copyconstruct.medium.com/logs-and-metri…
• • •
Missing some Tweet in this thread? You can try to
force a refresh
Book review 🌟Software Architecture Patterns for Serverless Systems🌟 by John Gilbert
TLDR: dissects the #serverless landscape into key patterns and mindset that everyone developing cloud applications must know!
🧠Top 3 ideas from this book are: 🧵👇
1) Autonomous service - owns all the resources it needs to continue to function even when other services cannot. Its building blocks are: Command, Publish, Consume, Query (CPCQ)
CPCQ - this is the core serverless pattern👇
2) There are three high-level autonomous service patterns that all other services fall under
▶️Backend for Frontend (BFF),
▶️External Service Gateway (ESG)
▶️Control Service
Book review 📕Solutions Architect's Handbook📕by
@it_saurabh & Neelanjali Srivastav
TLDR: probably the the most comprehensive guide, with the right balance of breadth and depth, for anyone aspiring to become a Solutions Architect 🧵👇 1/7
1/5 📢 Excited to share my new blog post on
🌟Application Networking Trends🌟 @thenewstack
We are witnessing a shift where networking concerns either sink down ⬇️ to the compute layer, or raise up ⬆️ into de facto APIs in the cloud. Let's dive into it!
2/5 ⬇️🕸️Transparent networking will keep descending and disappearing.
If the network doesn't change the data, if the devs and apps are not aware of it (ex: Auth, mTLS, tracing, routing, discovery) it'll keep sinking to compute layer, sidecar, proxy, or even Linux kernel w/ eBPF
3/5 ➡️🔌 Synchronous (stateless) networking will move away from applications into plug-and-play components.
If the data changes, developers must know (ex: connectors, transformation, content-based routing, aggregate, split). These patterns will become polyglot and reusable.
Book review: "Scalable Data Architecture with Java" from @PacktPublishing
TL;DR: provides a practical exploration of wide-range of data-driven solutions for Java developers looking to get a direction in the ecosystem🧵👇
👍Ideal Reader:
Java developers who already have a some understanding of backend systems and are keen on getting understanding of the broad data ecosystem, its architectures, and the inherent challenges.
👎Not a Great Fit for:
Senior developers looking for an in-depth understanding of data solutions. While this book provides a broad overview, it might not delve into the depth that experienced professionals may seek. For the latter, I recommend this
TLDR of timelines, app, infra, API changes 👇🧵(0..4)
1⃣ The pre-cloud/early cloud Era:
This is the time of monolithic apps and static raw on-prem infrastructure.
➡️In this era, the monolith contains and does everything it needs to. Devs responsible for most.
➡️The OS primitives are the interface with infra (static IPs and VMs)
2⃣The infrastructure/compute centric cloud era
This is the time of transition to microservices & raw cloud infra
➡️ Dynamic compute, networking, and storage cloud services (not app centric)
➡️ Containers emerging as de facto app packaging & compute format, & HTTP for networking
Both projects help create & run cloud-native applications on Kubernetes, but differ in important aspects.
I thought I'd quickly share where these projects overlap and complement each other from a user point of view. 0/10
1⃣Community
Knative originated from Google, whereas Dapr from Microsoft. Today both projects are incubating at CNCF.
Both projects have growing communities and are within top 20 active CNCF projects (Dapr #10 and Knative #17)
2⃣Primary focus area
Knative extends Kubernetes with serverless containers by taking care of runtine networking (sync/async), autoscaling (to/from zero), and app revision tracking...