Microservice Tech Stacks (introducing the FRN)

What are Microservices

Microservices – also known as the microservice architecture – is a software development paradigm, where an application is structured as a collection of services that are easier to maintain and test, loosely coupled and independently deployable. The microservice architecture enables a fast and reliable delivery of large and highly complex applications with frequent iterations, while also the evolution of a technology stack depending on the changing organisational needs and market requirements is enabled and facilitated.

Certain tech stacks are commonly bundled together and given distinct names because they work well in combination, either due to complementary technologies or through widespread adoption by developers. These named stacks are often used as standard solutions for building microservices or web applications. Below are some examples of well-known tech stacks that are often used together in microservices or modern development:

1. MEAN Stack (MongoDB, Express.js, Angular, Node.js)

• MongoDB: A NoSQL database used for data storage.
• Express.js: A minimalist web framework for Node.js used to build server-side logic.
• Angular: A front-end framework by Google used for building web-based user interfaces.
• Node.js: A JavaScript runtime that allows server-side development. Common Use: This stack is particularly popular for full-stack JavaScript applications, enabling developers to use the same language (JavaScript) for both the frontend and backend, simplifying development and scaling.

2. MERN Stack (MongoDB, Express.js, React, Node.js)

• MongoDB: NoSQL database for handling large-scale data storage.
• Express.js: Used for building RESTful APIs.
• React: A frontend library developed by Facebook for building user interfaces, especially single-page applications (SPA).
• Node.js: Backend runtime for executing JavaScript on the server side. Common Use: The MERN stack is widely used for building dynamic, full-stack web applications, particularly in scenarios where React’s component-based architecture excels at rendering dynamic data.

3. LAMP Stack (Linux, Apache, MySQL, PHP/Perl/Python)

• Linux: The operating system powering the infrastructure.
• Apache: The web server used to handle HTTP requests.
• MySQL: The relational database used for structured data.
• PHP/Perl/Python: Backend scripting languages to handle business logic. Common Use: The LAMP stack is one of the oldest and most stable stacks, commonly used for hosting traditional web applications and websites. It powers a large portion of legacy systems as well as new web applications.

4. LEMP Stack (Linux, Nginx, MySQL, PHP/Perl/Python)

• Linux: The OS platform.
• Nginx: A lightweight, fast web server that can also act as a reverse proxy or load balancer.
• MySQL: The relational database system.
• PHP/Perl/Python: Server-side scripting languages. Common Use: The LEMP stack is similar to LAMP but replaces Apache with Nginx, which is known for better performance under high traffic and resource efficiency.

5. ELK Stack (Elasticsearch, Logstash, Kibana)

• Elasticsearch: A search engine for indexing and searching large amounts of data.
• Logstash: A data processing pipeline that ingests data from various sources, transforms it, and sends it to Elasticsearch.
• Kibana: A visualization tool that allows you to explore and visualize data stored in Elasticsearch. Common Use: This stack is often used in microservices architecture for centralized logging, monitoring, and observability to track service health, performance, and troubleshooting.

6. JAM Stack (JavaScript, APIs, Markup)

• JavaScript: For dynamic front-end functionality.
• APIs: Backend services and business logic are accessed through RESTful APIs or GraphQL.
• Markup: Static HTML for rendering web content, often pre-built using static site generators like Jekyll or Hugo. Common Use: The JAM stack is popular for building static websites or applications where the front end is decoupled from the backend. It enhances performance by serving pre-rendered pages and using APIs for dynamic interactions.

7. SMACK Stack (Spark, Mesos, Akka, Cassandra, Kafka)

• Spark: A distributed processing engine for big data analytics.
• Mesos: A distributed systems kernel for managing resources.
• Akka: A toolkit for building concurrent, distributed applications.
• Cassandra: A distributed NoSQL database.
• Kafka: A distributed streaming platform used for real-time data processing. Common Use: The SMACK stack is geared towards real-time data processing and analytics, particularly in systems where scalability and high availability are critical.

8. TICK Stack (Telegraf, InfluxDB, Chronograf, Kapacitor)

• Telegraf: An agent that collects and reports metrics.
• InfluxDB: A time-series database optimized for fast, high-availability data storage.
• Chronograf: A data visualization tool for InfluxDB.
• Kapacitor: A real-time streaming data processing engine. Common Use: This stack is widely used in IoT and monitoring solutions where time-series data needs to be collected, stored, and analyzed in real-time.

9. FaaS (Functions as a Service) Stack

• AWS Lambda (or equivalent on other platforms like Google Cloud Functions or Azure Functions): A cloud-based, serverless compute service where code is executed in response to events.
• API Gateway: Used to trigger the Lambda functions via HTTP requests.
• DynamoDB: A NoSQL database often used in FaaS architectures for event-driven data processing. Common Use: FaaS stacks are ideal for serverless microservices, where the infrastructure is abstracted away, and the developer focuses solely on writing the code. This stack is great for event-driven architectures and systems that experience unpredictable loads.

10. Kubernetes Stack

• Kubernetes: For container orchestration.
• Helm: A package manager for Kubernetes that simplifies the deployment of applications.
• Prometheus: For monitoring metrics and alerting.
• Istio: A service mesh for managing and securing service-to-service communication. Common Use: The Kubernetes stack is the de-facto standard for deploying, managing, and scaling microservices in production environments. The combination of Kubernetes and complementary tools (like Helm and Prometheus) simplifies infrastructure management and observability.

In brief

• MEAN/MERN for full-stack JavaScript development.
• LAMP/LEMP for traditional web applications with PHP.
• ELK for logging and monitoring in distributed systems.
• SMACK and TICK for big data and real-time processing.
• Kubernetes Stack for containerized, orchestrated microservices.

Introducing the FRN – A powerful stack for Generative and Analytical Applications

In the FRN Stack—combining React, FastAPI, and .NET—we harness the unique strengths of each technology to power generative and analytical applications

React: JavaScript front-end library for building user interfaces, particularly single-page applications (SPAs). Ensures a dynamic and responsive user interface, ideal for visualizing large data sets or interacting with real-time generative models.

• FastAPI: Python-based web framework known for its speed and asynchronous capabilities, typically handling RESTful APIs or services requiring quick development and high performance. Known for its speed and high performance, it’s perfect for building APIs that serve machine learning models, handle real-time data processing, or support AI-driven applications

• .NET (ASP.NET Core): A powerful framework, primarily in C#, used to build robust, enterprise-grade backend services or APIs. Provides robust backend infrastructure, enabling complex data processing, enterprise-level analytics, and deep integration with legacy systems or high-performance computational tasks.

• Backend (FastAPI + .NET): FastAPI could be used for specific microservices requiring high-speed, lightweight, asynchronous handling (like APIs that need to handle high-throughput), while .NET could be used for more heavy-duty backend logic, complex business rules, or legacy services.

References

[1]  “What are microservices?” https://microservices.io, accessed: 2022-08- 5.

[2] H. Vural, M. Koyuncu, and S. Guney, “A systematic literature review on microservices,” in Computational Science and Its Applications–ICCSA 2017: 17th International Conference, Trieste, Italy, July 3-6, 2017, Proceedings, Part VI 17. Springer, 2017, pp. 203–217.