On Premise Deployment

The Nected On-Premise suite integrates frontend applications and backend services. The backend is a combination of core services supporting frontend applications and a dedicated service cluster for executing user-defined rules and workflows, triggered via APIs or cron schedules.

The Nected On-Premise suite integrates frontend applications and backend services. The backend is a combination of core services supporting frontend applications and a dedicated service cluster for executing user-defined rules and workflows, triggered via APIs or cron schedules.

By the end of this documentation, you will clearly understand the prerequisites, processes, and best practices for deploying Nected within your IT ecosystem. We aim to ensure that you can leverage the full potential of Nected's suite with confidence and efficiency, tailored to your organization's unique needs.

Core Architecture Overview

Nected's architecture is fundamentally designed to optimize task execution in a no-code/low-code environment. This section breaks down the key components of the platform, offering a clear view of how each contributes to overall performance and scalability.

The architecture of Nected is structured to efficiently manage and execute backend logic flows. It comprises several critical services, each playing a unique role in the system:

1. Overall Architecture:

• Fundamental Approach: Nected adopts a task-oriented approach where backend logic flows, created through the Nected console, are executed as a chain of tasks. These tasks, ranging from simple CRUD operations to complex user segmentations, can be executed independently by any worker within the system.

• Execution Engine: At the core of Nected is its execution engine, responsible for carrying out the backend logic flows at scale. This engine is pivotal in ensuring the platform's scalability and high-performance capabilities.

2. Core Components:

• Router Service:

  • Functionality: This lightweight GoLang service handles API / webhook triggers for backend logic flows. It is responsible for validating requests, applying throttling, and authenticating incoming requests. Upon validation, it triggers execution using temporal technology and awaits responses.

  • Accessibility: The Router Service is the entry point to the cluster, with all other services being internal. It is only service which is accessible through Load Balancer / API Gateway from the outside network.

• Task Manager:

  • Technology: We have used Temporal, an open-source durable execution framework, for managing tasks and task queues.

  • Role: The Task Manager interfaces with a Temporal cluster, which uses Cassandra as a persistent store, facilitating efficient task execution and management.

• Executor Service:

  • Functionality: Another lightweight GoLang service, the Executor Service is responsible for fetching and executing tasks. It independently scales to maintain high scalability and is tasked with executing functions such as fetchData, callAPI, and executeRuleCondition.

• Scalability: Configured to scale as required, it contributes to the overall flexibility and adaptability of the Nected platform.

3. Deployment and Fault Tolerance:

• Deployment on Kubernetes: All services within Nected are deployed on a Kubernetes cluster. This choice of infrastructure underlines the platform's emphasis on scalability and reliability.

• Fault Tolerance: Each service is designed to be fault-tolerant, ensuring the platform's resilience and uninterrupted operation.

4. Performance Benchmarking Setup:

• Objective: The aim was to benchmark a Kubernetes cluster capable of handling ~300rps throughput with specific Cassandra configurations.

• Configuration Details: The Router Service was configured with a minimum of 2 and a maximum of 8 pods, each equipped with 200m CPU and 512MB memory.

Detailed load testing and performance metrics can be found in our performance benchmarking blog.

In conclusion, the Nected platform’s architecture is a well-orchestrated system of services, each optimized for performance and scalability. This architecture not only enables efficient execution of backend logic flows but also ensures high availability and resilience, making Nected a reliable solution for various no-code/low-code backend applications.

Current Tech Stack Versions:

The following table details the specific versions of the technology stack we’re currently on. So these specific versions are required for the On-Premise deployment of Nected:

Category	Technology	Version
Platform Language & Compiler	React	~18.2
	NodeJS	Latest LTS
	Golang	~≥ 1.19
	Python	~≥ 3.11
Database and Storage	PostgreSQL	~≥ 9.6
	MongoDB	≥ 6
	Cassandra	≥ 4.1.3
	Elasticsearch	7 or 8
	Redis	Latest LTS
Infrastructure, Packaging, and Distribution	Docker	v25
	Kubernetes	≥ 1.24
	Helm	v3

These versions are critical to ensure compatibility and optimal performance of the Nected On-Premise deployment. It is recommended to adhere to these versions specifically, as they provide the necessary features and stability required for a successful installation.

Infrastructure Requirement:

Below are the minimum infrastructure requirements to support a load of 10 RPS on the Nected execution engine with a response time to 150-300 milliseconds.

Service	Components	Requirement	Size	Approx Monthly cost ($)
Frontend Apps	Console, Editor, Assets	single server deployment using nginx	One t3.small2 vCPU 2 GB	15
K8s Cluster	API Service - Main service pods	0.2 cpu 2 pods	One c6g.xlarge 4 vCPU 8 GB	100
	API Service - SQL Linter (optional)	0.5 cpu, 1 pod
	Router Service	0.2 cpu, 2 pod
	Executer Service - Main Service pods	0.2 cpu, 2 pod
	Executer Service - Executer-tp (optional)	0.7 cpu, 1 pod
	Temporal: History	1 cpu, 1 pod
	Temporal: Frontend	0.25 cpu, 2 pod
	Temporal: Matching	0.25 cpu, 2 pod
Redis			ElasticCache t3.small	35
Postgres			RDS t3.medium	40
MongoDB			MongoCloud Serverless	15

If you are facing any issue, please get in touch with our solution expert at [e-mail] to resolve your queries/issue. Further, if you have restriction around any of the above stack mentioned in pre-requisite, our solution expert can help you with the same to customize the installations wherever possible

Deployment:

Deploying Nected on-premise can be done either locally or on the cloud. Below are the steps for both deployment methods:

Local Deployment

1. Install Prerequisites:

   • Ensure your system meets the necessary requirements (CPU, memory, OS).

   • Install Docker and Kubernetes on your local machine.

2. Download and Configure Nected Charts:

   • Access the Nected Helm charts from charts.nected.io.

   • Customize your Helm values file to suit your local environment and security needs.

3. Deploy Nected Locally:

   • Use Helm to deploy Nected on your local Kubernetes cluster.

   • Monitor the deployment and verify all services are running correctly.

Cloud Deployment

1. Provision Cloud Resources:

   • Choose a cloud provider (e.g., AWS, GCP, Azure) and provision the necessary resources (compute, storage, networking).

2. Install Prerequisites:

   • Set up Docker and Kubernetes on your cloud instances.

   • Ensure your cloud infrastructure meets the required specifications.

3. Download and Configure Nected Charts:

   • Access the Nected Helm charts from charts.nected.io.

   • Adjust your Helm values file for cloud deployment, considering scalability and security.

4. Deploy Nected on the Cloud:

   • Use Helm to deploy Nected on your cloud-based Kubernetes cluster.

   • Continuously monitor the deployment and ensure all services are running efficiently.

For a detailed deployment guide, refer to the complete documentation.

Monitoring and Maintenance

Effective monitoring and maintenance are crucial for ensuring the ongoing security and performance of your Nected deployment. Follow these steps to maintain your system:

1. Regular Monitoring:

   • Use Kubernetes monitoring tools to track the health and performance of your deployment.

   • Set up alerts for any unusual activity or performance degradation.

2. Routine Maintenance:

   • Apply updates and patches promptly to keep your system secure.

   • Perform regular backups of your data and configurations.

   • Review and optimize resource allocation based on usage patterns.