Overview of Deploying Akaunting on Server¶

Prerequisites¶

• A fresh Ubuntu 22.04 (or newer) instance with a non‑root user that has sudo privileges.
• Public DNS record pointing to the server’s IP (used later for the domain name).
• Network ports 22, 80, and 443 opened on the firewall (the script uses UFW).
• Basic knowledge of terminal commands (git, sudo, docker, nginx).

The installation will automatically install all required packages, including Docker, PHP‑8.3, MySQL, Nginx, Certbot, and the required PHP extensions.

Installation Flow¶

The deployment is driven by a set of scripts that perform the following steps in order:

1. Clone the Akaunting repository into /opt/akaunting.
2. Create configuration files for the database (db.env) and the application runtime (run.env).
3. Set up directories for Docker data, Certbot storage, and Nginx configuration.
4. Start the Docker stack using docker‑compose up –detach.
5. Launch Nginx as a reverse proxy to forward HTTP/HTTPS traffic to the internal Docker container.
6. Obtain an SSL certificate from Let’s Encrypt using Certbot and configure Nginx for HTTPS.
7. Finalize environment variables to reflect the HTTPS URL and restart the Docker container.

The whole process can be executed with a single shell command that runs the main install.sh (or similar) script located in the root of the cloned repository.

Directory Layout¶

/opt/akaunting/
├── .git/                       # Git clone
├── docker-compose.yml          # Docker stack definition
├── env/
│   ├── db.env                  # MySQL connection details
│   └── run.env                 # Application environment variables
├── data/
│   └── certbot/
│       ├── conf/               # Certbot configuration
│       └── www/                # Webroot for ACME challenge
└── logs/                       # Docker log files (optional)

The script also creates:

• /etc/nginx/sites-available/akaunting – Nginx site configuration (temporary and final).
• /etc/nginx/sites-enabled/akaunting – Symlink to the enabled site.
• /etc/letsencrypt/live/<domain>/ – Let’s Encrypt certificates after successful issuance.

Permissions¶

The installation script runs as root or via sudo. Docker containers run as the www-data user internally, while Nginx runs as the system nginx user.

Database Setup¶

A MySQL server is installed and configured automatically. The db.env file defines:

MYSQL_DATABASE=akaunting
MYSQL_USER=admin
MYSQL_PASSWORD=<root password>
MYSQL_RANDOM_ROOT_PASSWORD=yes

During Docker stack startup, the akaunting-db service creates the database and user according to these values. The application connects to MySQL using the credentials in run.env.

Docker Container Startup¶

The Docker Compose file defines three primary services:

1. akaunting-db – MySQL 8.0 instance.
2. akaunting-app – PHP‑8.3 FPM serving the Akaunting application.
3. akaunting-nginx – (Optional internal Nginx, but not used because external Nginx proxies).

The command to bring the stack up is:

docker-compose up --detach

This pulls the latest images, builds the PHP container, and mounts the /opt/akaunting directory into the container. The container listens on localhost:8080, which is proxied by the external Nginx.

Proxy Server (Nginx)¶

Two Nginx configuration templates are used:

• nginx.conf.j2 – Temporary configuration that forwards HTTP requests to localhost:8080 and provides a webroot for Certbot challenge.
• nginx2.conf.j2 – Final configuration after SSL is obtained. It redirects all HTTP traffic to HTTPS and forwards HTTPS requests to the internal container.

During installation, the temporary config is used to run Certbot. After certificate issuance, the final config is applied and Nginx is reloaded.

SSL with Certbot¶

Certbot is installed via apt. The script runs:

certbot certonly --nginx -d <domain> --email <admin email> --agree-tos --non-interactive

The certificates are stored automatically at /etc/letsencrypt/live/<domain>/. They are referenced in the final Nginx config.

Launching the Application¶

After the installation completes, the user can access Akaunting at:

https://<your-domain>

The application is running inside the Docker container, behind the Nginx reverse proxy. Nginx handles TLS termination and passes requests to the internal PHP container.

Updating Akaunting¶

1. Pull the latest code:

cd /opt/akaunting
sudo git pull origin main

1. Restart Docker containers:

sudo docker-compose pull
sudo docker-compose up --detach

1. (Optional) Rebuild Docker images if a Dockerfile change is detected:

sudo docker-compose up --build --detach

1. Verify that the application is running by visiting the URL.

Updates to the Docker images are handled automatically when the docker-compose pull command is executed.

Reinstalling Akaunting¶

If a fresh install is required:

1. Remove the old installation:

sudo systemctl stop nginx
sudo docker-compose down
sudo rm -rf /opt/akaunting

1. Run the installation script again (the same script used originally). It will recreate all directories, download dependencies, and start the stack from scratch.

Reinstallation clears all configuration files and data; use only if a clean state is needed.

Logging and Monitoring¶

• Docker logs can be viewed with:

sudo docker logs akaunting-app

• Nginx logs are located at /var/log/nginx/.
• Certbot renewal logs are under /var/log/letsencrypt/.

The script configures automatic renewal of SSL certificates via a cron job created by Certbot during the installation.