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.

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 platform's key components, 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 a temporal framework and response.

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

• Task Manager:

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

  • Role: The Task Manager interfaces with a Temporal cluster, which uses Postgres[ Cassandra for high scaling] 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 the backend logic for both rules and workflows.

  • 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 provisioned 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
	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(Rule execution per second) on the Nected execution engine with a response time of ~100 milliseconds.

Service	Components	Requirement	Size	Approx Monthly cost ($)
K8s Cluster	UI Service	0.15 cpu 1 pods	One c6g.xlarge 4 vCPU 8 GB	100
	Editor(UI) Service	0.15 cpu 1 pods
	Backend service pods	0.15 cpu 2 pods
	Sql-Linter Service (optional)	0.6 cpu, 1 pod
	Router Service	0.15 cpu, 2 pod
	Executer Service	0.25 cpu, 4 pod
	Temporal: History Service	1 cpu, 1 pod
	Temporal: Frontend Service	0.25 cpu, 1 pod
	Temporal: Matching Service	0.25 cpu, 1 pod
	Temporal: Worker Service	0.15 cpu, 1 pod
Redis			ElasticCache t3.small	35
Postgres			RDS t3.medium	40
ElasticSearch (Optional)			t3.medium	40

If you are facing any issues, please contact our solution expert at [e-mail] to resolve your queries/issue. Further, if you have restriction around any of the above stack mentioned in the 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

To deploy Nected locally follow the below guide:

Prerequisites

Before you begin, ensure that the following software is installed on your local machine:

• Docker

• docker-compose

Deploy in Local

The following steps will run a local instance of the Nected Platform using the default configuration file (docker-compose.yml):

1. Open your terminal (on Linux/Mac) or Command Prompt/PowerShell (on Windows).

2. Clone the Nected repository using Git:

   git clone https://github.com/nected/docker-compose.git

3. Change the directory into the root of the project:

   cd  docker-compose

4. Start the Docker containers using Docker Compose:

   docker-compose up

For Apple M4 users, please do update following keys in .env:

ES_JAVA_OPTS="-Xms512m -Xmx512m -XX:UseSVE=0"
ES_CLI_JAVA_OPTS="-XX:UseSVE=0"

To update this, follow these steps:

1. Go to the .env file located in the docker-compose folder.

2. Uncomment line no. 10 and 11:

# ES_JAVA_OPTS="-Xms512m -Xmx512m -XX:UseSVE=0"
# ES_CLI_JAVA_OPTS="-XX:UseSVE=0"

Once these changes are made, try docker-compose up again.

Access the local dashboard:

1. Open the browser and access http://localhost:3000

2. Use credential [e-mail] / devPass123 to sign in to the local dashboard.

IMPORTANT: While accessing rule and workflow API from other services, replace http://10.10.0.1:8002/ with http://localhost:8002/

Cloud Deployment

1. Provision Cloud Resources:

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

2. Install Kubernetes Cluster:

   • Set up Kubernetes on your cloud account.

   • Ensure your cloud infrastructure meets the required specifications.

3. Access the Nected Helm charts from charts.nected.io. and adjust your Helm values file for cloud deployment, considering scalability and security as shown in the guide below:

Nected OnPremisehelm-charts

To host your cloud instance in a region of your choice, please contact [e-mail]. Nected now offers cloud hosting in the following locations:

• US - Virginia

• Europe - Netherlands

• India - Mumbai

• Asia - Singapore

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 database(Postgres) and configurations.

   • Review and optimize resource allocation based on usage patterns.