rhetenor/awesome-awesomeness
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update lists

Browse Source
This commit is contained in:
Jonas Zeunert
2025-07-18 22:22:32 +02:00
parent 55bed3b4a1
commit 5916c5c074
3078 changed files with 331679 additions and 357255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
terminal/microservices
View File

@@ -1,4 +1,4 @@
 Awesome Microservices !Awesome (https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg) (https://github.com/sindresorhus/awesome)
 Awesome Microservices !Awesome (https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg) (https://github.com/sindresorhus/awesome)
A curated list of Microservice Architecture related principles and technologies.
@@ -26,7 +26,7 @@
- Capabilities (#capabilities)
 - API Gateways / Edge Services (#api-gateways--edge-services)
 - Configuration & Discovery (#configuration--discovery)
 - Coordination & Governance (#coordination--governance)
 - Workflow Orchestration (#workflow-orchestration)
 - Elasticity (#elasticity)
 - Job Schedulers / Workload Automation (#job-schedulers--workload-automation)
 - Logging (#logging)
@@ -93,9 +93,11 @@
- Ice (https://zeroc.com/) - Comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python, and more.
- Light-4j (https://github.com/networknt/light-4j) - A high throughput, low latency, small memory footprint and more productive microservices platform.
- Micronaut (http://micronaut.io/) - A modern, JVM-based, full-stack framework for building modular, easily testable microservice applications.
- Modus (https://github.com/hypermodeinc/modus) - An open source, serverless framework for building intelligent functions and APIs, powered by WebAssembly.
- Moleculer (http://moleculer.services/) - Fast & powerful microservices framework for Node.js, Java, Go and Ruby.
- Open Liberty (https://openliberty.io/) - A lightweight open framework for building fast and efficient cloud-native Java microservices.
- Orbit (https://github.com/orbit/orbit) - Modern framework for JVM languages that makes it easier to build and maintain distributed and scalable online services.
- Pears (https://github.com/holepunchto/pear) - Peer-to-peer runtime, development and deployment.
- SmallRye (https://smallrye.io/) - APIs and implementations tailored for cloud development, including Eclipse MicroProfile.
- Spin (https://github.com/fermyon/spin) - An open source framework for building and running fast, secure, and composable cloud microservices with WebAssembly.
- ScaleCube (https://github.com/scalecube/scalecube) - Toolkit for building reactive microservices for the JVM: low-latency, high-throughput, scalable and resilient.
@@ -108,14 +110,13 @@
Polyglot
- GRPC (http://www.grpc.io/) - A high performance, open source, general RPC framework that puts mobile and HTTP/2 first. Libraries in C, C++, Java, Go, Node.js, Python, Ruby, Objective-C, PHP and C#.
- Hprose (http://github.com/hprose) - A very newbility RPC Library, support 25+ languages now.
- Hprose (http://github.com/hprose) - A very newability RPC Library, support 25+ languages now.
C
- Kore (https://kore.io/) - Easy to use web application framework for writing scalable web APIs in C.
- Libasyncd (https://github.com/wolkykim/libasyncd/) - Embeddable event-based asynchronous HTTP server library for C.
- Libslack (http://libslack.org/) - Provides a generic agent oriented programming model, run time selection of locking strategies, functions that make writing daemons trivial and simplify the implementation of network servers and 
clients, &c.
- Libslack (http://libslack.org/) - Provides a generic agent oriented programming model, run time selection of locking strategies, functions that make writing daemons trivial and simplify the implementation of network servers and clients, &c.
- Lwan (http://lwan.ws/) - High-performance and scalable web server.
- Onion (https://github.com/davidmoreno/onion) - C library to create simple HTTP servers and web applications.
@@ -131,8 +132,7 @@
CSharp
- Awesome Microservices .NET Core (https://github.com/mjebrahimi/Awesome-Microservices-NetCore) :star: - A collection of awesome training series, articles, videos, books, courses, sample projects, and tools for microservices in .NET 
Core.
- Awesome Microservices .NET Core (https://github.com/mjebrahimi/Awesome-Microservices-NetCore) :star: - A collection of awesome training series, articles, videos, books, courses, sample projects, and tools for microservices in .NET Core.
- Akka.NET (http://getakka.net/) - Toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on .NET & Mono.
- Orleans (https://dotnet.github.io/orleans/) - Provides a straightforward approach to building distributed high-scale computing applications, without the need to learn and apply complex concurrency or other scaling patterns.
@@ -194,8 +194,8 @@
- Disruptor (https://github.com/LMAX-Exchange/disruptor) - High-performance inter-thread messaging library.
- Dropwizard (https://dropwizard.github.io/) - Java framework for developing ops-friendly, high-performance, RESTful web services.
- Dubbo (https://github.com/apache/dubbo) - A high-performance, java based RPC framework open-sourced by Alibaba.
- Conjure (https://github.com/palantir/conjure-java-runtime) - Opinionated set of libraries for defining and creating RESTish/RPC servers and clients based on Feign or Retrofit as a client and Dropwizard/Jersey with JAX-RS service 
definitions as a server.
- Conjure (https://github.com/palantir/conjure-java-runtime) - Opinionated set of libraries for defining and creating RESTish/RPC servers and clients based on Feign or Retrofit as a client and Dropwizard/Jersey with JAX-RS service definitions as 
a server.
- Jersey (https://github.com/eclipse-ee4j/jersey) - RESTful services in Java. JAX-RS reference implementation.
- Quarkus (https://quarkus.io/) - A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.
- Ratpack (https://ratpack.io/) - Set of Java libraries that facilitate fast, efficient, evolvable and well tested HTTP applications. specific support for the Groovy language is provided.
@@ -216,7 +216,6 @@
Node.js
- Actionhero (http://www.actionherojs.com/) - Multi-transport Node.js API server with integrated cluster capabilities and delayed tasks.
- Cyclic.sh (c) (https://app.cyclic.sh/) - Simple serverless platform and dev tools for node.js services with Express.js support.
- Express (http://expressjs.com/) - Fast, unopinionated, minimalist web framework for Node.js
- Fastify (https://www.fastify.io/) - Fastify, Fast and low overhead web framework, for Node.js.
- FeathersJS (http://feathersjs.com/) - An open source REST and realtime API layer for modern applications.
@@ -237,13 +236,13 @@
PHP
- API Platform (https://api-platform.com/) - API-first web framework on top of Symfony with JSON-LD, Schema.org and Hydra support.
- Ecotone (https://docs.ecotone.tech/) - Framework based on architectural principles of DDD, CQRS and Event Sourcing that provides building blocks to create scalable and extensible applications. 
- Ecotone (https://docs.ecotone.tech/) - Framework based on architectural principles of DDD, CQRS and Event Sourcing that provides building blocks to create scalable and extensible applications.
- Hyperf (https://github.com/hyperf/hyperf) - Hyperf is an extremely performant and flexible PHP CLI framework based on Swoole 4.5+, powered by the state-of-the-art coroutine server and a large number of battle-tested components.
- Lumen (https://lumen.laravel.com/) - Stunningly fast micro-framework.
- Phalcon (https://phalconphp.com/) - Full-stack PHP framework delivered as a C-extension.
- Slim (http://www.slimframework.com/) - Micro-framework that helps you quickly write simple yet powerful web applications and APIs.
- Spiral (https://spiral.dev/) - Framework designed for long-running applications using RoadRunner (https://roadrunner.dev/). It offers advanced features like integration with the Temporal (https://temporal.io/) workflow engine and 
Centrifugo (https://centrifugal.dev/) websocket server. It is particularly effective for microservices architecture, providing robust support for REST APIs and gRPC services.
- Spiral (https://spiral.dev/) - Framework designed for long-running applications using RoadRunner (https://roadrunner.dev/). It offers advanced features like integration with the Temporal (https://temporal.io/) workflow engine and Centrifugo 
(https://centrifugal.dev/) websocket server. It is particularly effective for microservices architecture, providing robust support for REST APIs and gRPC services.
- Swoft (https://github.com/swoft-cloud/swoft/) - PHP microservices coroutine framework for building high-performance web systems, APIs, middleware, and basic services.
- Symfony (https://symfony.com/) - Micro-framework based on the Symfony components.
@@ -275,6 +274,7 @@
- Actix (https://actix.rs/) - Powerful, pragmatic, and extremely fast web framework for Rust.
- Tarpc (https://github.com/google/tarpc) - RPC framework for Rust with a focus on ease of use.
- Tower (https://github.com/tower-rs/tower) - Library of modular and reusable components for building robust networking clients and servers.
- Wtx (https://github.com/c410-f3r/wtx) - HTTP/2 client/server framework.
Frontend / UI
@@ -328,22 +328,22 @@
- Spring Cloud Config (http://cloud.spring.io/spring-cloud-config/) - Provides server and client-side support for externalized configuration in a distributed system.
- ZooKeeper (https://zookeeper.apache.org/) - Open source server which enables highly reliable distributed coordination.
Coordination & Governance
Workflow Orchestration
- AWS Step Functions (c) (https://aws.amazon.com/step-functions/) - Coordinate the components of distributed applications and microservices using visual workflows.
- Cadence (https://cadenceworkflow.io/) - Fault-oblivious stateful code platform.
- Conductor (https://github.com/Netflix/conductor) - A microservices orchestration engine.
- Inngest (https://github.com/inngest/inngest) - Durable functions for reliable background logic, from background jobs to complex workflows.
- Kestra (https://github.com/kestra-io/kestra) - Open source microservices event-driven, language-agnostic orchestration and scheduling platform.
- Temporal (https://github.com/temporalio/temporal) - Open source microservices orchestration platform for running mission critical code at any scale.
- Zeebe (https://camunda.com/platform/zeebe/) - Define, orchestrate, and monitor business processes across microservices.
Elasticity
- Hazelcast (http://hazelcast.org/) - Open source in-memory data-grid. Allows you to distribute data and computation across servers, clusters and geographies, and to manage very large data sets or high data ingest rates. Mature 
technology.
- Hazelcast (http://hazelcast.org/) - Open source in-memory data-grid. Allows you to distribute data and computation across servers, clusters and geographies, and to manage very large data sets or high data ingest rates. Mature technology.
- Helix (http://helix.apache.org/) - Generic cluster management framework used for the automatic management of partitioned, replicated and distributed resources hosted on a cluster of nodes.
- Ignite (http://ignite.apache.org/) - High-performance, integrated and distributed in-memory platform for computing and transacting on large-scale data sets in real-time, orders of magnitude faster than possible with traditional 
disk-based or flash technologies.
- Ignite (http://ignite.apache.org/) - High-performance, integrated and distributed in-memory platform for computing and transacting on large-scale data sets in real-time, orders of magnitude faster than possible with traditional disk-based or 
flash technologies.
- Libp2p (https://libp2p.io/) - A framework and suite of protocols for building peer-to-peer network applications.
- Mesos (https://mesos.apache.org/) - Abstracts CPU, memory, storage, and other compute resources away from machines (physical or virtual), enabling fault-tolerant and elastic distributed systems to easily be built and run effectively.
- Nomad (https://www.nomadproject.io/) - Distributed, highly available, datacenter-aware scheduler.
@@ -416,8 +416,8 @@
Resilience
- Awesome Chaos Engineering (https://github.com/dastergon/awesome-chaos-engineering) :star: - A curated list of awesome chaos engineering resources.
- Hystrix (https://github.com/Netflix/Hystrix) - Latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex 
distributed systems where failure is inevitable.
- Hystrix (https://github.com/Netflix/Hystrix) - Latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed 
systems where failure is inevitable.
- Raft Consensus (http://raftconsensus.github.io/) - Consensus algorithm that is designed to be easy to understand. It's equivalent to Paxos in fault-tolerance and performance.
- Resilience4j (https://github.com/resilience4j/resilience4j) - Fault tolerance library designed for Java8 and functional programming.
- Resilient HTTP (http://resilient-http.github.io/) - A smart HTTP client with super powers like fault tolerance, dynamic server discovery, auto balancing and reactive recovery, designed for distributed systems.
@@ -425,6 +425,7 @@
Security
- Cerbos Hub (https://www.cerbos.dev/product-cerbos-hub) - Authorization management system for authoring, testing, and deploying access policies. Built scalable, fine-grained authorization in a microservice architecture.
- Dex (https://github.com/coreos/dex) - Opinionated auth/directory service with pluggable connectors. OpenID Connect provider and third-party OAuth 2.0 delegation.
- JWT (http://jwt.io/) - JSON Web Tokens are an open, industry standard RFC 7519 method for representing claims securely between two parties.
- Keycloak (https://github.com/keycloak/keycloak) - Full-featured and extensible auth service. OpenID Connect provider and third-party OAuth 2.0 delegation.
@@ -467,7 +468,7 @@
- Citus (https://github.com/citusdata/citus) - Distributed PostgreSQL as an extension.
- ClickHouse (https://clickhouse.yandex/) - Column-oriented database management system that allows generating analytical data reports in real time.
- CockroachDB (c) (https://www.cockroachlabs.com/) - A cloud-native SQL database modelled after Google Spanner.
- Couchbase (http://www.couchbase.com/) - A distributed database engineered for performance, scalability, and simplified administration.
- Couchbase (https://couchbase.com/) - A distributed database engineered for performance, scalability, and simplified administration.
- Crate (c) (https://crate.io/) - Scalable SQL database with the NoSQL goodies.
- Datomic (http://www.datomic.com/) - Fully transactional, cloud-ready, distributed database.
- Druid (http://druid.io/) - Fast column-oriented distributed data store.
@@ -492,8 +493,7 @@
- Spring Cloud Contract (https://cloud.spring.io/spring-cloud-contract/) - TDD to the level of software architecture.
- VCR (https://github.com/vcr/vcr) - Record your test suite's HTTP interactions and replay them during future test runs for fast, deterministic, accurate tests. See the list of ports for implementations in other languages.
- Wilma (https://github.com/epam/Wilma) - Combined HTTP/HTTPS service stub and transparent proxy solution.
- WireMock (http://wiremock.org/) - Flexible library for stubbing and mocking web services. Unlike general purpose mocking tools it works by creating an actual HTTP server that your code under test can connect to as it would a real web 
service.
- WireMock (http://wiremock.org/) - Flexible library for stubbing and mocking web services. Unlike general purpose mocking tools it works by creating an actual HTTP server that your code under test can connect to as it would a real web service.
- Hoverfly (https://github.com/spectolabs/hoverfly) - Lightweight service virtualization/API simulation tool for developers and testers.
Continuous Integration & Delivery
@@ -534,8 +534,8 @@
- DID (https://www.w3.org/TR/did-core/) - W3C specification of Decentralized identifiers (DIDs): a new type of identifier that enables verifiable, decentralized digital identity.
- DIDComm (https://github.com/decentralized-identity/didcomm-messaging) - Private communication methodology built atop the decentralized design of DIDs.
- DIDComm Protocols (https://didcomm.org/) - Registry of protocols built on DIDComm, for high-trust, self-sovereign interactions over any transport.
- IDSA (https://internationaldataspaces.org/) - The International Data Spaces Association (IDSA) is on a mission to create the future of the global, digital economy with International Data Spaces (IDS), a secure, sovereign system of 
data sharing in which all participants can realize the full value of their data.
- IDSA (https://internationaldataspaces.org/) - The International Data Spaces Association (IDSA) is on a mission to create the future of the global, digital economy with International Data Spaces (IDS), a secure, sovereign system of data sharing 
in which all participants can realize the full value of their data.
HTTP/1.1
@@ -569,10 +569,10 @@
Security
- GNAP (https://datatracker.ietf.org/doc/html/draft-ietf-gnap-core-protocol) - Grant Negotiation and Authorization Protocol defines a mechanism for delegating authorization to a piece of software, and conveying that delegation to the 
software. This delegation can include access to a set of APIs as well as information passed directly to the software.
- OIDCONN (http://openid.net/connect/) - OpenID Connect 1.0 is a simple identity layer on top of the OAuth 2.0 protocol. It allows clients to verify the identity of the end-user based on the authentication performed by an Authorization 
Server, as well as to obtain basic profile information about the end-user in an interoperable and REST-like manner.
- GNAP (https://datatracker.ietf.org/doc/html/draft-ietf-gnap-core-protocol) - Grant Negotiation and Authorization Protocol defines a mechanism for delegating authorization to a piece of software, and conveying that delegation to the software. 
This delegation can include access to a set of APIs as well as information passed directly to the software.
- OIDCONN (http://openid.net/connect/) - OpenID Connect 1.0 is a simple identity layer on top of the OAuth 2.0 protocol. It allows clients to verify the identity of the end-user based on the authentication performed by an Authorization Server, as
well as to obtain basic profile information about the end-user in an interoperable and REST-like manner.
- PASETO (https://paseto.io/) - Paseto is everything you love about JOSE (JWT, JWE, JWS) without any of the many design deficits that plague the JOSE standards. 
- RFC5246 (https://tools.ietf.org/html/rfc5246) - The Transport Layer Security (TLS) Protocol Version 1.2.
- RFC6066 (https://tools.ietf.org/html/rfc6066) - TLS Extensions.
@@ -611,15 +611,14 @@
Organization Design / Team Dynamics
- How Do Committees Invent? (http://www.melconway.com/Home/pdf/committees.pdf) :small_orange_diamond: - Melvin E. Conway, Datamation magazine 1968. The original article defining Conway's Law.
- Service per Team (https://microservices.io/patterns/decomposition/service-per-team.html) - Each team is responsible for one or more business functions (e.g. business capabilities). A team owns a code base consisting of one or more 
modules. Its code base is sized so as to not exceed the cognitive capacity of team. The team deploys its code as one or more services. A team should have exactly one service unless there is a proven need to have multiple services.
- Start with Team Cognitive Load - Team Topologies (https://www.youtube.com/watch?v=haejb5rzKsM) :small_red_triangle: - DOES19 London. The "monoliths vs microservices" debate often focuses on technological aspects, ignoring strategy and
team dynamics. Instead of technology, smart-thinking organizations are beginning with team cognitive load as the guiding principle for modern software. In this talk, we explain how and why, illustrated by real case studies.
- Service per Team (https://microservices.io/patterns/decomposition/service-per-team.html) - Each team is responsible for one or more business functions (e.g. business capabilities). A team owns a code base consisting of one or more modules. Its 
code base is sized so as to not exceed the cognitive capacity of team. The team deploys its code as one or more services. A team should have exactly one service unless there is a proven need to have multiple services.
- Start with Team Cognitive Load - Team Topologies (https://www.youtube.com/watch?v=haejb5rzKsM) :small_red_triangle: - DOES19 London. The "monoliths vs microservices" debate often focuses on technological aspects, ignoring strategy and team 
dynamics. Instead of technology, smart-thinking organizations are beginning with team cognitive load as the guiding principle for modern software. In this talk, we explain how and why, illustrated by real case studies.
Enterprise & Verticals
- Commercetools (https://commercetools.com/) - Headless commerce platform.
- Elasticpath (https://www.elasticpath.com/) - E-commerce microservices.
- Equinox (https://www.infosysequinox.com/) - Infosys Equinox is a human-centric commerce and marketing platform that supports rich, hyper-personalized experiences across any channel and touchpoint.
- Flamingo (https://www.flamingo.me/) - Framework to build flexible and modern e-commerce applications.
- Medusa (https://medusajs.com/) - Headless open source commerce platform.
@@ -629,21 +628,22 @@
Articles & Papers
- Autonomy, Hyperconnectivity, and Residual Causality (https://doi.org/10.3390/philosophies6040081) - Philosophical introduction to the design of adaptive hyperliminal systems through complexity science theories.
- Awesome Scalability (https://github.com/binhnguyennus/awesome-scalability) :star: - An updated and organized reading list for illustrating the patterns of scalable, reliable, and performant large-scale systems. Concepts are explained 
in the articles of prominent engineers and credible references. Case studies are taken from battle-tested systems that serve millions to billions of users.
- Awesome Scalability (https://github.com/binhnguyennus/awesome-scalability) :star: - An updated and organized reading list for illustrating the patterns of scalable, reliable, and performant large-scale systems. Concepts are explained in the 
articles of prominent engineers and credible references. Case studies are taken from battle-tested systems that serve millions to billions of users.
- A Sidecar for Your Service Mesh (https://www.abhishek-tiwari.com/a-sidecar-for-your-service-mesh/) - A short service mesh introduction.
- AKF Scale Cube (http://akfpartners.com/techblog/2008/05/08/splitting-applications-or-services-for-scale/) - Model depicting the dimensions to scale a service.
- Building Microservices? Here is What You Should Know (https://cloudncode.blog/2016/07/22/msa-getting-started/) - A practical overview, based on real-world experience, of what one would need to know in order to build microservices.
- CALM (http://db.cs.berkeley.edu/papers/cidr11-bloom.pdf) :small_orange_diamond: - Consistency as logical monotonicity.
- Canary Release (http://martinfowler.com/bliki/CanaryRelease.html) - Technique to reduce the risk of introducing a new software version in production by slowly rolling out the change to a small subset of users before rolling it out to 
the entire infrastructure and making it available to everybody.
- CAP Theorem (http://blog.thislongrun.com/2015/03/the-cap-theorem-series.html) - States that it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees: Consistency, Availability
and Partition tolerance.
- Formal Foundations of Serverless Computing (https://arxiv.org/pdf/1902.05870.pdf) :small_orange_diamond: - The serverless computing abstraction exposes several low-level operational details that make it hard for programmers to write 
and reason about their code. This paper sheds light on this problem by presenting λ, an operational semantics of the essence of serverless computing.
- Java Microservices: A Practical Guide (https://www.marcobehler.com/guides/java-microservices-a-practical-guide) - You can use this guide to understand what Java microservices are, how you architect and build them. Also: A look at Java
- Canary Release (http://martinfowler.com/bliki/CanaryRelease.html) - Technique to reduce the risk of introducing a new software version in production by slowly rolling out the change to a small subset of users before rolling it out to the entire
infrastructure and making it available to everybody.
- CAP Theorem (http://blog.thislongrun.com/2015/03/the-cap-theorem-series.html) - States that it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees: Consistency, Availability and 
Partition tolerance.
- Formal Foundations of Serverless Computing (https://arxiv.org/pdf/1902.05870.pdf) :small_orange_diamond: - The serverless computing abstraction exposes several low-level operational details that make it hard for programmers to write and reason 
about their code. This paper sheds light on this problem by presenting λ, an operational semantics of the essence of serverless computing.
- Java Microservices: A Practical Guide (https://www.marcobehler.com/guides/java-microservices-a-practical-guide) - You can use this guide to understand what Java microservices are, how you architect and build them. Also: A look at Java 
microservice libraries & common questions.
- Microservice Architecture (http://martinfowler.com/articles/microservices.html) - Particular way of designing software applications as suites of independently deployable services.
- Microservices - From Design to Deployment (https://www.f5.com/content/dam/f5/corp/global/pdf/ebooks/Microservices_Designing_Deploying.pdf) :small_orange_diamond: - F5's seven-part series on microservices.
- Microservices – Please, don’t (https://riak.com/posts/technical/microservices-please-dont/) - Critical advice about some problems regarding a microservices approach.
- Microservices RefCard (https://dzone.com/refcardz/getting-started-with-microservices) - Getting started with microservices.
- Microservices Trade-Offs (http://martinfowler.com/articles/microservice-trade-offs.html) - Guide to ponder costs and benefits of the mircoservices architectural style.
@@ -651,16 +651,14 @@
- Reactive Streams (http://www.reactive-streams.org/) - Initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.
- ROCAS (http://resources.1060research.com/docs/2015/Resource-Oriented-Computing-Adaptive-Systems-ROCAS-1.2.pdf) :small_orange_diamond: - Resource Oriented Computing for Adaptive Systems.
- SECO (http://ceur-ws.org/Vol-746/IWSECO2011-6-DengYu.pdf) :small_orange_diamond: - Understanding software ecosystems: a strategic modeling approach.
- Service Discovery in a Microservice Architecture (https://www.nginx.com/blog/service-discovery-in-a-microservices-architecture/) - Overview of discovery and registration patterns.
- Testing Strategies in a Microservice Architecture (http://martinfowler.com/articles/microservice-testing/) - Approaches for managing the additional testing complexity of multiple independently deployable components.
- Your Server as a Function (http://monkey.org/~marius/funsrv.pdf) :small_orange_diamond: - Describes three abstractions which combine to present a powerful programming model for building safe, modular, and efficient server software: 
Composable futures, services and filters.
- Microservices - The Journey So Far and Challenges Ahead (https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8354433) :small_orange_diamond: - Overview of the state of microservices in both industrial and academia.
- Your Server as a Function (http://monkey.org/~marius/funsrv.pdf) :small_orange_diamond: - Describes three abstractions which combine to present a powerful programming model for building safe, modular, and efficient server software: Composable 
futures, services and filters.
Sites & Organizations
- Cloud Native Computing Foundation (https://www.cncf.io/) - The Cloud Native Computing Foundation builds sustainable ecosystems and fosters a community around a constellation of high-quality projects that orchestrate containers as part
of a microservices architecture.
- Cloud Native Computing Foundation (https://www.cncf.io/) - The Cloud Native Computing Foundation builds sustainable ecosystems and fosters a community around a constellation of high-quality projects that orchestrate containers as part of a 
microservices architecture.
- CNCF Cloud Native Interactive Landscape (https://landscape.cncf.io/) - Interactive landscape of cloud native technologies.
- Microservices Resource Guide (http://martinfowler.com/microservices/) - Martin Fowler's choice of articles, videos, books, and podcasts that can teach you more about the microservices architectural style.
- Microservice Patterns (http://microservices.io/) - Microservice architecture patterns and best practices.
@@ -677,3 +675,5 @@
Feel free to open an issue (https://github.com/mfornos/awesome-microservices/issues) or create a pull request (https://github.com/mfornos/awesome-microservices/pulls) with your additions.
:star2: Thank you!
microservices Github: https://github.com/mfornos/awesome-microservices