Tutorials

Introduction

Pip.Services is a multi-language, cross-platform toolkit that makes it easy for developers to create long-living microservice systems. From its beginnings, the toolkit was designed to be expandable and portable across programming languages and, at the same time, support microservice deployment on existing and future platforms.

Multi-language, cross-platform

The current technical environment is characterized by a variety of programming languages and deployment platforms. Pip.Services embraces this diversity through symmetric language implementation and containerization.

Symmetric implementation means that for every programming language it is implemented in, there is a common set of classes, methods, and method signatures that applies to all implemented languages. This carefully designed architecture allows the toolkit to support a variety of programming languages that can be compiled or interpreted, statically- or dynamically-typed, object-oriented or not. Currently, the toolkit is available in six different languages namely, Go, Node.js, .NET, Python, Dart, and Java.

Moreover, to support the big number of existing deployment platforms, Pip.Services uses the concept of containerization. This allows for the packaging of microservice components into different types of containers that support the most common existing platforms - such as Processes, Docker, AWS Lambda, Azure Functions, and Google Cloud Functions, and the reuse of over 90% of the implemented and tested code in the process.

Organized in a modular fashion

The toolkit is designed in a modular fashion, where there are a few core modules that provide common abstractions and patterns, and a growing number of additional modules that offer reusable components and patterns built on top of popular technologies. This approach facilitates the optimization of microservice dependencies and the rapid expansion of the toolkit’s functionalities.

At present, the toolkit contains the following modules:

Reusable building blocks

The Pip.Services toolkit consists of a set of nine building blocks that can be implemented in any of the supported programming languages. With a focus on rapid architecting and development, these nine building blocks offer the reusable components and patterns that developers need to create feature-rich, production-grade microservices in a short time.

Components	Pip.Services toolkit is built around components, which can be created from scratch, obtained from existing code via simple augmentation, or selected from a large collection of prebuilt modules. These components are assembled into fully-functional microservices using a number of inversion-of-control containers.
Data handling	Pipelines receive data in many different and sometimes incompatible formats. To help facilitate this diversity of data, PIP.Services offers tools for the conversion to common formats, methods for the construction of complex validation rules, and components for filtering, sorting and paging data sets.
Configurations	PIP.Services offers the flexibility to configure components at runtime and deployment time.
Connectivity	Applications need to work with other apps. For this, PIP.Services offers discovery components and credential stores.
Observability	Applications require an understanding of how the system is behaving through continuous monitoring of their behavior. PIP.Services contains several components that allow for the implementation of logging, tracing and metrics with a few lines of code.
Persistence	Data needs to be persisted in different storages, such as memory, and relational and NoSQL databases. For this, Pip.Services offers a broad collection of persistent components that support a variety of the most popular databases.
Synchronous calls	Microservices need to communicate with each other. The simplest and most widely used method of communication is via synchronous remote procedure calls. For this, Pip.Services offers components for in-process and inter-process communication via a number of technologies like HTTP/REST or GRPC. The implemented Commandable pattern helps to build a reliable fully-featured communication between microservices in minutes.
Asynchronous messaging	Messaging provides another way to communicate between microservices. Pip.Services offers components that abstract various message brokers like MQTT, Kafka, RabbitMQ and NATS, and provide a portable communication layer to enable event-driven microservices.
Concurrency	To achieve a high scale and reliability, microservices need to support horizontal scaling where multiple copies of the same microservice work concurrently. To prevent conflicts and enable complex collaboration scenarios, Pip.Services offers components like distributed caches and locks.

Fast learning, fast development

One of the most pressing aspects that developers face is keeping up with the pace of knowledge and technology changes.

Pip.Services' inner design based on building blocks and reusable components that embrace current best practices and patterns reduces the amount of time necessary to achieve programming productivity. Developers can concentrate on specific technologies, use the language of their preference and obtain new skills based on what they already know, without the need to master the entire development tool.

In addition, its symmetric implementation provides a common ground that speeds up communication and knowledge transfer between developers and teams.

The result is that, as experience demonstrates, an average developer with proper training can become productive in two to three weeks; and, once the toolkit has been adopted, total development efficiency can double or even triple.

Designed for long-living systems

Present-day technologies and business requirements change fast. Pip.Services was designed with these challenges in mind and with the idea of creating adaptable systems that stand the test of time and are functional and performant.

Its architecture based on a modular approach and reusable components makes this toolkit easily adaptable to business and technical innovations. Its fast learning and development style helps developers to implement those updates swiftly and accurately. And, its symmetric language implementation means that adding a new language is simply a matter of building on what already exists.