DirectAdmin Nginx Unit: Node.js and Python Apps

Enabling Nginx Unit and per-user Redis through CustomBuild on DirectAdmin, deploying a Node.js or Python application under a user account, and the resource and socket details that decide whether it stays up.

Published 29 Sep 2026Updated 3 Oct 2026 6 min read By srvScripts team

DirectAdmin does not need a third-party selector to host application code beyond PHP. CustomBuild can install Nginx Unit, an application server that runs Node.js, Python, Ruby and PHP processes under the owning user’s account, and it can give each user a private Redis instance reachable over a Unix socket. Together they cover the common request from agencies: a WordPress site on Apache or LiteSpeed next to a small API written in Node or Python, with a cache the customer controls. This tutorial walks through the install and a first deployment on a current build (1.711 at the time of writing).

Short answer: Enable unit and redis in CustomBuild with da build set, build both and run rewrite_confs, then create the application from the user’s Nginx Unit page in Evolution, pointing it at the app directory and entry file so DirectAdmin proxies the domain or path to Unit. The application must listen on the port Unit provides, and a per-user Redis instance is reachable only over the socket at ~/.redis/redis.sock.

Install Unit and Redis with CustomBuild

Unit sits behind the front web server, so the existing Apache, nginx or LiteSpeed stack stays in place. Enable both components and build them:

da build set unit yes
da build set redis yes
da build unit
da build redis
da build rewrite_confs

Run da build options first to confirm the exact option names on your build; the option set has grown steadily and older CustomBuild versions used different keys for the Node.js runtime. On AlmaLinux 9 and 10 the Node.js binaries come from the CustomBuild package set, so you do not need NodeSource repositories. Python applications use the system interpreter unless a user supplies a virtual environment.

After the build, check that both services are managed by systemd:

systemctl status unit
systemctl status redis

Unit’s control socket lives under /var/run/unit/, and DirectAdmin talks to it on the user’s behalf. Users never need shell access to Unit itself.

Deploy a Node.js application

Log in as the user in the Evolution skin and open the Nginx Unit page under Advanced Features. Create an application, choose the Node.js runtime, set the application root to a directory inside the user’s home (for example /home/appuser/apps/api) and the entry file, and map it to a domain or a path under the domain. DirectAdmin writes the Unit configuration and rewrites the web-server configuration so requests for that path are proxied to Unit.

Upload the code through File Manager, SFTP or a git checkout and install dependencies as the user:

cd /home/appuser/apps/api
npm ci --omit=dev

The application must listen on the port or socket Unit hands it rather than a hard-coded port. Most frameworks respect process.env.PORT; if the code binds 3000 unconditionally, Unit reports the app as started while the front web server returns a bad gateway error.

Deploy a Python application

The Python path is the same except that Unit calls a WSGI or ASGI callable rather than a script. Point the application at the module and callable, for example app:application, and create a virtual environment inside the app directory so packages are isolated:

python3 -m venv /home/appuser/apps/flaskapp/venv
/home/appuser/apps/flaskapp/venv/bin/pip install -r requirements.txt

Set the environment path on the Unit application page so the interpreter inside the virtual environment is used. Django projects also need STATIC_ROOT served by the front web server, not by Unit, or every asset request costs a Python worker.

Give the user a Redis instance

With the Redis component enabled, the user turns on their own instance from the Redis page in the same Advanced Features section. DirectAdmin starts a redis-server process as that user with a socket at /home/appuser/.redis/redis.sock and no TCP listener, so other accounts cannot reach it. The application connects over the socket:

REDIS_URL=unix:///home/appuser/.redis/redis.sock

For WordPress on the same account, the Redis Object Cache plugin accepts the same socket path as its host setting with port 0. Memory per instance is capped by the panel; the default is modest and appropriate for shared hosting, and it can be raised for specific packages from the reseller or admin level.

Common pitfall: memory and process limits

Every Node.js process, Python worker and Redis instance is an ordinary process owned by the user. On a shared server with CloudLinux-style limits absent, one runaway application can consume the box. Set a sensible processes count on each Unit application (two or three workers are plenty for small APIs), keep Redis maxmemory enforced, and watch the per-user resource graphs introduced in 1.703 for accounts that run applications. If the server also runs CSF, its process tracking flags long-running user processes; either raise PT_USERPROC for the application users or leave PT_LIMIT=0, which has been the DirectAdmin default since 1.689.

Verify

Request the application through the public hostname and check the response headers come from the front server with the app’s content behind it:

curl -sI https://example.com/api/health

Then confirm the process ownership and socket from the shell:

ps -o user,pid,cmd -u appuser | grep -E 'node|python|redis'
ls -l /home/appuser/.redis/redis.sock

If the application starts and immediately exits, its stdout and stderr are in the Unit journal rather than in a file: journalctl -u unit -n 100. For performance work on the front server that fronts these apps, our Apache and PHP-FPM tuning guide applies equally to DirectAdmin’s Apache build.

DirectAdmin Nginx Unit at a glance

DirectAdmin Nginx Unit summary card: Enable unit and redis in CustomBuild with da build set, build both and run rewrite_confs, then create the application… — In short: Enable unit and redis in CustomBuild with da build set, build both and run rewrite_confs, then create the application from the user’s Nginx Unit page in Evolution, pointing it at the app directory and entry file so DirectAdmin proxies the…

Official documentation: DirectAdmin documentation, Linux man pages.

Frequently asked questions

Does Nginx Unit on DirectAdmin work with LiteSpeed or OpenLiteSpeed as the front web server?

Yes. Unit sits behind whichever front server CustomBuild manages, and rewrite_confs writes the proxy rules for Apache, nginx, OpenLiteSpeed and LiteSpeed Enterprise alike, so the application deployment steps are the same.

How long does deploying a Node.js app on DirectAdmin take?

Installing Unit and Redis through CustomBuild takes a few minutes; a first deployment is usually ten to fifteen minutes including npm ci, and later updates are as quick as uploading the code and restarting the application from the panel.

Can I undo this?

Yes. Delete the application from the user’s Nginx Unit page, which removes the proxy rule at the next rewrite, and turn off the user’s Redis instance from the Redis page; to remove the components entirely set unit and redis to no in CustomBuild and rebuild.