Overview
QuickStart
Toolkit architectureMicroservice structureSetup environmentYour first microserviceFAQ
Tutorials
Data microserviceClient libraryMicroservice facadeMicroservice dockerization
Recipies
Logging
Configuration
Component References
Component lifecycle
Memory persistence
MongoDB persistence.
Active logic
API docs
Commons module
Components module
Container module
Data module
RPC module
Messaging module
MongoDB module
Couchbase module
Memcached module
Redis module
GRPC module
Elasticsearch module
Prometheus module
MQTT Module
RabbitMQ module
AWS module
Azure module
Fluentd module
To Quick start

Architecture of the Pip.Services toolkit

The Pip.Services toolkit is divided into a few dozen modules. A small part of these modules make up the core itself, while the rest are optional add ons. This approach simplifies adding new functionality and minimizes dependencies on 3rd party libraries.

The general structure of the Pip.Services toolkit is shown on the following diagram:

The foundation of the toolkit is shown in grey. It is made up of the stacks for the 6 supported programming languages: Java, Node.js, .NET Core, Python, Dart, and Golang.

The core of the toolkit is shown in green. It consists of two modules, both of which are required:

  • Commons - Basic primitives for symmetrical development on various programming languages, as well as patterns, used in the rest of the modules.
  • Components - Contains standard components, such as component logging, performance counters, synchronization, configuration, caching, and others. Specific implementations of these components are found in the extension modules.

The main (basic) modules are shown in blue. Although they are not required, they are used in most microservices:

  • Container - A basic container, which is used to compose microservices from loosely-coupled components (see [The Structure of a Microservice]).
  • Data - Basic components for storing data and implementing storage of data in memory and in the file system.
  • RPC - Basic components for synchronous communication and implementations using local calls and the HTTP/REST protocol.
  • Messaging - Basic components for asynchronous communication and implementing local queues.

Last but not least are the additional (optional) modules, shown in red. These modules are used to support specific technologies, such as:

  • Azure - components for working with the Azure cloud
  • AWS - components for working with the AWS cloud
  • MongoDB - components for storing data in MongoDB
  • GRPC - components for synchronous communication via GRPC
  • ActiveMQ - components for asynchronous communication via ActiveMQ
  • MQTT - components for asynchronous communication via the MQTT protocol
  • Memcached - components for caching and synchronizing with Memcached
  • Redis - components for caching and synchronizing with Redis
  • ElasticSearch - components for logging with ElasticSearch
  • Prometheus - components for using performance counters with Prometheus

The Pip.Services toolkit is an actively growing project. While the core has proven to be stable over the course of many years, additional modules are constantly being expanded and added. Be sure to regularly check our [news] to be informed of the latest updates and releases.