github.com/Erudika/para @1.54.7

A scalable, multitenant backend for the cloud.

Para is a scalable, multitenant backend server/framework for object persistence and retrieval. It helps you build and prototype applications faster by taking care of backend operations. It can be a part of your JVM-based application or it can be deployed as standalone, multitenant API server with multiple applications and clients connecting to it.

The name "pára" means "steam" in Bulgarian. And just like steam is used to power stuff, you can use Para to power your mobile or web application backend.

See how Para compares to other open source backend frameworks.

This project is fully funded and supported by Erudika - an independent, bootstrapped company.

Features

• RESTful JSON API secured with Amazon's Signature V4 algorithm
• Database-agnostic, designed for scalable data stores (DynamoDB, Cassandra, MongoDB, etc.)
• Full-text search (Lucene, Elasticsearch)
• Distributed and local object cache (Hazelcast, Caffeine)
• Multitenancy - each app has its own table, index and cache
• Webhooks with signed payloads
• Flexible security based on Spring Security (LDAP, SAML, social login, CSRF protection, etc.)
• Stateless client authentication with JSON Web Tokens (JWT)
• Simple but effective resource permissions for client access control
• Robust constraint validation mechanism based on JSR-303 and Hibernate Validator
• Per-object control of persistence, index and cache operations
• Support for optimistic locking and transactions (implemented by each DAO natively)
• Advanced serialization and deserialization capabilities (Jackson)
• Full metrics for monitoring and diagnostics (Dropwizard)
• Modular design powered by Google Guice and support for plugins
• I18n utilities for translating language packs and working with currencies
• Standalone executable JAR with embedded Jetty
• HTML form handling with public endpoint accepting multipart/form-data requests
• MCP server - allows AI agents to interact with your backend
• Para Web Console - admin user interface

Architecture

+----------------------------------------------------------+
|                  ____  ___ _ ____ ___ _                  |
|                 / __ \/ __` / ___/ __` /                 |
|                / /_/ / /_/ / /  / /_/ /                  |
|               / .___/\__,_/_/   \__,_/     +-------------+
|              /_/                           | Persistence |
+-------------------+  +-----------------+   +-------------+
|      REST API     |  |     Search      |---|    Cache    |
+---------+---------+--+--------+--------+---+------+------+
          |                     |                   |
+---------+---------+  +--------+--------+   +------+------+
|  Signed Requests  |  |  Search Index   |   |  Data Store |
|  and JWT Tokens   |  |      (Any)      |   |    (Any)    |
+----+---------^----+  +-----------------+   +-------------+
     |         |
+----v---------+-------------------------------------------+
| Clients: JavaScript, PHP, Java, C#, Android, iOS, et al. |
+----------------------------------------------------------+

Documentation

Read the Docs

Blog

Read more about Para on our blog

Hosting

We offer hosting and premium support at paraio.com where you can try Para online with a free developer account. Browse and manage your users and objects, do backups and edit permissions with a few clicks in the web console. By upgrading to a premium account you will be able to scale you projects up and down in seconds and manage multiple apps.

Quick Start

1. Download the latest executable JAR
2. Create a configuration file application.conf file in the same directory as the JAR package.
3. Start Para with java -jar -Dconfig.file=./application.conf para-*.jar
4. Install Para CLI with npm install -g para-cli
5. Create a new dedicated app for your project and save the access keys:

# run setup and set endpoint to either 'http://localhost:8080' or 'https://paraio.com'
# the keys for the root app are inside application.conf
$ para-cli setup
$ para-cli new-app "myapp" --name "My App"

Alternatively, you can use the Para Web Console to manage data, or integrate Para directly into your project with one of the API clients below.

Docker

Tagged Docker images for Para are located at erudikaltd/para on Docker Hub. It's highly recommended that you pull only release images like :1.51.0 or :latest_stable because the :latest tag can be broken or unstable. First, create an application.conf file and a data folder and start the Para container:

$ touch application.conf && mkdir data
$ docker run -ti -p 8080:8080 --rm -v $(pwd)/data:/para/data \
  -v $(pwd)/application.conf:/para/application.conf \
  -e JAVA_OPTS="-Dconfig.file=/para/application.conf" erudikaltd/para:latest_stable

Environment variables

JAVA_OPTS - Java system properties, defaults to -Dloader.path=lib

Plugins

You can create a custom Para container with all plugins and JDBC drivers you need by using docker compose. Below is an example build of Para, using para-dao-sql, para-search-lucene and PosgreSQL as a database.

1. First, create a new Dockerfile-plugins which does a multi-stage build like so:

• View contents of Dockerfile-plugins

  ARG PARA_VERSION="0.0.0"
  ARG SQL_DAO_VERSION="0.0.0"
  FROM erudikaltd/para:v${PARA_VERSION} AS base
  FROM erudikaltd/para-dao-sql:${SQL_DAO_VERSION} AS dao
  FROM erudikaltd/para-search-lucene:${SEARCH_VERSION} AS search
  FROM base AS final
  COPY --from=dao /para/lib/*.jar /para/lib
  COPY --from=search /para/lib/*.jar /para/lib
  
  # EXAMPLE: Add a PostgreSQL JDBC Driver
  ARG PG_JDBC_VERSION="0.0.0"
  ADD https://jdbc.postgresql.org/download/postgresql-${PG_JDBC_VERSION}.jar /para/lib/
  

1. Then, create a docker-compose.yml file:

• View contents of docker-compose.yml

  services:
     para:
       depends_on:
         - db
       build:
         context: .
         dockerfile: Dockerfile
         args:
           PARA_VERSION: "1.51.0"
           SQL_DAO_VERSION: "1.49.1"
           PG_JDBC_VERSION: "42.7.7"
       image: para-with-plugins
       pull_policy: never
       ports:
         - "8080:8080"
       volumes:
         - type: volume
           source: paraData
           target: /para/data
         - type: volume
           source: paraLib
           target: /para/lib
         - type: bind
           source: ./para-application.conf
           target: /para/application.conf
       restart: always
       environment:
         - JAVA_OPTS=-Dconfig.file=/para/application.conf -Dloader.path=/para/lib
  
     db:
       image: postgres:latest
       ports:
         - "5432:5432"
       volumes:
         - type: volume
           source: postgresData
           target: /var/lib/postgresql/data
       restart: always
       environment:
         - POSTGRES_PASSWORD=mysecretpassword
         - PGDATA=/var/lib/postgresql/data
  volumes:
    paraData:
    paraLib:
    postgresData:
  

1. Also reate the Para configuration file para-application.conf:

• View contents of para-application.conf

  para.env = "production"
  para.dao = "SqlDAO"
  para.sql.driver = "org.postgresql.Driver"
  para.sql.url = "postgresql://db:5432/para"
  para.sql.user = "postgres"
  para.sql.password = "mysecretpassword"
  

1. Finally, run docker compose build para && docker compose up

Kubernetes

There's a Helm chart inside the helm/ folder. First edit helm/para/values.yaml and then you can deploy Para to Kubernetes with a single command:

cd helm; helm install para ./para

For more info, check the quick start guide at helm/README.md.

Building Para

Para can be compiled with JDK 8+:

To compile it you'll need Maven. Once you have it, just clone and build:

$ git clone https://github.com/erudika/para.git && cd para
$ mvn install -DskipTests=true

To generate the executable "fat-jar" run $ mvn package and it will be in ./para-server/target/para-x.y.z-SNAPSHOT.jar. Two JAR files will be generated in total - the fat one is a bit bigger in size.

To build the native image of Para, run:

$ cd para-server && mvn -Pnative package

Note, that native images are platform-dependent, so an image built on x86-64 will not run on aarch64, for example.

To run a local instance of Para for development, use:

$ mvn -Dconfig.file=./application.conf spring-boot:run

Standalone server

Either download the executable JAR file and run it, or build it from scratch after cloning the Para repository. To build the "uber JAR" (fat JAR) file you need to enable it with the following Maven profiles:

mvn -Pfatjar,sql,lucene -DskipTests=true package

Finally, run Para server:

java -jar para-X.Y.Z.jar

The you can browse your objects through the Para Web Console console.paraio.org. Simply change the API endpoint to be your local server and connect your access keys. The admin interface is client-side only and your secret key is never sent over the the network. Instead, a JWT access token is generated locally and sent to the server on each request.

Download JAR

Maven dependency

You can also integrate Para with your project by adding it as a dependency. Para is hosted on Maven Central. Here's the Maven snippet to include in your pom.xml:

<dependency>
  <groupId>com.erudika</groupId>
  <artifactId>para-server</artifactId>
  <version>{see_green_version_badge_above}</version>
</dependency>

For building lightweight client-only applications connecting to Para, include only the client module:

<dependency>
  <groupId>com.erudika</groupId>
  <artifactId>para-client</artifactId>
  <version>{see_green_version_badge_above}</version>
</dependency>

Command-line tool

• Para CLI: para-cli

$ npm install -g para-cli

API clients

Use these client libraries to quickly integrate Para into your project:

• Java: para-client
• JavaScript / Node.js: para-client-js
• PHP: para-client-php
• Python: para-client-python
• C# / .NET: para-client-csharp
• Android: para-client-android
• Swift / iOS: para-client-ios

Database integrations

Use these DAO implementations to connect to different databases:

• DynamoDB: para-dao-dynamodb
• MongoDB: para-dao-mongodb
• Cassandra: para-dao-cassandra
• SQL (H2/MySQL/SQL Server/PostgreSQL, etc.): para-dao-sql H2DAO is the default DAO and it's part of the SQL plugin (packaged with the JAR file)

Search engine integrations

The Search interface is implemented by:

• Lucene: para-search-lucene
• Elasticsearch / OpenSearch: para-search-elasticsearch
• ~Elasticsearch v5.x~: para-search-elasticsearch-v5 [DEPRECATED] Compatible with ES 5.x only and missing some of the latest features like AWS Elasticsearch support.

Cache integrations

The Cache interface is implemented by:

• Caffeine: objects are cached locally (included in para-server)
• Hazelcast: para-cache-hazelcast (distributed)

Queue implementations

The Queue interface is implemented by:

• Amazon SQS: para-queue-sqs plugin for Amazon SQS
• LocalQueue for single-host deployments and local development

File storage implementations

The FileStore interface is implemented by:

• Amazon S3: para-storage-s3 plugin for Amazon S3
• LocalFileStore: for storing files to the local file system.

Emailer implementations

The Emailer interface is implemented by:

• AWSEmailer: para-email-ses plugin for Amazon SES
• JavaMailEmailer - the default JavaMail implementation for handling transaction emails

Projects using Para

• Scoold - an open source Stack Overflow clone
• ParaIO.com - managed Para hosting
• Erudika.com - the search bar and contact form on our website use Para
• Angular demo app - a sample Angu