Node Congress

Node Congress 2024

Today's Talk discusses microservices optimization strategies for distributed systems, specifically focusing on implementing casual consistency to ensure data synchronization. Vector clocks are commonly used to track the casual relationship between write events in distributed systems. Casual consistency allows for concurrent and independent operations without synchronization, maximizing parallelism and system resource utilization. It enables effective scalability, better latency, and fault tolerance in distributed systems through coordination, resilience, reconfiguration, recovery, and data replication.

- Delve into the intricacies of optimizing microservice architecture for achieving high performance and resilience.- Explore the challenges related to performance bottlenecks and resilience in microservices-based systems.- Deep dive into the strategies for enhancing performance, such as efficient communication protocols, asynchronous messaging, and load balancing, while also discussing techniques for building resilience, including circuit breakers, fault tolerance, and chaos engineering.- Explore relevant tooling and technologies, such as service mesh and container orchestration, and offer insightful case studies and lessons learned from real-world implementations.- Emphasize the importance of continuous improvement and adaptation in microservices environments, alongside reflections on the future trajectory of microservices architecture.

Optimizing Microservice Architecture for High Performance and Resilience

Santosh Nikhil Kumar

DevOps.js

DevOps.js Conf 2024

In this talk, Luca introduces the concept of the modern composable monolith and discusses the challenges of microservices. He emphasizes the importance of developing modular monoliths and introduces Fastify and the Platformatic Runtime as tools for this approach. The Platformatic Runtime simplifies running modular, monolithic applications, and standardizing interfaces and communication is crucial in this context. Lastly, Luca introduces Meraki as a UI-driven tool for building composable monoliths and invites developers to join their marketplace for revolutionizing the operational experience of microservices.

It all started with the monolith’s fission into microservices. This set logical and physical boundaries, fusing the infrastructure and software dimensions. While microservices simplified how teams develop independently, it added extra complexities around performance, correctness, general management, and ultimately a slower development cycle. In this talk, we will dive deep into how to architect and implement a Fastify-based composable monolith, cross-service network-less communication, and how to handle efficient development across teams while deploying a single artifact in Kubernetes. Does it sound like magic?Let's discover the trick together!

Building and Operating a Modern Composable Monolith

Luca Maraschi

JS Nation

JSNation 2023

This workshop explores JRPC and how to build JRPC microservices to convert cryptocurrencies in Node.js. It covers the low-level aspects of gRPC and its integration with Node.js, emphasizing its performance benefits over traditional REST APIs. The workshop includes demonstrations of generating protocol buffer types, protocol buffer transformation and serialization, creating server and client with gRPC, and building a cryptocurrency converter using multiple providers. It also discusses the comparison between REST, GraphQL, and gRPC in terms of coupling, verbosity, and discoverability.

The workshop overviews key architecture principles, design patterns, and technologies used to build microservices in the Node.js stack. It covers the theory of the GRPC framework and protocol buffers mechanism, as well as techniques and specifics of building isolated services using the monorepo approach with lerna and yarn workspaces, TypeScript. The workshop includes a live practical assignment to create a currency converter application that follows microservices paradigms. It fits the best developers who want to learn and practice GRPC microservices pattern with the Node.js platform. Prerequistes:- Good understanding of JavaScript or TypeScript- Experience with Node.js and writing Backend applications- <a href="https://nodejs.org/en/download/" target="_blank">Preinstall Node.js, npm</a>- <a href="https://grpc.io/docs/protoc-installation/" target="_blank">Preinstall Protocol Buffer Compiler</a>- We prefer to use VSCode for a better experience with JavaScript and TypeScript (other IDEs are also ok)

How to Convert Crypto Currencies With GRPC Microservices in Node.js

Alex Korzhikov

Andrew Reddikh

Node Congress 2023

The workshop focused on decomposing a monolithic API into microservices using NestJS and gRPC. The speaker discussed the benefits and drawbacks of monoliths and microservices, as well as principles and architecture patterns for microservices. The process of decomposing the monolith involved refactoring the code, introducing gRPC for communication, and gradually moving parts of the monolith to separate services. The workshop also highlighted the importance of testing, CI/CD pipelines, and database decomposition. Overall, the workshop emphasized the need for careful planning and testing when decomposing a monolith into microservices.

The workshop focuses on concepts, algorithms, and practices to decompose a monolithic application into GRPC microservices. It overviews architecture principles, design patterns, and technologies used to build microservices. It covers the theory of the GRPC framework and protocol buffers mechanism, as well as techniques and specifics of building isolated TypeScript services in the Node.js stack. The workshop includes a live use case demo of decomposing an API application into a set of microservices. It fits the best architects, tech leads, and developers who want to learn microservices patterns. Level: AdvancedPatterns: DDD, MicroservicesTechnologies: GRPC, Protocol Buffers, Node.js, TypeScript, NestJS, Express.js, PostgreSQL, TurborepoExample structure: monorepo configuration, packages configuration, common utilities, demo servicePractical exercise: refactor monolith app

Decomposing Monolith NestJS API into GRPC Microservices

Platform.SH is a platform as a service provider that supports various frameworks and runtimes. In this workshop, a two application project called food adviser is deployed using Next.js as the front end and Strapi as the back end. The process involves creating a Strapi application, managing content collections, building the Strapi API, setting up the database and admin panel, deploying the project to Platform.SH, integrating with GitHub, configuring routes, and deploying the backend. The workshop also covers deploying the frontend, configuring the frontend and backend, and additional topics such as email settings in Strapi.

Deploying decoupled and microservice applications isn't just a problem to be solved on migration day. Moving forward with these architectures depends completely on what your team's workflow experience will look like day-to-day post-migration. The hardest part of this can often be the number of vendors involved. Some targets are best suited for specific frontend frameworks, while others are more so for CMSs and custom APIs. Unfortunately their assumptions, workflows, APIs, and notions of security can be quite different. While there are certain advantages to relying on a strict contract between apps – where backend and frontend teams work is limited to a single vendor – this isn't always realistic. This could be because you're still experimenting, or simply the size of your organization doesn't allow for this kind of specialization just yet. In this workshop, you'll have a chance to explore a different, single vendor approach to microservices using Strapi and Next.js as an example. You'll deploy each app individually, establishing a workflow from the start that simplifies customization, introducing new features, investigating performance issues, and even framework interchangeability from the start. Structure:- Getting started- Overview of Strapi- Overview of Platform.sh workflow- Deploying the project- Switching services- Adding the frontend Prerequisites:- <a href="https://auth.api.platform.sh/register?trial_type=general&amp;_utm_medium=node-congress&amp;_utm_campaign=2023-Node-Congress&amp;_utm_source=node-congress" target="_blank">A Platform.sh trial account created</a>- <a href="https://docs.platform.sh/administration/cli.html" target="_blank">The Platform.sh CLI installed</a>

Decoupling in Practice

Chad Carlson

DevOps.js Conf 2022

The Workshop is about deploying Node.js microservices with Pulumi and Azure. It covers Docker, Kubernetes, Azure, and Pulumi concepts. The project uses a Monorepo approach and relies on gRPC and protocol buffers for communication between microservices. Pulumi is a flexible tool for creating infrastructure as code and supports multiple languages. The workshop also explores deploying applications with Helm in Kubernetes and discusses future plans for exploring microservices and database separation.

The workshop gives a practical perspective of key principles needed to develop, build, and maintain a set of microservices in the Node.js stack. It covers specifics of creating isolated TypeScript services using the monorepo approach with lerna and yarn workspaces. The workshop includes an overview and a live exercise to create cloud environment with Pulumi framework and Azure services. The sessions fits the best developers who want to learn and practice build and deploy techniques using Azure stack and Pulumi for Node.js. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

How to develop, build, and deploy Node.js microservices with Pulumi and Azure DevOps

Node Congress 2022

Today's workshop is divided into three parts: an introduction to gRPC and Node.js, practical examples of implementing a currency converter, and a hands-on practice session. The workshop covers the history and key features of gRPC, the concept of Remote Procedure Calls (RPC), gRPC communication and service definitions, gRPC extension points and protocol buffers, and the use of protocol buffers in TypeScript. It also includes demos on protocol buffer transformation, using gRPC.js and Proto Loader, starting the gRPC server, implementing the server and client, and using gRPC in JavaScript. The workshop concludes with discussions on using TypeScript and the protocol.gmtc file, preparing the environment and monorepo structure, creating a currency converter with providers, and the benefits of gRPC compared to REST, RPC, and GraphQL.

The workshop overviews key architecture principles, design patterns, and technologies used to build microservices in the Node.js stack. It covers the theory of the GRPC framework and protocol buffers mechanism, as well as techniques and specifics of building isolated services using the monorepo approach with lerna and yarn workspaces, TypeScript. The workshop includes a live practical assignment to create a currency converter application that follows microservices paradigms. The "Microservices in Node.js with GRPC" workshop fits the best developers who want to learn and practice GRPC microservices pattern with the Node.js platform. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

How to Convert Crypto Currencies with Microservices in Node.js and GRPC

DevOps.js Conf 2021

This Talk discusses the benefits of microservices and containers for building CI-CD pipelines. It explains how container technology enables portability and scalability. The challenges of microservices include network communication and testing in isolation. The Talk introduces Tacton, a cloud-native CICD pipeline for Kubernetes, and highlights the use of GitOps and Argo CD. It also discusses the importance of maintaining referential integrity between microservices and the evolving role of operators in the DevOps world.

Microservices present many advantages for running modern software, but they also bring new challenges for both Deployment and Operational tasks. This session will discuss advantages and challenges of microservices and review the best practices of developing a microservice-based architecture.We will discuss how container orchestration using Kubernetes or Red Hat OpenShift can help us and bring it all together with an example of Continuous Integration and Continuous Delivery (CI/CD) pipelines on top of OpenShift.

How to Build CI/CD Pipelines for a Microservices Application

Sasha Rosenbaum

JSNation Live

JSNation Live 2021

This Talk discusses the importance of bundling code in the modern JavaScript world and introduces Webpack as the de facto standard for bundling modules. It explores techniques such as code splitting, multiple entry points, and controlling the build process to optimize code organization and improve performance. The Talk also delves into concepts like Universal Model Definition (UMD) and using externals in Webpack to avoid code duplication. It highlights the benefits of separating and maintaining code in an application, as well as the use of micro-frontends and monorepos for scalability and collaboration. Overall, the Talk emphasizes the significance of code separation, dependency management, and efficient bundling strategies for developing robust and modular applications.

In this talk we will explore the great benefits of breaking a big modern app to meaningful, independent pieces – each can be built, deployed and loaded separately. We will discuss best practices and gotchas when trying to apply this microservice-like pattern to the chaotic world of the browser, and we'll see how building the right pieces guarantees a brighter future for your apps. Let's dive into Neverendering story of modern front-end architecture. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

#microservices