fabric

package module
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 9, 2024 License: Apache-2.0 Imports: 1 Imported by: 0

README

Microbus.io logo

Microbus is a holistic open source framework for the development, testing, deployment and operation of microservices at scale. It combines tooling, guides, patterns and best practices into an elevated engineering experience. Build entire cloud-enabled, enterprise-class and web-scalable solutions comprising a multitude of microservices, all on your local development machine. Deploy to suit your needs, as a standalone executable or as pods on Kubernetes.

🍴 Table of Content

🚌 Introduction
⚙️ How It Works
🔧 Design Principles
🚦 Get Started
📚 Learn More
✋ Get involved
☎️ Contact us
📃 Legal

🚌 Introduction

A microservice architecture is essential for addressing the technical and organizational scalability challenges of a business as it scales. Without such architecture, the complexity of the codebase will grow to a point where the engineering team can no longer innovate and collaborate efficiently. In most likelihood the entire solution will have to be rewritten at a critical point of the business - when it is growing rapidly - and at a prohibitive cost. Investing in microservices from the get-go is a wise investment that mitigates this upside risk.

Building and operating microservices at scale, however, is quite difficult and beyond the skills of most engineering teams. It's easy to spin up one web server and call it a microservice but things get exponentially more complicated the more microservices are added to the mix. Many teams at some point either call it quits and stop adding microservices, or introduce complex tooling such as service meshes to help manage the complexity. Adding complexity to solve complexity is a self-defeating strategy: the chickens eventually come home to roost.

Microbus takes a novel approach to the development, testing, deployment and troubleshooting of microservices, and eliminates much of the complexity of the current state of the art. Microbus is a holistic framework that packages together various OSS technologies, tooling, best practices, patterns and guides into a cohesive engineering experience that elevates productivity up to 4x.

Microbus is the culmination of a decade of research and has been successfully battle-tested in production settings running SaaS solutions comprising many dozens of microservices.

⚙️ How It Works

Build your microservices on top of a Connector construct and use its simple API to communicate with other microservices using the familiar HTTP protocol. Under the hood, communication happens over a real-time messaging bus. Powerful features are handled transparently for you:

  • Unicast 1:1 request/response
  • Multicast 1:N publish/subscribe
  • Multiplexed connections
  • Dynamic service discovery
  • Load balancing
  • Time budget
  • Ack or fail fast
  • Locality-aware routing
  • Connectivity liveness check
  • Instrumentation and observability

Core microservices such as an HTTP ingress proxy and configurator are provided out of the box.

🔧 Design Principles

These core tenets were top of mind in the design of Microbus.

Elevated Engineering Experience

Microbus includes tooling, guides, patterns and best practices that facilitate rapid application development (RAD), thorough testing and pinpoint troubleshooting. The greater engineering velocity yields more value delivered to the customer faster.

Evade the Microservices Tax

Microbus is powered by a small curated set of OSS technologies integrated to work together in unison and exposed through a simplified API that keeps the learning curve short and operational complexity low.

  • Get up to speed quickly by virtue of a small tech stack and reasonable defaults
  • Keep the number of moving parts small and control operational complexity and cost
  • Transition from a modular monolith to microservices as your business grows

Adaptable Deployment Topology

From a local development machine to a multi-region cloud deployment, Microbus's adaptable topology grows with your needs. No code change required.

  • Deploy as a resilient modular monolith, or as microservices spread across multiple cloud regions
  • Run as a standalone executable or as pods on Kubernetes
  • Include any number of microservices in each executable or pod

Scalable, Resilient and Performant

From individual microservices down to the messaging bus, components at all levels of Microbus can be scaled horizontally. No single points of failure or bottlenecks.

  • Serve thousands of requests per second per machine right out of the box
  • Scale your system horizontally as your requirements grow
  • Place your trust in a thoroughly-tested substrate

Common Runtime

All microservices running on Microbus comply with the same set of rules for unicast or multicast communications, configuration, observability, and more. This consistent behavior makes it easier to reason about the accuracy of the system, guaranteeing smooth interoperability, straightforward maintainability and verifiable stability.

  • Benefit from improved reliability with multiplexed connections, graceful shutdown, time budgets and acks
  • Observe every detail of interaction between microservices
  • Centralize the configuration of all microservices

🚦 Get Started

👉 Follow the quick start guide to set up your system and run the example app

👉 Go through the various examples

👉 Follow the step-by-step guide and build your first microservice

👉 Discover the power of code generation. It's totally RAD, dude

👉 Learn how to write thorough integration tests and achieve high code coverage

👉 Venture out and explore more on your own

👉 Ready? Build your own solution from scratch

📚 Learn More

Dig deeper into the technology of Microbus and its philosophy.

Architecture

Guides

Under the Hood

  • HTTP ingress proxy - The HTTP ingress proxy bridges the gap between HTTP and Microbus
  • Unicast messaging - Unicast enables bi-directional 1:1 request/response HTTP messaging between a client and a single server over the bus
  • Multicast messaging - Extending on the unicast pattern, multicast enables bi-directional 1:N publish/subscribe HTTP messaging between a client and a multitude of servers over the bus
  • Error capture - How and why errors are captured and propagated across microservices boundaries
  • Time budget - The right way to manage client-to-server request timeouts
  • Control subscriptions - Subscriptions that all microservices implement out of the box on port :888
  • Deployment environments - An application can run in one of 4 deployment environments: PROD, LAB, LOCAL and TESTING
  • Events - How event-driven architecture can be used to decouple microservices
  • Distributed tracing - Visualizing stack traces across microservices using OpenTelemetry and Jaeger
  • OpenAPI - OpenAPI document generation for microservices
  • Local development - Run an entire solution comprising a multitude of microservices in your local IDE

Design Choices

Miscellaneous

  • Milestones - Each milestone of Microbus is maintained in a separate branch for archival purposes and to demonstrate the development process and evolution of the code.

✋ Get Involved

We want your feedback. Clone the repo, try things out and let us know what worked for you, what didn't and what you'd like to see improved.

Help us spread the word. Let your peers and the Go community know about Microbus.

Give us a Github ⭐. And ask all your friends to give us one too!

Reach out if you'd like to contribute code.

Corporation? Contact us for sponsorship opportunities.

☎️ Contact Us

Find us at any of the following channels. We're looking forward to hearing from you so don't hesitate to drop us a line.

Find us at...
Website www.microbus.io
Email info@microbus.io
Github github.com/microbus-io
LinkedIn linkedin.com/company/microbus-io
Slack microbus-io.slack.com
Discord discord.gg/FAJHnGkNqJ
Reddit r/microbus
YouTube @microbus-io

The Microbus framework is the copyrighted work of various contributors. It is licensed by Microbus LLC - a Delaware limited liability company formed to hold the combined intellectual property - under the Apache License 2.0.

Refer to the list of third-party open source software for licensing information of components used by the Microbus framework.

Test

Documentation

The Go Gopher

There is no documentation for this package.

Source Files

View all Source files

Directories

Path Synopsis
Application is a collection of microservices that run in a single process and share the same lifecycle
 Application is a collection of microservices that run in a single process and share the same lifecycle
Package cfg is used for defining configuration properties.
 Package cfg is used for defining configuration properties.
spec
tester
Package tester implements the codegen.test microservice.
 Package tester implements the codegen.test microservice.
tester/app/tester command
tester/intermediate
Package intermediate serves as the foundation of the codegen.test microservice.
 Package intermediate serves as the foundation of the codegen.test microservice.
tester/resources
tester/testerapi
Package testerapi implements the public API of the codegen.test microservice, including clients and data structures.
 Package testerapi implements the public API of the codegen.test microservice, including clients and data structures.
Package connector implements the base class of all microservices.
 Package connector implements the base class of all microservices.
coreservices
configurator
Package configurator implements the configurator.core microservice.
 Package configurator implements the configurator.core microservice.
configurator/app/configurator command
configurator/configuratorapi
Package configuratorapi implements the public API of the configurator.core microservice, including clients and data structures.
 Package configuratorapi implements the public API of the configurator.core microservice, including clients and data structures.
configurator/intermediate
Package intermediate serves as the foundation of the configurator.core microservice.
 Package intermediate serves as the foundation of the configurator.core microservice.
configurator/resources
control
Package control implements the control.core microservice.
 Package control implements the control.core microservice.
control/app/control command
control/controlapi
Package controlapi implements the public API of the control.core microservice, including clients and data structures.
 Package controlapi implements the public API of the control.core microservice, including clients and data structures.
control/intermediate
Package intermediate serves as the foundation of the control.core microservice.
 Package intermediate serves as the foundation of the control.core microservice.
control/resources
httpegress
Package httpegress implements the http.egress.core microservice.
 Package httpegress implements the http.egress.core microservice.
httpegress/app/httpegress command
httpegress/httpegressapi
Package httpegressapi implements the public API of the http.egress.core microservice, including clients and data structures.
 Package httpegressapi implements the public API of the http.egress.core microservice, including clients and data structures.
httpegress/intermediate
Package intermediate serves as the foundation of the http.egress.core microservice.
 Package intermediate serves as the foundation of the http.egress.core microservice.
httpegress/resources
httpingress
Package httpingress implements the http.ingress.core microservice.
 Package httpingress implements the http.ingress.core microservice.
httpingress/app/httpingress command
httpingress/httpingressapi
Package httpingressapi implements the public API of the http.ingress.core microservice, including clients and data structures.
 Package httpingressapi implements the public API of the http.ingress.core microservice, including clients and data structures.
httpingress/intermediate
Package intermediate serves as the foundation of the http.ingress.core microservice.
 Package intermediate serves as the foundation of the http.ingress.core microservice.
httpingress/resources
metrics
Package metrics implements the metrics.core microservice.
 Package metrics implements the metrics.core microservice.
metrics/app/metrics command
metrics/intermediate
Package intermediate serves as the foundation of the metrics.core microservice.
 Package intermediate serves as the foundation of the metrics.core microservice.
metrics/metricsapi
Package metricsapi implements the public API of the metrics.core microservice, including clients and data structures.
 Package metricsapi implements the public API of the metrics.core microservice, including clients and data structures.
metrics/resources
openapiportal
Package openapiportal implements the openapiportal.core microservice.
 Package openapiportal implements the openapiportal.core microservice.
openapiportal/app/openapiportal command
openapiportal/intermediate
Package intermediate serves as the foundation of the openapiportal.core microservice.
 Package intermediate serves as the foundation of the openapiportal.core microservice.
openapiportal/openapiportalapi
Package openapiportalapi implements the public API of the openapiportal.core microservice, including clients and data structures.
 Package openapiportalapi implements the public API of the openapiportal.core microservice, including clients and data structures.
openapiportal/resources
smtpingress
Package smtpingress implements the smtp.ingress.core microservice.
 Package smtpingress implements the smtp.ingress.core microservice.
smtpingress/app/smtpingress command
smtpingress/intermediate
Package intermediate serves as the foundation of the smtp.ingress.core microservice.
 Package intermediate serves as the foundation of the smtp.ingress.core microservice.
smtpingress/resources
smtpingress/smtpingressapi
Package smtpingressapi implements the public API of the smtp.ingress.core microservice, including clients and data structures.
 Package smtpingressapi implements the public API of the smtp.ingress.core microservice, including clients and data structures.
Package dlru implements an LRU cache that is distributed among the peers of a microservice.
 Package dlru implements an LRU cache that is distributed among the peers of a microservice.
Package env manages the loading of environment variables.
 Package env manages the loading of environment variables.
Package errors replaces the standard Go package, adding the ability to attach a stack trace and annotations to an error
 Package errors replaces the standard Go package, adding the ability to attach a stack trace and annotations to an error
examples
browser
Package browser implements the browser.example microservice.
 Package browser implements the browser.example microservice.
browser/app/browser command
browser/browserapi
Package browserapi implements the public API of the browser.example microservice, including clients and data structures.
 Package browserapi implements the public API of the browser.example microservice, including clients and data structures.
browser/intermediate
Package intermediate serves as the foundation of the browser.example microservice.
 Package intermediate serves as the foundation of the browser.example microservice.
browser/resources
calculator
Package calculator implements the calculator.example microservice.
 Package calculator implements the calculator.example microservice.
calculator/app/calculator command
calculator/calculatorapi
Package calculatorapi implements the public API of the calculator.example microservice, including clients and data structures.
 Package calculatorapi implements the public API of the calculator.example microservice, including clients and data structures.
calculator/intermediate
Package intermediate serves as the foundation of the calculator.example microservice.
 Package intermediate serves as the foundation of the calculator.example microservice.
calculator/resources
directory
Package directory implements the directory.example microservice.
 Package directory implements the directory.example microservice.
directory/app/directory command
directory/directoryapi
Package directoryapi implements the public API of the directory.example microservice, including clients and data structures.
 Package directoryapi implements the public API of the directory.example microservice, including clients and data structures.
directory/intermediate
Package intermediate serves as the foundation of the directory.example microservice.
 Package intermediate serves as the foundation of the directory.example microservice.
directory/resources
eventsink
Package eventsink implements the eventsink.example microservice.
 Package eventsink implements the eventsink.example microservice.
eventsink/app/eventsink command
eventsink/eventsinkapi
Package eventsinkapi implements the public API of the eventsink.example microservice, including clients and data structures.
 Package eventsinkapi implements the public API of the eventsink.example microservice, including clients and data structures.
eventsink/intermediate
Package intermediate serves as the foundation of the eventsink.example microservice.
 Package intermediate serves as the foundation of the eventsink.example microservice.
eventsink/resources
eventsource
Package eventsource implements the eventsource.example microservice.
 Package eventsource implements the eventsource.example microservice.
eventsource/app/eventsource command
eventsource/eventsourceapi
Package eventsourceapi implements the public API of the eventsource.example microservice, including clients and data structures.
 Package eventsourceapi implements the public API of the eventsource.example microservice, including clients and data structures.
eventsource/intermediate
Package intermediate serves as the foundation of the eventsource.example microservice.
 Package intermediate serves as the foundation of the eventsource.example microservice.
eventsource/resources
hello
Package hello implements the hello.example microservice.
 Package hello implements the hello.example microservice.
hello/app/hello command
hello/helloapi
Package helloapi implements the public API of the hello.example microservice, including clients and data structures.
 Package helloapi implements the public API of the hello.example microservice, including clients and data structures.
hello/intermediate
Package intermediate serves as the foundation of the hello.example microservice.
 Package intermediate serves as the foundation of the hello.example microservice.
hello/resources
helloworld
Package helloworld implements the helloworld.example microservice.
 Package helloworld implements the helloworld.example microservice.
helloworld/app/helloworld command
helloworld/helloworldapi
Package helloworldapi implements the public API of the helloworld.example microservice, including clients and data structures.
 Package helloworldapi implements the public API of the helloworld.example microservice, including clients and data structures.
helloworld/intermediate
Package intermediate serves as the foundation of the helloworld.example microservice.
 Package intermediate serves as the foundation of the helloworld.example microservice.
helloworld/resources
messaging
Package messaging implements the messaging.example microservice.
 Package messaging implements the messaging.example microservice.
messaging/app/messaging command
messaging/intermediate
Package intermediate serves as the foundation of the messaging.example microservice.
 Package intermediate serves as the foundation of the messaging.example microservice.
messaging/messagingapi
Package messagingapi implements the public API of the messaging.example microservice, including clients and data structures.
 Package messagingapi implements the public API of the messaging.example microservice, including clients and data structures.
messaging/resources
Package httpx includes various HTTP utilities.
 Package httpx includes various HTTP utilities.
Package log defines type-safe fields that can be attached to log messages
 Package log defines type-safe fields that can be attached to log messages
Package pub is used for the publishing of requests.
 Package pub is used for the publishing of requests.
Package rand combines crypto.rand and math.rand for more secure random number generation with reduced performance impact.
 Package rand combines crypto.rand and math.rand for more secure random number generation with reduced performance impact.
Package service defines the interfaces of a microservice, which the connector implements.
 Package service defines the interfaces of a microservice, which the connector implements.
Package sub is used for subscribing to handle requests.
 Package sub is used for subscribing to handle requests.
Package trc is used for working with tracing spans.
 Package trc is used for working with tracing spans.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.