Skip to content

Sudoo.sh overview ​

Sudoo.sh

Every Odoo environment your team needs (demos, test branches, training, customer previews) on one server you own, for the price of that server instead of a bill per environment.

Any branch of your repository becomes a running Odoo, any version, Community or Enterprise, with its own HTTPS link, in about two minutes. Instances nobody is using pause themselves, so one ordinary server holds dozens of them.

sudo + Odoo: full control of your Odoo instances, on a server you own.

Community and Enterprise · Any Odoo version · GitHub sync · Live metrics · Five roles · Second factors · Auto-pause · Daily backups and one-click restore · One-command install

IMPORTANT

Instances are for showing Odoo, not for real data. Every instance opens with the Odoo login admin / admin, and anyone who has an instance's link can sign in with it. With the default exposure plugin the public links are free Cloudflare links: they change when the server restarts, and the panel always shows the current ones. Panel accounts are different: their passwords are stored only as hashes, and a second factor can be required.

Quick start ​

On a Linux server (Ubuntu 22.04+ or Debian 12+), one command checks the server, installs what is missing (Docker, after asking) and starts Sudoo.sh from its prebuilt images:

bash
curl -fsSL https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/sudoo-install.sh | sudo bash

To read the installer before running it, download it with the release's checksums, check it, and run it:

bash
curl -fsSLO https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/sudoo-install.sh
curl -fsSLO https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/SHA256SUMS
sha256sum --check --ignore-missing SHA256SUMS      # must print: sudoo-install.sh: OK
less sudoo-install.sh                              # read it
sudo bash sudoo-install.sh

It prints the panel's link and a setup code. Open the link, enter the code, and create your own account with your name, e-mail and password; you sign in with your e-mail address. Everything else, including the e-mail account that sends sign-in codes, is set up in the website. Without the installer: Manual installation. Details in Installation & Configuration.

Why Sudoo.sh ​

The problem: every extra environment costs money ​

Odoo teams rarely need just one test database. A partner wants a fresh demo for each prospect, developers want every feature branch running before it reaches production, consultants want a copy to try a configuration on, trainers want one per class, and customers want a link to check a fix themselves.

On hosted platforms such as Odoo.sh, each staging environment is billed every month on top of workers and storage, development builds are short-lived and not meant for customers, and the hosting price does not include the Enterprise licence. The more branches a team keeps, the higher the bill, so teams start rationing: demos are deleted too early, several features share one staging, and some work never gets a live environment at all.

The solution: pay for one server, run as many environments as it holds ​

Hosted, billed per environmentSudoo.sh
One more demo or test branchadds to the monthly billcosts nothing extra; limited by your server's disk
Environments nobody is usingbilled while idlepaused, using no memory, until someone opens the link
A demo for a prospectwait for a build, share access to the projectits own link in about two minutes, deleted after the days you choose, with a backup
Testing a feature brancha few staging slots shared by everyoneevery branch its own instance, updated on every push
Where your code and data livethe provider's cloudyour server

A typical team runs Sudoo.sh on a single rented server with a few gigabytes of memory: the instances in use run, the rest wait paused, and the monthly cost stays the server's price however many branches there are.

Made for: Odoo partners and integrators (a demo per prospect), in-house Odoo teams (every branch tested before production), trainers and schools (an instance per class or student), and freelancers.

Not for: production databases. Keep live company data on a production host; Sudoo.sh is for everything around it (development, demos, tests and training).

Sudoo.sh and Odoo.sh ​

Sudoo.sh is to your own server what Odoo.sh is to Odoo's cloud: branches become running instances. It is an independent project, not affiliated with Odoo S.A.

Odoo.shSudoo.sh
Where it runsOdoo's cloudyour server (one Docker host)
Costper worker, per GB of storage and per staging environmentyour server; free for noncommercial use, a commercial licence for companies
A running Odoo per branchyesyes, Community or Enterprise, any version
Updates on pushyesyes: GitHub App, GitHub webhook or polling (plugins)
Instances that pause and expirestaging builds expirepause when unused, wake on the next visit; lifetime with a backup
How instances are reached*.odoo.comfree Cloudflare tunnels, open ports, or your own exposure plugin
API for automationsigned REST API (Panel API)
Production hostingyesno: Sudoo.sh is for development, demos, tests and training

What This Panel Does ​

Sudoo.sh runs on the server and is used from a browser. Nobody has to install anything or run any command to use it: people receive a link.

  1. Create an instance in a few clicks: choose a GitHub repository, a branch, the Odoo version (any published version) and the edition (Community or Enterprise). The name, the database, the ports and the passwords are generated. Two minutes later the panel shows the instance's own https link and its login. See Creating an instance.
  2. One https link per instance: every instance is reachable from anywhere through its own link, even though the server accepts no incoming connections. Browsers, API clients and webhook senders use it like any Odoo address. See Tunneling.
  3. Stays in sync with GitHub: by polling GitHub every 2 minutes, or instantly through a GitHub webhook (both are plugins, use either or both); when a developer pushes, the instance pulls the code, upgrades only the modules whose files changed and restarts. Submodules (for example OCA repositories) can be updated, added and removed from the panel.
  4. Private repositories without personal tokens: connect GitHub once and the panel's own read-only GitHub App reads every repository you allow on your account or organisation, submodules included; pushes reach the panel at once. Servers without it use one read-only deploy key per repository, created by the panel and stored encrypted. See The GitHub App and Deploy keys.
  5. Saves memory by itself: an instance nobody opened for 6 hours is paused, and starts again by itself on the next visit (a "Starting up" page is shown for a few seconds).
  6. Restart, pause, switch off, delete: from the list (Restart) or from the instance's page.
  7. Lifetime and backups: each instance can be deleted automatically a set number of days after its creation (30 by default), or kept. The choice is made when creating it and can be changed later. Before any deletion, automatic or by hand, the database and files are saved as a standard Odoo backup, listed under Backups.
  8. Daily backups with one-click restore: every instance that was used during the day is backed up once a day, at a time you choose, keeping its latest daily backup. Restore the latest on the instance's page puts a backup back in a minute or two, after saving the current state, and Rollback undoes it for 24 hours. Any backup can also go into another instance of the same Odoo version, or start a new instance, neutralised so the copy sends no e-mail. See Backups.
  9. Five roles: super admin, administrator, maintainer, developer and viewer, each a clear set of permissions. People sign in with their e-mail address; passwords follow the NIST rules (length and a blocklist, no forced symbols). Sign-in can require a second factor: an authenticator app or a code by e-mail. See Accounts and roles.
  10. Live figures: processor, memory, requests, errors and response times of the server and every instance, every few seconds, with an hour of history. The Instances page charts requests and errors, instances by state, response times and the busiest instances. Pages update by themselves as things change.
  11. An API for other systems: CI pipelines and scripts can create, update, restart and delete instances with an API token and a signature on every request. See Panel API.
  12. Apps for Odoo: your company's own Odoo can create and manage instances from the record that needs them, with free apps on the Odoo Apps store for Odoo 17.0 to 20.0, in English and Arabic: Instance Manager, CRM Demos (a demo per opportunity), Project Tests (a test instance per task) and Helpdesk Tests (per ticket). They use a token of the least-privilege instances scope. Source and documentation: Sudoo-sh/sudoo-odoo.
  13. Explains itself: plain-language messages when something fails, the technical log next to it, and this documentation inside the panel under Help.
  14. Set up from the website: every setting, from second factors and limits to the e-mail account, on the Settings page, with .env as the base. Light and dark themes, and your own accent colour.

Architectural Position ​

How the parts of Sudoo.sh fit together

Everything on the server listens on 127.0.0.1 only. The only ways in are the Cloudflare connectors (which the server itself opened) and SSH for administrators. The full picture is in Architecture.


Technologies and What We Gain From Them ​

TechnologyWhat it does hereWhat we gain
Docker EngineRuns every Odoo, every PostgreSQL, the panel and the connectors as containers.Instances are isolated from each other and from the server: one can break or be deleted without touching the others. See Docker.
Docker ComposeDescribes each instance (Odoo + PostgreSQL + volumes) as one project.One command starts, stops or removes a whole instance, and deleting leaves nothing behind.
Official Odoo images (odoo:<version>)The Odoo program itself.Nothing to build or maintain; every version behaves exactly as Odoo publishes it; new versions appear in the panel by themselves (ODOO_VERSIONS=auto).
PostgreSQL 16The database of each instance.Odoo's own database; one per instance, so instances never share data.
Cloudflare Tunnel (cloudflared, quick tunnels)Gives the panel and every instance a public https address.Works without any open port, free, https included, no domain needed. See Tunneling.
Python 3.12+ with type hintsThe panel's language.Same language as Odoo, so every Odoo developer can read and fix it; type hints checked by mypy catch mistakes before they run.
uvInstalls the dependencies, from a lock file.Fast, and every installation (servers, CI, developers) gets exactly the same versions.
pydantic-settingsReads and checks the settings.Every setting typed and documented in one class; a wrong value stops the panel at start-up with a clear message.
Entry-point pluginsHow instances are reached, where Enterprise comes from, what starts updates.Nothing is forced: each server chooses, and new options are added as plugins without changing the panel. See Plugins.
FlaskThe panel's pages and JSON API.Small, well known, signed session cookies built in.
GunicornServes the Flask app.Production web server; threads let long actions run without blocking the page.
aiohttpThe gateway in front of every instance.Streams large files and keeps thousands of WebSocket connections (Odoo's live updates) open with little memory. See Gateway.
cryptography (AES-256-GCM)Encrypts the secrets the panel must read back (deploy keys, Odoo master passwords).Audited library; encryption that also detects any change to the stored value. See Passwords and encryption.
scrypt (Python standard library)Hashes panel passwords.Slow and memory-hungry on purpose, so stolen hashes are very expensive to guess.
Git and SSH deploy keysFetch code; read-only access to one repository per key.No personal account or token whose owner might leave; each key can be revoked on its own. See Git submodules.
React 19 + TypeScript + ViteThe web app (web/), a separate service on top of the API.Typed end to end; pages load only when opened; fast rebuilds; any front-end developer can work on it.
TanStack Query + Server-Sent EventsData in the web app, kept current by the live event stream.Pages update the moment something happens, with no polling; data is cached between pages.
SCSS design tokensEvery colour, size, material and motion defined once (web/src/styles/_tokens.scss), light and dark themes; the system font, translucent chrome and motion in Apple's manner (Design).Restyling Sudoo.sh is one file; the accent colour follows BRAND_COLOR.
Chart.jsThe live charts: an hour of figures, updated in place as each sample arrives.Smooth, accessible canvas charts in a small, tree-shaken bundle.
CaddyServes the web app and forwards /api to the backend (container sudoo-web).One small binary, compression, strict security headers, no configuration beyond one file.
SQLiteThe panel's own data (accounts, tokens, audit log).Transactions and queries without a database server.
Python-MarkdownShows this documentation inside the panel.One set of Markdown files, read on GitHub and in the panel.
Alpine Linux (python:3.15-alpine)The panel's container.Small image; the Docker command line is copied in from the official Docker image.
black, ruff, mypy, pre-commitFormatting, lint, type checks on every commit and in CI.One style, mistakes caught before review, enforced for everyone.

Why each of these was chosen over the alternatives is explained in Architecture: why we chose this.


Documentation ​

All documents are in docs/ and are also shown inside the panel under Help.

DocumentForWhat it covers
Documentation indexeveryoneWhere to find what, by question ("how do I...?")
User manualeveryone who uses the panelEvery page and button of the panel, step by step
Administrator guidethe server's administratorInstalling, files, backups, Enterprise add-ons, troubleshooting
Configurationthe server's administratorEvery setting, with its type and default
Pluginsadministrators, developersChoosing how instances are reached, where Enterprise comes from and what starts updates; writing your own
Panel APIdevelopersManaging instances from other systems with signed API calls
API and webhooksdevelopersCalling an instance's Odoo from other systems
ArchitecturedevelopersHow the parts work together, and why we chose each of them
Designdevelopers, designersThe design system: tokens, type, materials, motion, charts; restyling Sudoo.sh
Securityadministrators, reviewersPasswords, encryption, sessions, input checks, what is and is not protected
Conceptsanyone curiousTunneling, Docker, the gateway, deploy keys, submodules, passwords and encryption, web attacks; each with examples

Security at a Glance ​

TopicHow it is handled
ReachabilityNothing listens on a public address. The web app, the backend, the gateway and Odoo listen on 127.0.0.1; the way in is the Cloudflare connectors.
First runNo default accounts: the first account is created with a one-time setup code printed on the server.
Panel passwordsNever stored. Only a salted, peppered scrypt hash is kept; the pepper comes from a key outside the accounts file. Rules follow NIST SP 800-63B: 12 to 128 characters, common passwords and sequences refused. Sign-in is locked after repeated failures.
Stored secretsThe GitHub App's private key, GitHub deploy keys and Odoo master passwords are encrypted with AES-256-GCM. Odoo itself only receives a hash of its master password.
InputEvery value from a browser or API client is checked against an allow-list (type, length, characters, pattern) before use, and never passed through a shell.
SessionsSigned, HttpOnly, Secure, SameSite=Strict cookie; signed out after 60 minutes without activity and after 12 hours.
BrowserCSRF token and same-origin check on every change; strict Content-Security-Policy; no inline scripts; HSTS.
Second factorsAuthenticator app or e-mail code; can be required for administrators or everyone.
Roles and auditFive roles made of named permissions, checked on the server for every request; every sign-in, refusal and action is in the audit log.
LimitsRequests per minute per user or address; how many instances, and how often.

Details, and what is deliberately not protected, are in Security.


Components ​

sudoo.sh/
├── README.md, LICENSE.md, CHANGELOG.md, CONTRIBUTING.md, SECURITY.md
├── pyproject.toml, uv.lock        # dependencies (locked with uv), plugins, tool settings
├── Dockerfile, compose.yaml       # the backend image (sudoo-panel, with docs/ inside) and the web app (sudoo-web)
├── .github/workflows/             # CI; images.yml builds, signs and publishes the images (release.yml, edge from main)
├── web/                           # the web app: React + TypeScript + Vite, served by Caddy
│   ├── src/api/                   #   typed calls to /api/v1, query hooks, the live event stream
│   ├── src/styles/                #   SCSS: _tokens.scss (colours, sizes, motion), components, layout, pages
│   ├── src/components/            #   frame (Shell), UI pieces, charts
│   ├── src/pages/                 #   one file per page, loaded when first opened
│   └── Caddyfile, Dockerfile      #   serves the app; forwards /api, /hooks, /docs and the live events
├── .env.example                   # every setting, documented (full list: docs/CONFIGURATION.md)
├── .pre-commit-config.yaml        # black, ruff, mypy, shellcheck, ... on every commit and in CI
├── docs/                          # documentation, also shown in the panel (Help); images/ and diagrams/build.py
├── tests/                         # pytest
├── examples/                      # panel_api_client.py: a dependency-free client for the panel's API
└── src/sudoo/
    ├── config.py                  # every setting, typed (pydantic-settings)
    ├── plugins.py                 # finds and loads plugins (entry points)
    ├── cli.py                     # the sudoo command: accounts, links, config, serve
    ├── accounts.py                # accounts, profiles, password hashing, first-run setup, sign-in throttling
    ├── roles.py                   # the five roles and their permissions
    ├── storage/                   # PLUGIN TYPE: where the panel keeps its data (sqlite), migrations
    ├── auth/                      # PLUGIN TYPES: authenticators (local) and second factors (totp, email)
    ├── mail/                      # PLUGIN TYPE: mailers (smtp, none); HTML e-mail templates
    ├── limits/                    # PLUGIN TYPE: rate limiters (memory); instance quotas
    ├── background.py              # monitor, auto-pause, auto-delete, daily backups, GitHub polling, gateway, exposure
    ├── core/                      # infrastructure, no Odoo knowledge
    │   ├── shell.py, jobs.py      #   commands without a shell; background actions, one per instance at a time
    │   ├── state.py, audit.py     #   last visit / paused / switched off; audit log
    │   ├── vault.py, hints.py     #   AES-256-GCM encryption; plain-language error explanations
    ├── instances/                 # the life of an instance
    │   ├── store.py               #   folders, .env files, names, ports
    │   ├── odoo.py                #   compose file, odoo.conf, database parameters, versions
    │   ├── operations.py          #   create, delete, back up, restore, restart, pause, updates, submodules
    │   ├── backups.py             #   Odoo-format backups, kinds, daily schedule, restore
    │   ├── gateway.py, status_pages.py, monitor.py
    ├── repos/                     # git and GitHub: the GitHub App, deploy keys, access checks, git helpers
    ├── exposure/                  # PLUGIN TYPE: how instances are reached
    │   ├── base.py                #   the interface
    │   ├── cloudflare.py          #   cloudflare-quick
    │   └── ports.py               #   host-ports
    ├── triggers/                  # PLUGIN TYPE: what starts a code update
    │   ├── base.py                #   the interface
    │   ├── polling.py             #   polling
    │   ├── github_app.py          #   github-app
    │   └── github_webhook.py      #   github-webhook
    ├── api_tokens.py              # API tokens: hashed tokens, encrypted signing secrets, signature checks
    ├── addons/                    # PLUGIN TYPE: where Enterprise add-ons come from
    │   ├── base.py                #   the interface
    │   ├── folder.py              #   folder
    │   └── git.py                 #   git
    └── web/                       # Flask app: security, sign-in, validation, the API (v1/), documentation

Rules of the layout ​

RuleWhy
One module per responsibility, each with a docstring that says what it owns.Anyone can find where a behaviour lives from the file name.
Anything that differs between servers is a plugin or a setting, never a fixed choice.Each server picks what fits it; the core stays the same.
web/ only receives requests, checks them and calls the other modules.The work (operations, git, Docker) can be tested and reused without HTTP.
Every external command is a list of arguments, run without a shell (core/shell.py, core/jobs.py).User input can never be interpreted as a command.
Every value from outside goes through web/validation.py.One place to read and review all input rules.
Type hints everywhere, checked by mypy; formatting by black; lint by ruff.Mistakes are caught before review, and the code reads the same everywhere.
No inline scripts in the browser code, and the web app talks to the backend only through /api/v1.Allows the strict Content-Security-Policy; the front end can be replaced without touching the backend.

Installation & Configuration ​

Requirements: a Linux server (Ubuntu 22.04+ or Debian 12+; amd64 or arm64) with systemd, 2 CPU cores, at least 2 GB of memory (about 1 to 1.5 GB per running instance), 20 GB of free disk, and outgoing HTTPS to GitHub, ghcr.io, Docker Hub and Cloudflare. With the default exposure plugin no incoming port is needed.

bash
curl -fsSL https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/sudoo-install.sh | sudo bash

The installer checks the server first and prints every problem with its fix; it installs nothing without asking ([y]es, [n]o or [a]ll; --yes answers yes for scripts). It downloads the two prebuilt, signed images of the release (ghcr.io/sudoo-sh/sudoo-panel and sudoo-web, pinned by digest), writes /opt/odoo/manager/.env and compose.yaml, and starts them. It stays on the server as sudoo-install:

CommandWhat it does
sudo sudoo-install checkChecks the server; changes nothing.
sudo sudoo-install updateUpdates to the latest release. Only sudoo-panel and sudoo-web are replaced; instances, accounts, keys, settings and the public links are kept.
sudo sudoo-install update --rollbackGoes back to the version that ran before the last update.
sudo sudoo-install update --version edgeFollows main (images built from every commit), for test servers.
sudo sudoo-install statusVersion, containers, links.
sudo sudoo-install uninstallRemoves the panel; /opt/odoo and the instances' data are kept (--purge deletes everything).

A server installed with the earlier install.sh is moved to the images by the same update, with the same containers, folders and settings. Everything about installing: Administrator guide.

The installer prints the panel's link and, on a new server, a setup code: open the link, enter the code and create the first account (a super admin). Show the code again with docker exec sudoo-panel sudoo.sh setup-code.

Manual installation ​

Without the installer, with Docker Engine 24+ and its Compose plugin already installed:

bash
sudo install -d -m 700 /opt/odoo /opt/odoo/manager /opt/odoo/instances /opt/odoo/enterprise
cd /opt/odoo/manager
sudo curl -fsSLO https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/compose.yaml
sudo curl -fsSL -o .env https://github.com/Sudoo-sh/sudoo.sh/releases/latest/download/env.example
sudo chmod 600 .env compose.yaml                  # then edit .env if needed (docs/CONFIGURATION.md)
sudo docker compose pull && sudo docker compose up -d
sudo docker exec sudoo-panel sudoo.sh urls        # the panel's link
sudo docker exec sudoo-panel sudoo.sh setup-code  # the code for the first account

The release's compose.yaml names the images by digest. To update by hand, download the new release's compose.yaml, add the new keys of its env.example to .env, and run sudo docker compose pull && sudo docker compose up -d again in /opt/odoo/manager.

From source (developers) ​

The repository's compose.yaml builds the two images from the source (sudoo-panel:local, sudoo-web:local):

bash
git clone https://github.com/Sudoo-sh/sudoo.sh.git && cd sudoo.sh
sudo install -d -m 700 /opt/odoo /opt/odoo/manager /opt/odoo/instances /opt/odoo/enterprise
[ -f /opt/odoo/manager/.env ] || sudo install -m 600 .env.example /opt/odoo/manager/.env
sudo ln -sfn /opt/odoo/manager/.env .env           # the same settings for the clone
sudo docker compose build
sudo docker compose up -d manager web

Run git pull and the last two commands again to update. This replaces only sudoo-panel and sudoo-web, like the installer; to go back to the released images, run sudo sudoo-install update (or the manual steps above).

Almost every setting can be changed in the website (Settings). The base values are in /opt/odoo/manager/.env; the ones most people change:

SettingDefaultMeaning
EXPOSUREcloudflare-quickHow instances are reached: a free Cloudflare tunnel each, or host-ports
ENTERPRISE_SOURCEfolderWhere Enterprise comes from: folder, git or none
ENTERPRISE_PATH/opt/odoo/enterprise/{version}Folder of a version's Enterprise add-ons, any naming
ODOO_VERSIONSautoEvery published Odoo version from ODOO_MIN_VERSION (16.0), or a fixed list
IDLE_HOURS6Pause after this many hours without visits
DELETE_AFTER_DAYS30Lifetime offered for new instances (each instance can be set to "keep")
ADMIN_CONTACT_NAMEthe administratorWho users are told to contact
SMTP_HOST, SMTP_USERNAME, SMTP_PASSWORDemptyThe mailbox that sends sign-in codes, for example Gmail with an app password
REQUIRE_SECOND_FACTORadminsWho must use a second factor: none, admins or everyone

Every setting, with its type and default: Configuration. Choosing and writing plugins: Plugins. Running the server (files, backups, troubleshooting): Administrator guide.


Testing ​

bash
uv sync                          # installs the project and the development tools
uv run pytest                    # tests
uv run pre-commit run --all-files   # black, ruff, mypy, shellcheck, uv.lock and file checks
cd web && npm ci && npm run build   # the web app: type check and build

The same checks, plus a Docker image build, run on every pull request (CI). The panel is also tested end to end on a real server, through the public links, the way users reach it:

AreaChecked
InstancesOdoo 20 Enterprise created in under 2 minutes; backup before deletion restorable by Odoo, web_enterprise installed, 800+ Enterprise apps available; restart; pause; a visit wakes a paused instance in a few seconds; delete removes everything.
Odoo through its linkSign-in admin / admin, JSON-RPC, XML-RPC, JSON-2 API with an API key, incoming webhook, 5 MB upload and download, 30 parallel calls, WebSocket, two instances signed in at the same time.
SecuritySign-in throttling, roles, CSRF and same-origin checks, session expiry, refused input (wrong types, too long, control characters, option-like branch names), encrypted deploy keys, Odoo accepting its hashed master password.

How to repeat these checks is described in the Administrator guide.


Known Limitations ​

  • With cloudflare-quick, links change after a restart of the server or of a connector. For links that never change, use EXPOSURE=host-ports on a server that can accept connections, or write an exposure plugin for a Cloudflare named tunnel with your own domain (Plugins).
  • Cloudflare quick tunnels carry at most 100 MB per request, end requests that take longer than about 100 seconds, and have no uptime guarantee.
  • Memory: about 1 to 1.5 GB per running instance. On a 3 GB server, keep one or two instances running; the others pause by themselves.
  • Python libraries listed in a module's requirements.txt are not in the official Odoo image.
  • An instance's major version cannot be changed; create a new instance for another version.
  • Without the GitHub App or a webhook, updates start up to 2 minutes after a push (GitHub is polled).
  • The vault key is on the same server as the secrets it protects: it protects copies and backups of the data, not a person who already has full control of the server. See Security.

Odoo Enterprise Add-ons (Not Included) ​

This repository contains no Odoo Enterprise code. Enterprise add-ons are Odoo's proprietary modules, available to Odoo partners and subscribers; each server needs its own copy. Community instances work without them.

The add-on source plugin decides where the panel finds them (Plugins):

ENTERPRISE_SOURCEThe add-ons areSet
folder (default)in a folder per version, with any namingENTERPRISE_PATH, e.g. /opt/odoo/enterprise/{version} or /data/ent-{major}
gitin a git repository with one branch per versionENTERPRISE_GIT_URL, ENTERPRISE_GIT_BRANCH (e.g. {version})
nonenot used: Community only

With the default folder source, each version's folder holds the modules directly:

/opt/odoo/enterprise/           (ENTERPRISE_PATH=/opt/odoo/enterprise/{version})
├── 18.0/
│   ├── web_enterprise/         required: Enterprise is offered for a version only when this module is there
│   ├── account_accountant/
│   └── ...                     every Enterprise module directly inside the version folder
├── 19.0/
└── 20.0/
RuleRightWrong
Modules sit directly inside the version folder19.0/web_enterprise/19.0/enterprise/web_enterprise/
The add-ons match the version of the folderOdoo 19 add-ons for 19.0Odoo 18 add-ons for 19.0
Readable by the Odoo containerschmod -R a+rX <folder>files readable by root only

The Edition field in the panel then offers Enterprise for that version immediately. Enterprise databases must be registered with your own Odoo subscription or partner code.


Licensing & Terms ​

Licensed under the PolyForm Noncommercial License 1.0.0: the source is open to read, use, change and share, for any noncommercial purpose.

AllowedNot allowed
Personal use, study, research, testingSelling it, or selling a service built on it
Use by charities, schools, public bodiesUsing it to make money for a company without permission
Changing it and sharing your changes under the same licenceRemoving the licence or the copyright notice

"Sudoo" and "Sudoo.sh", the logo and the marketplace's "Official" and "Verified" badges are trademarks of the author, and the licence does not cover them: a changed copy may not use the name or logo, and only plugins published on marketplace.sudoo.sh may show the badges. See TRADEMARKS.md.

Commercial licences ​

Sudoo.sh is owned by its author (named in LICENSE.md). Companies that want to use it for their business, offer it as a hosted service, or build a product on it can get a commercial licence, a hosted plan or support: write to [email protected]. Contributions are accepted under the terms in CONTRIBUTING, which keep commercial licensing possible.

For commercial use, ask the author for a separate licence. Odoo and Odoo.sh are trademarks of Odoo S.A.; this project is not affiliated with or endorsed by Odoo S.A.


Contributing ​

Contributions are welcome: bug reports, documentation fixes and code.

Support ​

Maintainer ​

Built and maintained by the Sudoo.sh project, with help from every contributor.