A curated list of Microservice Architecture related principles and technologies.

Table of Contents

• Platforms
• Frameworks / Runtimes
• Service Toolkits
  • Polyglot
  • C
  • C++
  • C#
  • D
  • Erlang VM
  • Go
  • Haskell
  • Java VM
  • Node.js
  • Perl
  • PHP
  • Python
  • Ruby
• Frontend / UI
• Capabilities
  • API Gateways / Edge Services
  • Configuration and Discovery
  • Coordination and Governance
  • Elasticity
  • Job Schedulers / Workload Automation
  • Logging
  • Messaging
  • Monitoring and Debugging
  • Reactivity
  • Resilience
  • Security
  • Serialization
  • Storage
  • Testing
• Continuous Integration and Continuous Delivery
• Documentation & Modeling
  • REST APIs
• Standards / Recommendations
  • World Wide Web
  • HTTP/1.1
  • HTTP/2
  • CoAP
  • RPC
  • Messaging
  • Security
  • Service Discovery
  • Data Formats
  • Vocabularies
  • Unicode
• Real Life Stories
• Enterprise & Verticals
• Theory
  • Articles & Papers
  • Talks
  • Tutorials
  • Books
  • Sites & Organizations
• Emerging Technologies
• License
• Contributing
• Acknowledgments

• Ballerina - Cloud native programming language.
• Cocaine - A cloud platform enabling you to build your own PaaS clouds.
• Deis - Open source application platform for public and private clouds.
• Express Serverless - An open source, Kubernetes-native, microservices and serverless platform.
• Fabric8 - Open source microservices platform based on Docker, Kubernetes and Jenkins. Makes it easy to create, edit, deploy and manage microservices and go faster.
• Hook.io - Open source provider of microservice and webhook hosting.
• KintoHub - Microservice package manager empowering developers to easily build and share cloud ready features.
• Lightbend - Platform for building scalable reactive systems on the JVM.
• Mantl - Platform for rapidly deploying globally distributed services.
• Netflix OSS - Netflix open source software ecosystem.
• OpenWhisk - Serverless, open source cloud platform that executes functions in response to events at any scale.
• Pulumi - SDK for cloud native infrastructure as code. Use your favorite language to preview and manage updates to your apps and infrastructure, and continuously deploy to any cloud (no YAML required).
• STUPS - A set of tools and components by Zalando to provide a convenient and audit-compliant PaaS for multiple autonomous teams on top of AWS.
• VAMP - Build, deploy and manage microservices with power and ease.

• Akka - Toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM.
• Axon - An end-to-end development and infrastructure platform for easy development and running of any DDD, CQRS and Event Sourcing applications on JVM.
• Baratine - Platform for building a network of loosely-coupled POJO microservices.
• Erlang/OTP - Programming language used to build massively scalable soft real-time systems with requirements on high availability.
• Finagle - Extensible RPC system for the JVM, used to construct high-concurrency servers.
• Flogo - Flogo is an open source framework to simplify building efficient & modern serverless functions and edge microservices.
• GPars - Concurrency and parallelism framework for the JVM.
• Grenache - A Bittorent-DHT based microservices framework supporting REQ/REP and PUB/SUB patterns over multiple transports.
• Ice - Comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python, and more.
• Lagom - Reactive microservices for the JVM.
• Light-4j - A high throughput, low latency, small memory footprint and more productive microservices platform.
• Micro - A microservice development runtime.
• Microserver - Java 8 native, zero configuration, standards based, battle hardened library to run Java REST microservices.
• Orbit - Modern framework for JVM languages that makes it easier to build and maintain distributed and scalable online services.
• Quasar - Fibers, channels and actors for the JVM.
• ScaleCube - Toolkit for building reactive microservices for the JVM: low-latency, high-throughput, scalable and resilient.
• Vert.X - Toolkit for building reactive applications on the JVM.
• Vert.X Toolbox - A set of Vert.x components to build reactive microservice applications.
• Wangle - A framework providing a set of common client/server abstractions for building services in a consistent, modular, and composable way.
• WildFly Swarm - Microservices starting with just enough Java EE runtime, based on Eclipse MicroProfile.

• Apex - Tool for deploying and managing AWS Lambda functions. With shims for languages not yet supported by Lambda, you can use Golang out of the box.
• CoAP - Constrained application protocol implementations.
• GRPC - 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 - A very newbility RPC Library, support 25+ languages now.

• Kore - Easy to use web application framework for writing scalable web APIs in C.
• Libasyncd - Embeddable event-based asynchronous HTTP server library for C.
• Libslack - 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 - High-performance and scalable web server.
• Onion - C library to create simple HTTP servers and web applications.
• RIBS2 - Library which allows building high-performance internet serving systems.

• AnyRPC - Provides a common system to work with a number of different remote procedure call standards, including: JSON-RPC, XML-RPC, MessagePack-RPC.
• Cap’n Proto RPC - The Cap’n Proto C++ RPC implementation.
• C++ Micro Services - An OSGi-like C++ dynamic module system and service registry.
• Enduro/X - XATMI based service framework for GNU/Linux.
• Pion - C++ framework for building lightweight HTTP interfaces.
• Pistache - A high-performance REST toolkit written in C++.
• Poco - C++ class libraries for building network-based applications and servers.
• Restbed - Brings asynchronous RESTful functionality to C++11 applications.
• Served - C++ library for building high-performance RESTful web servers.
• ULib - Highly optimized class framework for writing C++ applications.

• Akka.NET - Toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on .NET & Mono.
• Microdot - Open source .NET microservices framework.
• Nancy - Lightweight web framework.
• 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.

• Vibe.d - Asynchronous I/O that doesn’t get in your way, written in D.

• Phoenix - Framework for building HTML5 apps, API backends and distributed systems.
• Plug - A specification and conveniences for composable modules between web applications.

• Cowboy - Small, fast, modular HTTP server written in Erlang.
• Mochiweb - Erlang library for building lightweight HTTP servers.

• Echo - Fast and unfancy HTTP server framework for Go. Up to 10x faster than the rest.
• Enduro/X ASG - Enduro/X bindings for Go allows to effectively write XATMI based microservices in Go language. Uses Unix kernel IPC (queues) for fast process communications.
• Gin - Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance - up to 40 times faster.
• Gizmo - Microservices toolkit.
• Goa - Design-based HTTP microservices in Go.
• Gocraft - A toolkit for building web apps. Includes routing, middleware stacks, logging and monitoring.
• Goji - Minimalistic and flexible request multiplexer for Go.
• Go kit - Distributed programming toolkit for microservices in the modern enterprise.
• Go-micro - A pluggable RPC microservice framework.
• Gopencils - Easily consume REST APIs with Go.
• Gorilla - Web toolkit for the Go programming language.
• Iris - Fast, simple and efficient micro web framework for Go.
• Kite - Microservices framework in Go.
• KrakenD - Framework to build ultra performance API Gateways with middlewares.
• Libchan - Ultra-lightweight networking library which lets network services communicate in the same way that goroutines communicate using channels.
• Martini - Martini is a powerful package for quickly writing modular web applications/services in Golang.
• Micro - A microservices toolchain in Go.
• Nano - A minimalistic, transport-agnostic and testing-friendly microservice framework.
• Negroni - Idiomatic HTTP middleware for Golang.
• Neutrino - Realtime/REST backend service.
• RPCX - A distributed RPC service framework based on NET/RPC like Alibaba Dubbo and Weibo Motan.
• Sleepy - REST for go.
• Vamp-router - Service routing, load balancing and filtering application.

• Scotty - Micro web framework inspired by Ruby's Sinatra, using WAI and Warp.
• Servant - Type-level web DSL.
• Yesod - The Haskell RESTful web framework.

• Compojure - A concise routing library for Ring/Clojure.
• Duct - Minimal framework for building web applications in Clojure, with a strong emphasis on simplicity.
• Friboo - Utility library for writing microservices in Clojure, with support for Swagger and OAuth.
• Liberator - Library that helps you expose your data as resources while automatically complying with all the relevant requirements of the HTTP specification.
• Modularity - JUXT's Clojure-based modular system.
• System - Built on top of Stuart Sierra's component library, offers a set of readymade components.
• Tesla - Common basis for some of Otto.de's Clojure microservices.

• Airlift - Framework for building REST services in Java.
• Armeria - Open-source asynchronous HTTP/2 RPC/REST client/server library built on top of Java 8, Netty, Thrift and gRPC.
• Disruptor - High-performance inter-thread messaging library.
• Dropwizard - Java framework for developing ops-friendly, high-performance, RESTful web services.
• Dubbo - A high-performance, java based RPC framework open-sourced by Alibaba.
• HTTP Remoting - 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.
• Ja-micro - Lightweight Java framework for building microservices (compatible with go-micro).
• Jersey - RESTful services in Java. JAX-RS reference implementation.
• Micronaut - A modern, JVM-based, full-stack framework for building modular, easily testable microservice applications.
• MSF4J - High throughput & low memory footprint Java microservices framework.
• QBit - Reactive programming library for building microservices.
• Ratpack - Set of Java libraries that facilitate fast, efficient, evolvable and well tested HTTP applications. specific support for the Groovy language is provided.
• Restlet - Helps Java developers build web APIs that follow the REST architecture style.
• Spark - A micro-framework for creating web applications in Java 8 with minimal effort.
• Spring Boot - Makes it easy to create stand-alone, production-grade Spring based applications.

• Http4k - Lightweight but fully-featured HTTP toolkit written in pure Kotlin that enables the serving and consuming of HTTP services in a functional and consistent way.
• Ktor - Framework for building asynchronous servers and clients in connected systems using the Kotlin programming language.

• Akka HTTP - Open source toolkit for building REST/HTTP-based integration layers on top of Scala and Akka.
• Colossus - I/O and microservice library for Scala.
• Finatra - Fast, testable, Scala HTTP services built on Twitter-Server and Finagle.
• Http4s - A minimal, idiomatic Scala interface for HTTP
• Play - The high velocity web framework for Java and Scala.
• Scalatra - Simple, accessible and free web micro-framework.
• Skinny Micro - Micro-web framework to build servlet applications in Scala.
• Squbs - A suite of components enabling standardization and operationalization of Akka and Akka HTTP applications/services in a large scale, managed, cloud environment.

• Actionhero - Multi-transport Node.js API server with integrated cluster capabilities and delayed tasks.
• Baucis - To build and maintain scalable HATEOAS/Level 3 REST APIs.
• ClaudiaJS - Easy to deploy Node.js projects to AWS Lambda and API Gateway.
• Cote - A Node.js library for building zero-configuration microservices.
• Express - Fast, unopinionated, minimalist web framework for Node.js
• Fastify - Fastify, Fast and low overhead web framework, for Node.js.
• FeathersJS - An open source REST and realtime API layer for modern applications.
• Graft - Full-stack javascript through microservices.
• Hapi - A rich framework for building applications and services.
• Hudson Taylor - Set of libraries for building automatically documented, well validated services.
• Koa - Next generation web framework for Node.js
• Loopback - Node.js framework for creating APIs and easily connecting to backend data sources.
• Micro - Asynchronous HTTP microservices.
• Micro Panda - Node.js toolkit to help build microservices.
• Micro-Whalla - A simple, fast framework for writing microservices in Node.js communicate using RPC / IPC.
• Moleculer - Fast & powerful microservices framework for NodeJS.
• Restify - Node.js module built specifically to enable you to build correct REST web services.
• Seneca - A microservices toolkit for Node.js
• Serverless - Build and maintain web, mobile and IoT applications running on AWS Lambda and API Gateway (formerly known as JAWS).
• Steriods Framework - Steroids framework simplifies the development of microservices with Serverless using TypeScript by enabling the developer to emphasize more on business/domain logic rather than focusing too much on technical details.
• StdLib - Standard library for microservices.

• Cro - Libraries for creating reactive distributed systems using Perl 6.
• Mojolicious - Next generation web framework for Perl.

• API Platform - API-first web framework on top of Symfony with JSON-LD, Schema.org and Hydra support.
• Fat-Free - A powerful yet easy-to-use PHP micro-framework.
• Flight - An extensible micro-framework.
• Kraken - Asynchronous and fault-tolerant PHP framework for distributed applications.
• Lumen - Stunningly fast micro-framework.
• Phalcon - Full-stack PHP framework delivered as a C-extension.
• Slim - Micro-framework that helps you quickly write simple yet powerful web applications and APIs.
• Symfony - Micro-framework based on the Symfony components.
• Upswarm - Multi-processed, async, fault-tolerant micro-framework for writing service-oriented applications.

• Aiohttp - HTTP client/server for asyncio.
• Bottle - Fast, simple and lightweight WSGI micro web-framework for Python.
• Falcon - Bare-metal Python web API framework for building very fast app backends and microservices.
• Flask - Python framework for microservices based on Werkzeug and Jinja 2.
• Nameko - Python framework for building microservices.
• Sanic - Sanic is a Flask-like Python 3.5+ web server that's written to go fast.
• Tornado - Web framework and asynchronous networking library.
• Twisted - Event-driven network programming engine.
• Web.py - Minimalist web framework for Python.
• Zappa - Framework for building and deploying server-less Python event-driven and web applications.
• Connexion - Swagger/OpenAPI First framework for Python on top of Flask with automatic endpoint validation & OAuth2 support.

• Grape - An opinionated framework for creating REST-like APIs
• Hanami - A modern web framework for Ruby.
• Praxis - Framework for both designing and implementing APIs.
• Rails API - Rails as an API only.
• Scorched - Light-weight web framework for Ruby.
• Sinatra - Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort.

• Awesome Micro Frontends - A curated list of resources about Micro Frontends.
• Micro Frontends - Extending the microservice idea to frontend development.

Note that data and control plane components are not categorized at this moment.

• Amalgam8 - Content-based routing fabric for polyglot microservices.
• Ambassador - Kubernetes-native API gateway for microservices built on Envoy.
• Annon - Open source API gateway with built-in API management, authentication and status pages written in Elixir.
• Caddy - Extensible HTTP/2 web server with automatic HTTPS.
• Camel - Empowers you to define routing and mediation rules in a variety of domain-specific languages, including a Java-based fluent API, Spring or Blueprint XML configuration files, and a Scala DSL.
• Envoy - Open source edge and service proxy, from the developers at Lyft.
• Express Gateway - A microservices API gateway built on Express.js.
• Fabio - A fast, modern, zero-conf load balancing HTTP/S router for deploying microservices managed by Consul.
• HAProxy - Reliable, high Performance TCP/HTTP load balancer.
• Istio - An open platform to connect, manage, and secure microservices.
• Janus - An API Gateway written in Go.
• Keepalived - Simple and robust facilities for loadbalancing and high-availability to Linux system and Linux based infrastructures.
• Kong - Open source management layer for APIs.
• KrakenD - Open source ultra performance API Gateway.
• Linkerd - Resilient service mesh for cloud native apps.
• Neutrino - Extensible software load balancer.
• OpenResty - Fast web application server built on top of Nginx.
• Otoroshi - Modern HTTP reverse proxy with lightweight API management.
• Skipper - HTTP router useful for decoupling routing from service logic.
• Spring Cloud Gateway - API Gateway on top of Spring MVC. Aims to provide a simple, yet effective way to route to APIs.
• Tengine - A distribution of Nginx with some advanced features.
• Træfɪk - A modern HTTP reverse proxy and load balancer made to deploy microservices with ease.
• Traffic Server - High-performance building block for cloud services.
• Tyk - Open source, fast and scalable API gateway, portal and API management platform.
• Vulcand - Programmatic load balancer backed by Etcd.
• Zuul - An edge service that provides dynamic routing, monitoring, resiliency, security, and more.

• Central Dogma - Open-source highly-available version-controlled service configuration repository based on Git, ZooKeeper and HTTP/2.
• Consul - Service discovery and configuration made easy. Distributed, highly available, and datacenter-aware.
• ContainerPilot - Service for autodiscovery and configuration of applications running in containers.
• Denominator - Portably control DNS clouds using java or bash.
• Doozer - Highly-available, completely consistent store for small amounts of data. When the data changes, it can notify connected clients immediately.
• Etcd - Highly-available key-value store for shared configuration and service discovery.
• Eureka - REST based service that is primarily used in the AWS cloud for locating services for the purpose of load balancing and failover of middle-tier servers.
• Microphone - Lightweight .NET framework to run self hosting REST services using Web Api or NancyFx on top of a Consul or Etcd cluster.
• Registrator - Service registry bridge for Docker. Supports pluggable service registries, which currently includes Consul, Etcd and SkyDNS 2.
• Shaman - Small, lightweight, api-driven DNS server.
• SkyDNS - Distributed service for announcement and discovery of services built on top of etcd. It utilizes DNS queries to discover available services.
• SmartStack - Airbnb's automated service discovery and registration framework.
• Spring Cloud Config - Provides server and client-side support for externalized configuration in a distributed system.
• ZooKeeper - Open source server which enables highly reliable distributed coordination.

• AWS Step Functions - Coordinate the components of distributed applications and microservices using visual workflows.
• Azuqua - Orchestration and governance platform for distributed applications.
• Conductor - A microservices orchestration engine.
• Fission Workflows - Workflow-based, reliable function composition for serverless functions.

• Galaxy - Open source high-performance in-memory data-grid.
• Grape - Realtime processing pipeline.
• Hazelcast - 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 - Generic cluster management framework used for the automatic management of partitioned, replicated and distributed resources hosted on a cluster of nodes.
• Ignite - 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.
• Marathon - Deploy and manage containers (including Docker) on top of Apache Mesos at scale.
• Mesos - 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 - Distributed, highly available, datacenter-aware scheduler.
• Onyx - Distributed, masterless, high performance, fault tolerant data processing for Clojure.
• Ordasity - Designed to spread persistent or long-lived workloads across several machines.
• Redisson - Distributed and scalable Java data structures on top of Redis server.
• Serf - Decentralized solution for cluster membership, failure detection and orchestration.

• Celery - Asynchronous task queue/job queue based on distributed message passing. Focused on real-time operation and supports scheduling.
• Chronos - Fault tolerant job scheduler for Mesos which handles dependencies and ISO8601 based schedules.
• Fenzo - Extensible scheduler for Mesos frameworks.
• JobScheduler - Open Source solution for enterprise-level workload automation. It is used to launch executable files and shell scripts and to run database procedures automatically.
• Rundeck - Job scheduler and runbook automation. Enable self-service access to existing scripts and tools.
• Schedulix - Open source enterprise job scheduling system lays down ground-breaking standards for the professional automation of IT processes in advanced system environments.

• Bunyan - Simple and fast JSON logging library for Node.js services.
• Fluentd - Open source data collector for unified logging layer.
• Graylog - Fully integrated open source log management platform.
• Kibana - Flexible analytics and visualization platform.
• LogDNA - Centralized log management software. Instantly collect, centralize, and analyze logs in real-time from any platform, at any volume.
• Logstash - Tool for managing events and logs.
• Suro - Distributed data pipeline which enables services for moving, aggregating, routing, storing data.

• ØMQ - Brokerless intelligent transport layer.
• ActiveMQ - Powerful open source messaging and integration patterns server.
• Aeron - Efficient reliable UDP unicast, UDP multicast, and IPC message transport.
• Apollo - Faster, more reliable, easier to maintain messaging broker built from the foundations of the original ActiveMQ.
• Ascoltatori - Pub/sub library for Node.
• Beanstalk - Simple, fast work queue.
• Crossbar - Open source networking platform for distributed and microservice applications. It implements the open Web Application Messaging Protocol (WAMP).
• Disque - Distributed message broker.
• Eventuate - A platform for developing asynchronous microservices solving the distributed data management problems.
• Kafka - Publish-subscribe messaging rethought as a distributed commit log.
• Malamute - ZeroMQ enterprise messaging broker.
• Mist - A distributed, tag-based pub/sub service.
• Mosca - MQTT broker as a module.
• Mosquitto - Open source message broker that implements the MQTT protocol.
• Nanomsg - Socket library that provides several common communication patterns for building distributed systems.
• NATS - Open source, high-performance, lightweight cloud messaging system.
• NSQ - A realtime distributed messaging platform.
• Pulsar - Distributed pub-sub messaging system.
• Qpid - Cross-platform messaging components built on AMQP.
• RabbitMQ - Open source Erlang-based message broker that just works.
• RocketMQ - A low latency, reliable, scalable, easy to use message oriented middleware born from alibaba massive messaging business.
• VerneMQ - Open source, scalable, Erlang-based MQTT broker.

• Beats - Lightweight shippers for Elasticsearch & Logstash.
• Collectd - The system statistics collection daemon.
• Elastalert - Easy & flexible alerting for Elasticsearch.
• Ganglia - A scalable distributed monitoring system for high-performance computing systems such as clusters and grids.
• Grafana - An open source, feature rich metrics dashboard and graph editor for Graphite, InfluxDB & OpenTSDB.
• Graphite - Scalable realtime graphing.
• IOpipe - Application performance monitoring for Amazon Lambda.
• Jaeger - An open source, end-to-end distributed tracing
• Microservice Graph Explorer - Navigate and explore all of the microservices in your application in real time using the real application connections.
• Parallec - Fast parallel asynchronous HTTP/SSH/TCP/Ping client Java library.
• Prometheus - An open source service monitoring system and time series database.
• REST Commander - Fast parallel asynchronous HTTP client as a service to monitor and manage HTTP endpoints.
• Riemann - Monitors distributed systems.
• Sensu - Monitoring for today's infrastructure.
• Trace - A visualised stack trace platform designed for microservices.
• Watcher - Alerting for Elasticsearch.
• Zabbix - Open source enterprise-class monitoring solution.
• Zipkin - Distributed tracing system.

• Reactor.io - A second-generation Reactive library for building non-blocking applications on the JVM based on the Reactive Streams Specification.
• Reactive Kafka - Reactive Streams API for Apache Kafka.
• ReactiveX - API for asynchronous programming with observable streams. Available for idiomatic Java, Scala, C#, C++, Clojure, JavaScript, Python, Groovy, JRuby, and others.
• Simple React - Powerful future streams & asynchronous data structures for Java 8.

• 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.
• Pathod - Crafted malice for tormenting HTTP clients and servers.
• Raft Consensus - Consensus algorithm that is designed to be easy to understand. It's equivalent to Paxos in fault-tolerance and performance.
• Resilience4j - Fault tolerance library designed for Java8 and functional programming.
• Resilient HTTP - A smart HTTP client with super powers like fault tolerance, dynamic server discovery, auto balancing and reactive recovery, designed for distributed systems.
• Saboteur - Causing deliberate network mayhem for better resilience.
• Semian - Resiliency toolkit for Ruby for failing fast.
• Simian Army - Suite of tools for keeping your cloud operating in top form. Chaos Monkey, the first member, is a resiliency tool that helps ensure that your applications can tolerate random instance failures.
• Toxiproxy - TCP proxy to simulate network and system conditions for chaos and resiliency testing.

• Crtauth - A public key backed client/server authentication system.
• Dex - Opinionated auth/directory service with pluggable connectors. OpenID Connect provider and third-party OAuth 2.0 delegation.
• Identity Server - OpenID Connect and OAuth 2.0 Framework for ASP.NET Core.
• JWT - JSON Web Tokens are an open, industry standard RFC 7519 method for representing claims securely between two parties.
• Keycloak - Full-featured and extensible auth service. OpenID Connect provider and third-party OAuth 2.0 delegation.
• Light OAuth2 - A fast, lightweight and cloud native OAuth 2.0 authorization microservices based on light-java.
• Login With - Stateless login-with microservice for Google, FB, Github, and more.
• OAuth - Provides specific authorization flows for web applications, desktop applications, mobile phones, and living room devices. Many implementations.
• OpenID Connect - Libraries, products, and tools implementing current OpenID specifications and related specs.
• OSIAM - Open source identity and access management implementing OAuth 2.0 and SCIMv2.
• SCIM - System for Cross-domain Identity Management.
• Vault - Secures, stores, and tightly controls access to tokens, passwords, certificates, API keys, and other secrets in modern computing.

• Avro - Apache data serialization system providing rich data structures in a compact, fast, binary data format.
• BooPickle - Binary serialization library for efficient network communication. For Scala and Scala.js
• Cap’n Proto - Insanely fast data interchange format and capability-based RPC system.
• CBOR - Implementations of the CBOR standard (RFC 7049) in many languages.
• Cereal - C++11 library for serialization.
• Cheshire - Clojure JSON and JSON SMILE encoding/decoding.
• Etch - Cross-platform, language and transport-independent framework for building and consuming network services.
• Fastjson - Fast JSON Processor.
• Ffjson - Faster JSON serialization for Go.
• FST - Fast java serialization drop in-replacement.
• Jackson - A multi-purpose Java library for processing JSON data format.
• Jackson Afterburner - Jackson module that uses bytecode generation to further speed up data binding (+30-40% throughput for serialization, deserialization).
• Kryo - Java serialization and cloning: fast, efficient, automatic.
• MessagePack - Efficient binary serialization format.
• Protostuff - A serialization library with built-in support for forward-backward compatibility (schema evolution) and validation.
• SBinary - Library for describing binary formats for Scala types.
• Thrift - The Apache Thrift software framework, for scalable cross-language services development.

• Apache Hive - Data warehouse infrastructure built on top of Hadoop.
• Apache Cassandra - Column-oriented and providing high availability with no single point of failure.
• Apache HBase - Hadoop database for big data.
• Aerospike - High performance NoSQL database delivering speed at scale.
• ArangoDB - A distributed free and open source database with a flexible data model for documents, graphs, and key-values.
• AtlasDB - Transactional layer on top of a key value store.
• ClickHouse - Column-oriented database management system that allows generating analytical data reports in real time.
• CockroachDB - A cloud-native SQL database modelled after Google Spanner.
• Couchbase - A distributed database engineered for performance, scalability, and simplified administration.
• Crate - Scalable SQL database with the NoSQL goodies.
• Datomic - Fully transactional, cloud-ready, distributed database.
• Druid - Fast column-oriented distributed data store.
• Elasticsearch - Open source distributed, scalable, and highly available search server.
• Elliptics - Fault tolerant distributed key/value storage.
• Geode - Open source, distributed, in-memory database for scale-out applications.
• Infinispan - Highly concurrent key/value datastore used for caching.
• InfluxDB - Scalable datastore for metrics, events, and real-time analytics.
• Manta - Highly scalable, distributed object storage service with integrated compute.
• MemSQL - High-performance, in-memory database that combines the horizontal scalability of distributed systems with the familiarity of SQL.
• OpenTSDB - Scalable and distributed time series database written on top of Apache HBase.
• Parquet - Columnar storage format available to any project in the Hadoop ecosystem, regardless of the choice of data processing framework, data model or programming language.
• Reborn - Distributed database fully compatible with redis protocol.
• RethinkDB - Open source, scalable database that makes building realtime apps easier.
• Secure Scuttlebutt - P2P database of message-feeds.
• Tachyon - Memory-centric distributed storage system, enabling reliable data sharing at memory-speed across cluster frameworks.
• Voldemort - Open source clone of Amazon DynamoDB
• VoltDB - In-Memory ACID compliant distributed database.

• Goreplay - A tool for capturing and replaying live HTTP traffic into a test environment.
• Hikaku - A library that tests if the implementation of a REST-API meets its specification.
• Mitmproxy - An interactive console program that allows traffic flows to be intercepted, inspected, modified and replayed.
• Mountebank - Cross-platform, multi-protocol test doubles over the wire.
• Spring Cloud Contract - TDD to the level of software architecture.
• 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 - Combined HTTP/HTTPS service stub and transparent proxy solution.
• WireMock - 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.

• Awesome CI/CD DevOps - A curated list of awesome tools for continuous integration, continuous delivery and DevOps.

• Aglio - API Blueprint renderer with theme support that outputs static HTML.
• API Blueprint - Tools for your whole API lifecycle. Use it to discuss your API with others. Generate documentation automatically. Or a test suite. Or even some code.
• Apidoc - Beautiful documentation for REST services.
• RAML - RESTful API Modeling Language, a simple and succinct way of describing practically-RESTful APIs.
• ReDoc - OpenAPI/Swagger-generated API Documentation.
• Slate - Beautiful static documentation for your API.
• Spring REST Docs - Document RESTful services by combining hand-written documentation with auto-generated snippets produced with Spring MVC Test.
• Swagger - A simple yet powerful representation of your RESTful API.

• W3C.REC-Webarch - Architecture of the World Wide Web, Volume One.
• RFC3986 - Uniform Resource Identifier (URI): Generic Syntax.
• RFC6570 - URI Template.
• RFC7320 - URI Design and Ownership.

• RFC7230 - Message Syntax and Routing.
• RFC7231 - Semantics and Content.
• RFC7232 - Conditional Requests.
• RFC7233 - Range Requests.
• RFC7234 - Caching.
• RFC7235 - Authentication.
• RFC7807 - Problem Details for HTTP APIs.

• RFC7540 - Hypertext Transfer Protocol Version 2.

• RFC7252 - The Constrained Application Protocol (CoAP) is a specialized web transfer protocol for use with constrained nodes and constrained networks in the Internet of Things.

• BERT-RPC 1.0 - An attempt to specify a flexible binary serialization and RPC protocol that are compatible with the philosophies of dynamic languages.
• JSON-RPC 2.0 - A stateless, light-weight remote procedure call (RPC) protocol.

• AMQP - Advanced Message Queuing Protocol.
• MQTT - MQ Telemetry Transport.
• STOMP - Simple Text Oriented Messaging Protocol.

• RFC5246 - The Transport Layer Security (TLS) Protocol Version 1.2.
• RFC6066 - TLS Extensions.
• RFC6347 - Datagram Transport Layer Security Version 1.2.
• RFC6749 - The OAuth 2.0 authorization framework.
• RFC7515 - JSON Web Signature (JWS) represents content secured with digital signatures or Message Authentication Codes (MACs) using JSON-based data structures.
• RFC7519 - JSON Web Token (JWT) is a compact, URL-safe means of representing claims to be transferred between two parties.
• RFC7642 - SCIM: Definitions, overview, concepts, and requirements.
• RFC7643 - SCIM: Core Schema, provides a platform-neutral schema and extension model for representing users and groups.
• RFC7644 - SCIM: Protocol, an application-level, REST protocol for provisioning and managing identity data on the web.
• OIDCONN - 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.

• HAL - The JSON Hypertext Application Language (HAL) is a standard which establishes conventions for expressing hypermedia controls, such as links, with JSON. ^DRAFT
• Hydra - Specifications for interoperable, hypermedia-driven Web APIs.
• GraphQL - Query language designed to build client applications by providing an intuitive and flexible syntax and system for describing their data requirements and interactions. ^DRAFT
• WADL - The Web Application Description Language specification.
• WSDL - The Web Services Description Language Version 2.0 spec.

• RFC4627 - JavaScript Object Notation (JSON).
• RFC7049 - Concise Binary Object Representation (CBOR).
• BSON - Binary JSON (BSON).
• JSON-LD - JSON for Linking Data.
• SBE - Simple Binary Encoding (SBE).
• MSGPACK - MessagePack Specification.
• UBJSON - Universal Binary JSON Specification.

• JSON Schema - Vocabulary that allows you to annotate and validate JSON documents.
• LOV - Linked open vocabularies.
• Schema.org - Collaborative, community activity with a mission to create, maintain, and promote schemas for structured data on the Internet, on web pages, in email messages, and beyond.

• UNIV8 - The Unicode Consortium. The Unicode Standard, Version 8.0.0, (Mountain View, CA: The Unicode Consortium, 2015. ISBN 978-1-936213-10-8).
• RFC3629 - UTF-8, a transformation format of ISO 10646.

• A Journey into Microservices
• Clean microservice architecture
• Failing at microservices
• How to talk to your friends about microservices
• How we build microservices at Karma
• How we ended up with microservices at SoundCloud
• Microservices: lessons from the frontline
• Monolith first
• Scaling microservices at Gilt with Scala, Docker and AWS

• Commercetools - Headless commerce platform.
• Flamingo - Framework to build flexible and modern e-commerce applications.
• Interact - CRM microservices for rapid delivery of tailored solutions.
• Moltin - E-commerce API for developers.
• Predix - Industrial microservices platform.
• Skava - Provides microservices for all the functions of your store, and the glue to hold them together.

• AKF Scale Cube - Model depicting the dimensions to scale a service.
• Benchmark Requirements for Microservices Architecture Research 🔸^PDF - Set of requirements that may be useful in selecting a community-owned architecture benchmark to support repeatable microservices research.
• Building Microservices? Here is What You Should Know - A practical overview, based on real-world experience, of what one would need to know in order to build Microservices.
• CALM 🔸^PDF - Consistency as logical monotonicity.
• Canary Release - 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 - States that it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees: Consistency, Availability and Partition tolerance.
• Cloud Design Patterns - Contains twenty-four design patterns that are useful in cloud-hosted applications. Includes: Circuit Breaker, Competing Consumers, CQRS, Event Sourcing, Gatekeeper, Cache-Aside, etc.
• Microservice Architecture - Particular way of designing software applications as suites of independently deployable services.
• Microservices and SOA - Similarities, differences, and where we go from here.
• Microservices – Please, don’t - Critical advice about some problems regarding a microservices approach.
• Microservices RefCard - Getting started with microservices.
• Microservices Trade-Offs - Guide to ponder costs and benefits of the mircoservices architectural style.
• Reactive Manifesto - Reactive systems definition.
• Reactive Streams - Initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.
• ROCAS 🔸^PDF - Resource Oriented Computing for Adaptive Systems.
• SECO 🔸^PDF - Understanding software ecosystems: a strategic modeling approach.
• Service Discovery in a Microservice Architecture - Overview of discovery and registration patterns.
• Testing Strategies in a Microservice Architecture - Approaches for managing the additional testing complexity of multiple independently deployable components.
• Your Server as a Function 🔸^PDF - Describes three abstractions which combine to present a powerful programming model for building safe, modular, and efficient server software: Composable futures, services and filters.

• Bla Bla Microservices Bla Bla - A talk at the O’Reilly Software Architecture Conference, April 2016.
• Challenges in Implementing MicroServices - A presentation at GOTO 2015 by Fred George.
• Microservices - A presentation at GOTO Berlin 2014 by Martin Fowler.

• Developing a RESTful Microservice in Python - A story of how an aging Java project was replaced with a microservice built with Python and Flask.
• Developing and Testing Microservices With Docker - An example of the processes involved in creating a simple Docker-packaged Node microservice.
• Game On! - Microservices architecture explained in the context of an old-school text-based adventure game.
• Microservices without the Servers - Step by step demo-driven talk about serverless architecture.
• Microservices in C#: Part 1, Part 2, Part 3, Part 4, Part 5.
• Microservices with Python, RabbitMQ and Nameko
• Reactive Microservices - Project showcasing different microservice communication styles using Scala, Akka, Play and other tools from Scala ecosystem.
• Using Packer and Ansible to build immutable infrastructure

• Building Microservices 🔸^PDF - Building Microservices: Designing Fine-grained Systems. Sam Newman. Preview Edition.
• Istio in Action - Teaches you how to implement a full-featured Istio-based service mesh to manage a microservices application.
• Microservice Architecture: Aligning Principles, Practices, and Culture - Practical advice for the strategy and design of Microservices.
• Microservices in Action - A practical book about building and deploying microservice-based applications.
• Microservice Patterns - Teaches how to build applications with the microservice architecture and how to refactor a monolithic application to a microservices.
• Microservices from Theory to Practice - Microservices from Theory to Practice: Creating Applications in IBM Bluemix Using the Microservices Approach. IBM Redbooks publication.
• Migrating to Cloud Native Application Architectures - This O’Reilly report defines the unique characteristics of cloud native application architectures such as microservices and twelve-factor applications.
• Testing Microservices with Mountebank - Provides a testing strategy using mountebank for service virtualization, promoting independent releases of Microservices
• The Art of Scalability - The Art of Scalability: Scalable Web Architecture, Processes, and Organizations for the Modern Enterprise. Martin L. Abbott, Michael T. Fisher.
• The New Stack eBook Series - A Comprehensive Overview of the Docker and Container Ecosystem.
  • Book 1: The Docker Container Ecosystem.
  • Book 2: Applications & Microservices with Docker & Containers.
  • Book 3: Automation & Orchestration with Docker & Containers.
  • Book 4: Network, Security & Storage with Docker & Containers.
  • Book 5: Monitoring & Management with Docker & Containers.
• The Tao of Microservices - Teaches the path to understanding how to apply microservices architecture with your own real-world projects.
• Micro Frontends in Action - A practical guide that teaches how to develop large software projects with multiple independent teams.

• Cloud Native Computing Foundation - 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 - Interactive landscape of cloud native technologies.
• Microservices Resource Guide - Martin Fowler's choice of articles, videos, books, and podcasts that can teach you more about the microservices architectural style.
• Microservice Patterns - Microservice architecture patterns and best practices.
• Microservice Antipatterns and Pitfalls - Microservice mostly known antipatterns and pitfalls.
• The 12-Factors App - A methodology for building software-as-a-service applications.

• BigchainDB - The scalable blockchain database.
• Blocknet - The Blocknet makes possible to deliver microservices over a blockchain-based P2P network architecture.
• Blockstack - A new decentralized internet where users control their data and apps run on their devices.
• CEPTR - A recomposable medium for distributed social computing, a semantic self-describing protocol stack, and a cretor of fractal coherence contexts for biomimetic computing.
• Edgware Fabric - Lightweight, agile service bus for systems at the edge of the network, in the physical world.
• Hyperledger - Open source collaborative effort created to advance cross-industry blockchain technologies. It is a global collaboration, hosted by The Linux Foundation, including leaders in finance, banking, IoT, supply chain, manufacturing and technology.
• Luna - Visual and textual functional programming language with a focus on productivity, collaboration and development ergonomics.
• MultiChain - Open platform for building blockchains.
• Node-RED - Visual tool for wiring together hardware devices, APIs and online services in new and interesting ways.
• ops - Free open source tool to build, run and deploy existing linux applications as unikernels.
• Pony - Open source, object-oriented, actor-model, capabilities-secure, high performance programming language.

Please, read the Contribution Guidelines before submitting your suggestion.

Feel free to open an issue or create a pull request with your additions.

🌟 Thank you!