Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

awesome-microservices

A curated list of Microservice Architecture related principles and technologies.
https://github.com/mfornos/awesome-microservices

Last synced: 4 days ago
JSON representation

  • Platforms

    • Jolie - Open source microservice-oriented programming language.
    • 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).
    • Wing - Cloud-oriented programming language. It allows developers to build distributed systems that fully leverage the power of the cloud without having to worry about the underlying infrastructure.
    • Triton - Open-source cloud management platform that delivers next generation, container-based, service-oriented infrastructure across one or more data centers.
    • Jolie - Open source microservice-oriented programming language.
    • Kalix (c) - Platform as a Service that abstracts away the complexity of event-driven microservices.

  • Frameworks / Runtimes

    • Ballerina - Cloud native programming language.
    • Dapr - Open source runtime for writing highly performant microservices using any programming language.
    • Micronaut - A modern, JVM-based, full-stack framework for building modular, easily testable microservice applications.
    • Moleculer - Fast & powerful microservices framework for Node.js, Java, Go and Ruby.
    • Eclipse Microprofile - An open forum to optimize Enterprise Java for a microservices architecture by innovating across multiple implementations and collaborating on common areas of interest with a goal of standardization.
    • Finagle - Extensible RPC system for the JVM, used to construct high-concurrency servers.
    • Helidon - Collection of Java libraries for writing microservices that run on a fast web core powered by Netty.
    • Ice - Comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python, and more.
    • Wangle - A framework providing a set of common client/server abstractions for building services in a consistent, modular, and composable way.
    • GraalVM - High-performance runtime that provides significant improvements in application performance and efficiency which is ideal for microservices.
    • Deno - JavaScript, TypeScript, and WebAssembly runtime with secure defaults and a great developer experience.
    • Bun - Fast all-in-one JavaScript runtime.
    • Gleam - A friendly language for building type-safe, scalable systems.
    • Open Liberty - A lightweight open framework for building fast and efficient cloud-native Java microservices.
    • SmallRye - APIs and implementations tailored for cloud development, including Eclipse MicroProfile.
    • Light-4j - A high throughput, low latency, small memory footprint and more productive microservices platform.
    • Erlang/OTP - Programming language used to build massively scalable soft real-time systems with requirements on high availability.
    • Modus - An open source, serverless framework for building intelligent functions and APIs, powered by WebAssembly.
    • Orbit - Modern framework for JVM languages that makes it easier to build and maintain distributed and scalable online services.
    • Pears - Peer-to-peer runtime, development and deployment.
    • Spin - An open source framework for building and running fast, secure, and composable cloud microservices with WebAssembly.

  • Service Toolkits

    • Polyglot

      • Hprose - A very newbility RPC Library, support 25+ languages now.

    • 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.
      • Kore - Easy to use web application framework for writing scalable web APIs in C.
      • Onion - C library to create simple HTTP servers and web applications.

    • C++

      • Poco - C++ class libraries for building network-based applications and servers.
      • Cap’n Proto RPC - The Cap’n Proto C++ RPC implementation.
      • C++ Micro Services - An OSGi-like C++ dynamic module system and service registry.
      • Pistache - A high-performance REST toolkit written in C++.
      • Sogou Workflow - Enterprise-grade programming engine aimed to satisfy most of the backend development requirements.

    • CSharp

      • Akka.NET - Toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on .NET & Mono.
      • 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.
      • Awesome Microservices .NET Core - A collection of awesome training series, articles, videos, books, courses, sample projects, and tools for microservices in .NET Core.

    • Erlang VM

      • 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.

    • Go

      • Gorilla - Web toolkit for the Go programming language.
      • Chi - Lightweight, idiomatic and composable router for building Go HTTP services.
      • Go-micro - A distributed systems development framework.
      • Micro - A distributed systems runtime for the cloud and beyond.
      • Echo - Fast and unfancy HTTP server framework for Go. Up to 10x faster than the rest.
      • Iris - Fast, simple and efficient micro web framework for Go.
      • go-zero - A web and rpc distributed system development framework.
      • 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.
      • Fiber - Express inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go. Designed to ease things up for fast development with zero memory allocation and performance in mind.
      • Goa - Design-based HTTP microservices in Go.
      • GoFr - An opinionated microservice development framework emphasizing scalability and robustness. Designed to simplify the development of microservices.
      • Go Chassis - A framework for rapid development of microservices in Go that is easy to integrate with some cloud ecosystems.
      • Go kit - Distributed programming toolkit for microservices in the modern enterprise.
      • Lura - Framework to build ultra performance API Gateways with middlewares.
      • Negroni - Idiomatic HTTP middleware for Golang.
      • RPCX - A distributed RPC service framework based on NET/RPC like Alibaba Dubbo and Weibo Motan.

    • Java VM

      • Armeria - Open-source asynchronous HTTP/2 RPC/REST client/server library built on top of Java 8, Netty, Thrift and gRPC.
      • Http4s - A minimal, idiomatic Scala interface for HTTP
      • Conjure - 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.
      • 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.
      • Quarkus - A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.
      • Airlift - Framework for building REST services in Java.
      • 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.
      • Ktor - Framework for building asynchronous servers and clients in connected systems using the Kotlin programming language.
      • Jersey - RESTful services in Java. JAX-RS reference implementation.
      • Ratpack - Set of Java libraries that facilitate fast, efficient, evolvable and well tested HTTP applications. specific support for the Groovy language is provided.
      • Finatra - Fast, testable, Scala HTTP services built on Twitter-Server and Finagle.
      • Play - The high velocity web framework for Java and Scala.
      • Squbs - A suite of components enabling standardization and operationalization of Akka and Akka HTTP applications/services in a large scale, managed, cloud environment.
      • Armeria - Open-source asynchronous HTTP/2 RPC/REST client/server library built on top of Java 8, Netty, Thrift and gRPC.
      • Compojure - A concise routing library for Ring/Clojure.
      • Duct - Minimal framework for building web applications in Clojure, with a strong emphasis on simplicity.
      • 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.

    • Node.js

      • Actionhero - Multi-transport Node.js API server with integrated cluster capabilities and delayed tasks.
      • Cyclic.sh (c) - Simple serverless platform and dev tools for node.js services with Express.js support.
      • Fastify - Fastify, Fast and low overhead web framework, for Node.js.
      • FeathersJS - An open source REST and realtime API layer for modern applications.
      • Koa - Next generation web framework for Node.js
      • Loopback - Node.js framework for creating APIs and easily connecting to backend data sources.
      • Hono - Small, simple, and ultrafast web framework for the Edges. It works on any JavaScript runtime.
      • 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).
      • tRPC - End-to-end typesafe APIs.
      • NestJS - A Node.js framework for building efficient and scalable server-side applications with a built-in microservices support.

    • Perl

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

    • Python

      • Bottle - Fast, simple and lightweight WSGI micro web-framework for Python.
      • Twisted - Event-driven network programming engine.
      • FastAPI - Modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
      • Sanic - Sanic is a Flask-like Python 3.5+ web server that's written to go fast.
      • Flask - Python framework for microservices based on Werkzeug and Jinja 2.
      • Aiohttp - HTTP client/server for asyncio.
      • Falcon - Bare-metal Python web API framework for building very fast app backends and microservices.

    • PHP

      • Ecotone - Framework based on architectural principles of DDD, CQRS and Event Sourcing that provides building blocks to create scalable and extensible applications.
      • Spiral - 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.
      • Symfony - Micro-framework based on the Symfony components.
      • Phalcon - Full-stack PHP framework delivered as a C-extension.
      • 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.
      • API Platform - API-first web framework on top of Symfony with JSON-LD, Schema.org and Hydra support.

    • Rust

      • Are we web yet? - A summary of the current state of web programming in Rust.
      • Actix - Powerful, pragmatic, and extremely fast web framework for Rust.
      • Tower - Library of modular and reusable components for building robust networking clients and servers.
      • Wtx - HTTP/2 client/server framework.
      • Tarpc - RPC framework for Rust with a focus on ease of use.

    • Haskell

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

    • Ruby

      • Scorched - Light-weight web framework for Ruby.
      • Grape - An opinionated framework for creating REST-like APIs
      • Hanami - A modern web framework for Ruby.

  • Frontend / UI

  • Capabilities

    • API Gateways / Edge Services

    • Configuration & Discovery

      • Spring Cloud Config - Provides server and client-side support for externalized configuration in a distributed system.
      • 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.
      • Etcd - Highly-available key-value store for shared configuration and service discovery.
      • Nacos - Easy-to-use dynamic service discovery, configuration and service management platform.
      • SkyDNS - Distributed service for announcement and discovery of services built on top of etcd. It utilizes DNS queries to discover available services.
      • ZooKeeper - Open source server which enables highly reliable distributed coordination.
      • 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.

    • Elasticity

      • 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.
      • Libp2p - A framework and suite of protocols for building peer-to-peer network applications.
      • Zenoh - Pub/sub/query protocol unifying data in motion, data at rest and computations. Efficiently blends traditional pub/sub with geo distributed storage, queries and computations.
      • Nomad - Distributed, highly available, datacenter-aware scheduler.
      • 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.
      • Serf - Decentralized solution for cluster membership, failure detection and orchestration.
      • Valkey - A new project to resume development on the formerly open-source Redis project.

    • Job Schedulers / Workload Automation

      • Dkron - Distributed, fault tolerant job scheduling system.
      • Rundeck (c) - Job scheduler and runbook automation. Enable self-service access to existing scripts and tools.
      • Dkron - Distributed, fault tolerant job scheduling system.
      • Faktory - Language-agnostic persistent background job server.
      • Schedulix - Open source enterprise job scheduling system lays down ground-breaking standards for the professional automation of IT processes in advanced system environments.
      • Celery - Asynchronous task queue/job queue based on distributed message passing. Focused on real-time operation and supports scheduling.

    • Logging

      • LogDNA (c) - Centralized log management software. Instantly collect, centralize, and analyze logs in real-time from any platform, at any volume.
      • Graylog - Fully integrated open source log management platform.
      • Logstash - Tool for managing events and logs.
      • Loki - Like Prometheus, but for logs.
      • Kibana - Flexible analytics and visualization platform.

    • Messaging

      • ØMQ - Brokerless intelligent transport layer.
      • Mosca - MQTT broker as a module.
      • Mosquitto - Open source message broker that implements the MQTT protocol.
      • VerneMQ - Open source, scalable, Erlang-based MQTT broker.
      • Beanstalk - Simple, fast work queue.
      • Malamute - ZeroMQ enterprise messaging broker.
      • Redpanda - Streaming data platform for developers: Kafka API compatible, 10x faster, no ZooKeeper and no JVM.
      • VerneMQ - Open source, scalable, Erlang-based MQTT broker.
      • RocketMQ - A low latency, reliable, scalable, easy to use message oriented middleware born from alibaba massive messaging business.
      • NATS - Open source, high-performance, lightweight cloud messaging system.
      • Pulsar - Distributed pub-sub messaging system.
      • Aeron - Efficient reliable UDP unicast, UDP multicast, and IPC message transport.
      • Bull - Fast and reliable Redis-based queue for Node.
      • Crossbar - Open source networking platform for distributed and microservice applications. It implements the open Web Application Messaging Protocol (WAMP).
      • Mosca - MQTT broker as a module.
      • RabbitMQ - Open source Erlang-based message broker that just works.

    • Monitoring & Debugging

      • Beats - Lightweight shippers for Elasticsearch & Logstash.
      • Grafana - An open source, feature rich metrics dashboard and graph editor for Graphite, InfluxDB & OpenTSDB.
      • Zabbix - Open source enterprise-class monitoring solution.
      • Riemann - Monitors distributed systems.
      • Sensu - Monitoring for today's infrastructure.
      • Zabbix - Open source enterprise-class monitoring solution.
      • Elastalert - Easy & flexible alerting for Elasticsearch.
      • IOpipe (c) - Application performance monitoring for Amazon Lambda.
      • Jaeger - An open source, end-to-end distributed tracing
      • OpenTelemetry - High-quality, ubiquitous, and portable telemetry to enable effective observability.
      • SkyWalking - Application performance monitor tool for distributed systems, especially designed for microservices, cloud native and container-based (Docker, K8s, Mesos) architectures.

    • Resilience

      • Resilient HTTP - A smart HTTP client with super powers like fault tolerance, dynamic server discovery, auto balancing and reactive recovery, designed for distributed systems.
      • Svix - Webhooks service that sends webhooks to your users with full retry schedules, exponential backoff, signature verification, and event types.
      • Awesome Chaos Engineering - A curated list of awesome chaos engineering resources.
      • 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.
      • 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.
      • Raft Consensus - Consensus algorithm that is designed to be easy to understand. It's equivalent to Paxos in fault-tolerance and performance.

    • Security

      • OpenID Connect - Libraries, products, and tools implementing current OpenID specifications and related specs.
      • Open Ziti - Zero trust security and overlay networking as pure open source software.
      • OpenID Connect - Libraries, products, and tools implementing current OpenID specifications and related specs.
      • SCIM - System for Cross-domain Identity Management.
      • Open Ziti - Zero trust security and overlay networking as pure open source software.
      • Dex - Opinionated auth/directory service with pluggable connectors. OpenID Connect provider and third-party OAuth 2.0 delegation.
      • 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.
      • Vault - Secures, stores, and tightly controls access to tokens, passwords, certificates, API keys, and other secrets in modern computing.
      • Cerbos Hub - Authorization management system for authoring, testing, and deploying access policies. Built scalable, fine-grained authorization in a microservice architecture.
      • ORY - Open source identity infrastructure and services.

    • Serialization

      • Etch - Cross-platform, language and transport-independent framework for building and consuming network services.
      • MessagePack - Efficient binary serialization format.
      • Avro - Apache data serialization system providing rich data structures in a compact, fast, binary data format.
      • Cap’n Proto - Insanely fast data interchange format and capability-based RPC system.
      • CBOR - Implementations of the CBOR standard (RFC 7049) in many languages.
      • FST - Fast java serialization drop in-replacement.
      • Jackson - A multi-purpose Java library for processing JSON data format.
      • Kryo - Java serialization and cloning: fast, efficient, automatic.
      • Cereal - C++11 library for serialization.
      • Cheshire - Clojure JSON and JSON SMILE encoding/decoding.
      • Fastjson - Fast JSON Processor.
      • Ffjson - Faster JSON serialization for Go.
      • Jackson Afterburner - Jackson module that uses bytecode generation to further speed up data binding (+30-40% throughput for serialization, deserialization).
      • 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.

    • Storage

      • Aerospike (c) - High performance NoSQL database delivering speed at scale.
      • ClickHouse - Column-oriented database management system that allows generating analytical data reports in real time.
      • Crate (c) - Scalable SQL database with the NoSQL goodies.
      • Geode - Open source, distributed, in-memory database for scale-out applications.
      • OpenTSDB - Scalable and distributed time series database written on top of Apache HBase.
      • Couchbase - A distributed database engineered for performance, scalability, and simplified administration.
      • InfluxDB - Scalable datastore for metrics, events, and real-time analytics.
      • Elasticsearch - Open source distributed, scalable, and highly available search server.
      • ClickHouse - Column-oriented database management system that allows generating analytical data reports in real time.
      • AtlasDB - Transactional layer on top of a key value store.
      • Citus - Distributed PostgreSQL as an extension.
      • Couchbase - A distributed database engineered for performance, scalability, and simplified administration.
      • Pilosa - Open source, distributed bitmap index that dramatically accelerates queries across multiple, massive data sets.
      • Secure Scuttlebutt - P2P database of message-feeds.
      • TiKV - Distributed transactional key-value database.
      • Trino - Fast distributed SQL query engine for big data analytics that helps you explore your data universe.
      • Alluxio - Virtual distributed storage system.
      • CockroachDB (c) - A cloud-native SQL database modelled after Google Spanner.

    • Testing

      • Mountebank - Cross-platform, multi-protocol test doubles over the wire.
      • Pact - Contract testing framework for HTTP APIs and non-HTTP asynchronous messaging systems.
      • 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.
      • 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.
      • Goreplay - A tool for capturing and replaying live HTTP traffic into a test environment.
      • 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.
      • RestQA - A tool to manage microservices mocking, unit and performance testing locally with best in class developer experience.
      • Wilma - Combined HTTP/HTTPS service stub and transparent proxy solution.
      • Hoverfly - Lightweight service virtualization/API simulation tool for developers and testers.

    • Workflow Orchestration

      • Zeebe - Define, orchestrate, and monitor business processes across microservices.
      • Inngest - Durable functions for reliable background logic, from background jobs to complex workflows.
      • AWS Step Functions (c) - Coordinate the components of distributed applications and microservices using visual workflows.
      • Cadence - Fault-oblivious stateful code platform.
      • Conductor - A microservices orchestration engine.
      • Kestra - Open source microservices event-driven, language-agnostic orchestration and scheduling platform.
      • Temporal - Open source microservices orchestration platform for running mission critical code at any scale.

    • Reactivity

      • RSocket - Application protocol providing Reactive Streams semantics.
      • Reactor.io - A second-generation Reactive library for building non-blocking applications on the JVM based on the Reactive Streams Specification.

  • Web API Modeling & Documentation

    • REST

      • RAML - RESTful API Modeling Language, a simple and succinct way of describing practically-RESTful APIs.
      • Spring REST Docs - Document RESTful services by combining hand-written documentation with auto-generated snippets produced with Spring MVC Test.
      • OpenAPI - The OpenAPI Specification (OAS) provides a consistent means to carry information through each stage of the API lifecycle.
      • Swagger - A simple yet powerful representation of your RESTful API.
      • 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.
      • ReDoc - OpenAPI/Swagger-generated API Documentation.
      • Slate - Beautiful static documentation for your API.

    • JSON

      • JSON:API - A specification for how a client should request that resources be fetched or modified, and how a server should respond to those requests.

  • Standards / Recommendations

    • World Wide Web

      • 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.

    • Self-sovereignty & Decentralisation

      • DID - W3C specification of Decentralized identifiers (DIDs): a new type of identifier that enables verifiable, decentralized digital identity.
      • IDSA - 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.
      • DID - W3C specification of Decentralized identifiers (DIDs): a new type of identifier that enables verifiable, decentralized digital identity.
      • DIDComm Protocols - Registry of protocols built on DIDComm, for high-trust, self-sovereign interactions over any transport.
      • DIDComm - Private communication methodology built atop the decentralized design of DIDs.

    • HTTP/1.1

    • HTTP/2

      • RFC7540 - Hypertext Transfer Protocol Version 2.

    • QUIC

      • QUIC-Transport - A UDP-based multiplexed and secure transport.
      • QUIC-Transport - A UDP-based multiplexed and secure transport.
      • QUIC-WG - IETF Working Group that is chartered to deliver the next transport protocol for the Internet.

    • Security

      • 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.
      • 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.
      • RFC6962 - Certificate transparency.
      • 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.
      • RFC6962 - Certificate transparency.
      • GNAP - 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.<sup>DRAFT</sup>
      • PASETO - Paseto is everything you love about JOSE (JWT, JWE, JWS) without any of the many design deficits that plague the JOSE standards. <sup>DRAFT</sup>

    • Data Formats

      • RFC4627 - JavaScript Object Notation (JSON).
      • RFC7049 - Concise Binary Object Representation (CBOR).
      • RFC7049 - Concise Binary Object Representation (CBOR).
      • SBE - Simple Binary Encoding (SBE).
      • MSGPACK - MessagePack Specification.

    • 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.

    • Unicode

      • 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.
      • UNIV8 - The Unicode Consortium. The Unicode Standard, Version 8.0.0, (Mountain View, CA: The Unicode Consortium, 2015. ISBN 978-1-936213-10-8).

    • RPC

      • Open RPC - The OpenRPC Specification defines a standard, programming language-agnostic interface description for JSON-RPC 2.0 APIs.

    • Messaging

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

    • Service Discovery

      • DNS-SD - Mechanism for clients to discover a list of named instances of a service, using standard DNS queries.
      • RFC2782 - A DNS RR for specifying the location of services (DNS SRV).

  • Organization Design / Team Dynamics

    • Unicode

      • How Do Committees Invent? - Melvin E. Conway, Datamation magazine 1968. The original article defining Conway's Law.
      • Start with Team Cognitive Load - Team Topologies - 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.
      • How Do Committees Invent? - Melvin E. Conway, Datamation magazine 1968. The original article defining Conway's Law.
      • Service per Team - 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.

  • Enterprise & Verticals

    • Unicode

      • Elasticpath - E-commerce microservices.
      • Commercetools - Headless commerce platform.
      • Equinox - Infosys Equinox is a human-centric commerce and marketing platform that supports rich, hyper-personalized experiences across any channel and touchpoint.
      • Flamingo - Framework to build flexible and modern e-commerce applications.
      • Medusa - Headless open source commerce platform.

  • Theory

    • Articles & Papers

      • Autonomy, Hyperconnectivity, and Residual Causality - Philosophical introduction to the design of adaptive hyperliminal systems through complexity science theories.
      • AKF Scale Cube - Model depicting the dimensions to scale a service.
      • CALM - 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.
      • 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 - Resource Oriented Computing for Adaptive Systems.
      • SECO - 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 - 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 - Overview of the state of microservices in both industrial and academia.
      • 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.
      • Microservices - The Journey So Far and Challenges Ahead - Overview of the state of microservices in both industrial and academia.
      • Autonomy, Hyperconnectivity, and Residual Causality - Philosophical introduction to the design of adaptive hyperliminal systems through complexity science theories.
      • Reactive Streams - Initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.
      • ROCAS - Resource Oriented Computing for Adaptive Systems.
      • Formal Foundations of Serverless Computing - 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.
      • A Sidecar for Your Service Mesh - A short service mesh introduction.
      • Formal Foundations of Serverless Computing - 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 - 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.
      • Microservices – Please, don’t - Critical advice about some problems regarding a microservices approach.
      • Microservices RefCard - Getting started with microservices.
      • 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.
      • Awesome Scalability - 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.
      • Microservices - From Design to Deployment - F5's seven-part series on microservices.

    • Sites & Organizations

  • Continuous Integration & Delivery

    • Testing

      • Awesome CI/CD DevOps - A curated list of awesome tools for continuous integration, continuous delivery and DevOps.
Programming Languages
Go 25 Java 20 Python 6 JavaScript 6 Rust 6 C 5 Clojure 4 C++ 4 Haskell 3 Ruby 3
Categories
Capabilities 180 Service Toolkits 89 Standards / Recommendations 49 Theory 33 Frameworks / Runtimes 21 Web API Modeling & Documentation 8 Platforms 6 Enterprise & Verticals 5 Frontend / UI 4 Organization Design / Team Dynamics 4 License 1 Continuous Integration & Delivery 1
Sub Categories
API Gateways / Edge Services 54 Articles & Papers 28 Security 25 Java VM 20 Messaging 19 Storage 18 Go 16 Serialization 15 Unicode 12 Testing 12 Node.js 11 Monitoring & Debugging 11 Rust 9 Elasticity 9 Configuration & Discovery 8 Workflow Orchestration 7 Python 7 REST 7 HTTP/1.1 7 Resilience 7 Job Schedulers / Workload Automation 6 Sites & Organizations 6 PHP 6 Logging 5 Data Formats 5 C++ 5 Self-sovereignty & Decentralisation 5 Erlang VM 4 World Wide Web 4 Haskell 3 C 3 Ruby 3 QUIC 3 CSharp 3 Perl 2 Service Discovery 2 Reactivity 2 HTTP/2 1 RPC 1 Polyglot 1 JSON 1 Vocabularies 1
Keywords
go 17 java 11 microservices 11 golang 10 distributed-systems 9 http 9 microservice 9 framework 8 grpc 7 api 7 kubernetes 6 database 6 rest-api 5 http2 5 serverless 5 proxy 5 devops 5 web 5 web-framework 5 websocket 5 rest 4 middleware 4 router 4 server 4 rust 4 cloud-native 4 workflows 3 cache 3 metrics 3 sql 3 reverse-proxy 3 api-gateway 3 http-server 3 python 3 rpc 3 https 3 testing-tools 3 swagger 3 service-mesh 3 openapi 3 serialization 3 cloud 3 microservice-framework 3 docker 3 performance 3 javascript 3 microservices-architecture 3 dubbo 3 workflow-engine 3 redis 3