[opensourcedex]

cenit is a free, open source automation project written in Ruby and released under MIT. It has 503 GitHub stars, 133 forks and 24 open issues, and was last pushed 2 months ago. On this registry it ranks #51 of 54 tracked projects in Automation, with 5 head-to-head comparisons available. It gained 1 stars over the last 3 tracked days.

What is cenit?

Cenit is a 100% open-source integration-platform-as-a-service (iPaaS) written in Ruby, built for teams that design integrations, orchestrate data flows, expose APIs, and manage data pipelines across external systems without adopting a closed hosted vendor.

What it is

Cenit is an open-source iPaaS that runs on Ruby (Rails with Unicorn) and depends on MongoDB, Redis, and RabbitMQ as its core runtime. It provides two surfaces: a backend API on http://localhost:3000 and a UI on http://localhost:3002, with the UI maintained in a separate repository at cenit-io/ui. The project's topics cover automation, data-flow, EDI, integration-platform, iPaaS, multitenant, and on-premises deployment, which describes its intended shape well: a self-hostable integration runtime rather than a library or a single-purpose tool.

The concrete problem it solves is the integration and data-API work that teams would otherwise assemble by hand. Cenit generates backendless data APIs from JSON Schema-based Data Types, so a team defines a data type and gets an API rather than writing a service layer for it. It runs integration flows for routing, orchestration, and automation, and it performs data transformation pipelines across JSON, XML, ASN, EDIFACT, X12, UBL, and other formats, which removes the need for per-format conversion code in EDI and structured-data work. It lives in the Ruby and Rails ecosystem and works with MongoDB, Redis, and RabbitMQ rather than replacing them.

Key capabilities

  • Backendless data APIs generated from JSON Schema-based Data Types.
  • Integration flows for routing, orchestration, and automation across external systems.
  • Data transformation pipelines across JSON, XML, ASN, EDIFACT, X12, and UBL.
  • API and integration connectors for third-party services.
  • Event- and schedule-driven integration workloads.
  • Multitenant operation, as listed in the project topics.
  • On-premises deployment through Docker Compose, with a RabbitMQ management interface on http://localhost:15672.

Who uses it and how

  • Teams evaluating the platform run the default Docker Compose stack, which starts the five published services and exposes UI, backend, and RabbitMQ management ports.
  • Contributors develop against the UI as a sibling repository, using scripts/compose-dev.sh to build both images from local source, with CENIT_UI_CONTEXT set when the UI checkout is not at ../ui.
  • UI developers iterate with the dev profile, which serves Vite on http://localhost:3002 with source mounted and live reload, while the nginx ui service is kept for production-like checks and CI parity.
  • Operations teams run image-only production-like deployments with scripts/compose-prod.sh and docker-compose.yml plus docker-compose.prod.yml, pulling published images from GHCR.
  • Organizations needing EDI, data-flow, and multitenant integration on their own infrastructure use the on-premises deployment path instead of the hosted service.

Getting started

Local evaluation is a Docker Compose start: docker compose up -d --wait --wait-timeout 300 scripts/smoke/compose_stack.sh. On a fresh database the default admin credentials are [email protected] with password password, and a hosted option is available at web.cenit.io.

How it compares

This registry lists no paid products that Cenit replaces and names no comparable integration platforms, so on the facts available it stands alone here. The distinguishing facts that are documented are its MIT licence, its self-hosted Docker Compose path, and its hosted alternative at web.cenit.io; no licence, cost, or data-ownership comparison against other products can be made from the supplied facts.

When to use it — and when not to

A self-hoster must operate the full runtime: MongoDB, Redis, RabbitMQ, and the Ruby-on-Rails backend, which is a real operational load and not a single-container install. Teams that do not want to run or upgrade that stack should not pick the on-premises path, and the documented default admin credentials must be changed before any exposure. The repository's upgrade context lives in upgrading_notes.md against a baseline of Ruby 3.2.2 and MongoDB 7.0, so anyone tracking the project should expect migration work between versions.

project readme (upstream, from github) — read inline

Cenit

Cenit banner

Smoke: Docker Compose + UI Login codebeat License

Cenit is an open-source integration-platform-as-a-service (iPaaS). It helps teams design integrations, orchestrate data flows, expose APIs, and manage data pipelines across external systems.

Table of contents

What you can build

  • Backendless data APIs from JSON Schema-based Data Types.
  • Integration flows for routing, orchestration, and automation.
  • Data transformation pipelines across JSON, XML, ASN, EDIFACT, X12, UBL, and more.
  • API and integration connectors for third-party services.
  • Event- and schedule-driven integration workloads.

Architecture and stack

Core runtime:

  • Ruby (Rails + Unicorn)
  • MongoDB
  • Redis
  • RabbitMQ

Default local ports:

  • Backend: http://localhost:3000
  • UI: http://localhost:3002
  • RabbitMQ management: http://localhost:15672

Related repository:

Project status

The repository is actively maintained. Current local migration baseline in this branch/repo:

  • Ruby 3.2.2
  • MongoDB 7.0
  • Docker Compose local runtime

Additional migration context is documented in upgrading_notes.md.

Quick start (local Docker Compose)

Prerequisites

  • Docker Desktop (or Docker Engine + Compose v2 plugin)
  • git

1) Clone the repository

git clone https://github.com/cenit-io/cenit.git
cd cenit

2) Start the stack

docker compose up -d --wait --wait-timeout 300
scripts/smoke/compose_stack.sh

The default stack runs the five published services needed to evaluate Cenit:

  • UI: http://localhost:3002
  • Backend: http://localhost:3000
  • RabbitMQ management: http://localhost:15672

Default admin credentials on a fresh database:

No source checkout or local image build of the UI is required.

2.1) Contributor development mode

Clone the UI as a sibling repository before using the development override:

git clone https://github.com/cenit-io/ui.git ../ui
scripts/compose-dev.sh up -d --wait --wait-timeout 300

This builds both images from local source. Set CENIT_UI_CONTEXT if the UI checkout is not at ../ui.

Fast UI development mode (live reload)

Use this when iterating on UI code to avoid rebuilding the nginx UI image:

cd /path/to/cenit
scripts/compose-dev.sh --profile dev up -d mongo_server redis rabbitmq server ui_dev
scripts/compose-dev.sh --profile dev ps

Notes:

  • ui_dev serves Vite on http://localhost:3002 with source mounted from ${CENIT_UI_CONTEXT:-../ui}.
  • Keep ui (nginx image service) for production-like checks and CI parity.

2.2) Explicit image-only (prod-like) mode

cd /path/to/cenit
scripts/compose-prod.sh up -d
scripts/compose-prod.sh ps

This uses:

  • docker-compose.yml + docker-compose.prod.yml
  • published images from GHCR (pull_policy defaults to missing)

GHCR tag policy (from publish workflows):

  • master branch -> ghcr.io/cenit-io/cenit:latest and ghcr.io/cenit-io/ui:latest
  • develop branch -> ghcr.io/cenit-io/cenit:develop and ghcr.io/cenit-io/ui:develop
  • release tags v*.*.* -> semver tags
  • every publish -> immutable sha- tag

Run prod-like using develop images:

CENIT_SERVER_IMAGE=ghcr.io/cenit-io/cenit:develop \
CENIT_UI_IMAGE=ghcr.io/cenit-io/ui:develop \
scripts/compose-prod.sh up -d

Run prod-like pinned to immutable SHA tags:

CENIT_SERVER_IMAGE=ghcr.io/cenit-io/cenit:sha-<server_sha> \
CENIT_UI_IMAGE=ghcr.io/cenit-io/ui:sha-<ui_sha> \
scripts/compose-prod.sh up -d

For strict refresh from registry each run:

CENIT_PULL_POLICY=always scripts/compose-prod.sh up -d

2.3) Repro mode with non-default host ports (redirect/debug)

Use this to reproduce host/port redirect issues (for example, verify UI does not fall back to localhost:3000).

cd /path/to/cenit
REPRO_SERVER_PORT=13000 REPRO_UI_PORT=13002 scripts/compose-repro.sh up -d
REPRO_SERVER_PORT=13000 REPRO_UI_PORT=13002 scripts/smoke/repro_runtime_ports.sh

Default repro port mapping:

  • Backend host port: 13000 -> container 8080
  • UI host port: 13002 -> container 80

Optional public URL overrides (if not using localhost):

REPRO_SERVER_PUBLIC_URL=http://127.0.0.1:13000 \
REPRO_UI_PUBLIC_URL=http://127.0.0.1:13002 \
scripts/smoke/repro_runtime_ports.sh

3) Verify services

scripts/smoke/compose_stack.sh

RabbitMQ default credentials:

  • User: cenit_rabbit
  • Password: cenit_rabbit
  • VHost: cenit_rabbit_vhost

Common local operations

# Follow backend logs
docker compose logs -f server

# Restart backend only
docker compose restart server

# Stop all services
docker compose down

# Full reset (containers + volumes)
docker compose down -v --remove-orphans

Configuration

Important environment knobs used by local scripts:

  • CENIT_SERVER_URL (default http://localhost:3000)
  • CENIT_UI_URL (default http://localhost:3002)
  • CENIT_UI_CONTEXT (path to UI repository for Docker build)
  • CENIT_SERVER_IMAGE (prod-like server image tag, default ghcr.io/cenit-io/cenit:latest)
  • CENIT_UI_IMAGE (prod-like UI image tag, default ghcr.io/cenit-io/ui:latest)
  • CENIT_UNICORN_WORKERS (backend worker count, default 2 for local evaluation)
  • CENIT_MAXIMUM_UNICORN_CONSUMERS (RabbitMQ consumer workers, default 2)
  • CENIT_PULL_POLICY (prod-like pull policy, default missing; use always for strict pulls)
  • CENIT_COMPOSE_FILES (default: docker-compose.yml:docker-compose.dev.yml)
  • CENIT_COMPOSE_FILE (legacy single-file override, still supported)
  • CENIT_BASE_COMPOSE_FILE (helper override for base file)
  • CENIT_DEV_COMPOSE_FILE (helper override for dev file)
  • CENIT_PROD_COMPOSE_FILE (helper override for prod-like file)
  • CENIT_REPRO_COMPOSE_FILE (helper override for repro file)

Image labels:

  • GHCR images are published with OCI metadata labels (source/revision/created) via docker/metadata-action.

Testing and quality checks

Backend API integration checks

scripts/e2e/cenit_api_login.sh
scripts/e2e/cenit_api_contact_flow.sh
scripts/e2e/cenit_api_integration_journey.sh

Browser journeys are owned by the Cenit UI repository. From a sibling UI checkout, run npm run e2e:login, npm run e2e:contact-flow, npm run e2e:user-journey, or npm run e2e:integration-journey.

Browser smoke: no localhost redirect during auth bootstrap

# Default URL
scripts/smoke/cenit_ui_no_localhost_redirect.sh

# Repro stack URL
CENIT_UI_URL=http://localhost:13002 scripts/smoke/cenit_ui_no_localhost_redirect.sh

This smoke fails if any browser request hits http://localhost:3000 during initial auth flow.

Pre-apply repro gate (runtime + browser checks)

REPRO_SERVER_PORT=13000 REPRO_UI_PORT=13002 scripts/smoke/repro_preapply_gate.sh

Use this as the required gate before Terraform apply or other deploy steps when validating the localhost redirect fix path.

Flow execution + RabbitMQ smoke

scripts/e2e/cenit_flow_execution_smoke.sh

Git hooks (pre-push E2E)

Install hooks:

npm install
npm run prepare

Current pre-push behavior:

  • Runs the backend API v3 login, contact-flow, and strict integration journey.
  • Does not require or invoke the UI repository.

Overrides:

# Skip the backend API E2E gate once
SKIP_E2E_HOOKS=1 git push

Troubleshooting

Backend does not become reachable on :3000

scripts/compose-dev.sh ps -a
scripts/compose-dev.sh logs --no-color --tail=200 server

If needed, run a full reset and rebuild:

scripts/compose-dev.sh down -v --remove-orphans
scripts/compose-dev.sh up -d --build

Contributing

Contributions are welcome and appreciated.

readme truncated — read the full docs on github

Frequently asked questions

Is cenit free to use?

cenit is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does cenit do?

:rocket: Cenit IO - 100% open source integration Platform (iPaaS)

What is cenit written in?

cenit is primarily written in Ruby. Its source is publicly available at https://github.com/cenit-io/cenit, and it has 503 GitHub stars.