Artifactory gives your teams one home for every package, container image and Helm chart. This guide installs the open source edition on Ubuntu with a real PostgreSQL database behind it, and every command was built and run on Ubuntu 26.04 LTS and 24.04 LTS in November 2026.
Two things changed since most tutorials were written: the installer no longer ships with an embedded database, and the old Bintray repositories are gone. You’ll cover both gaps here, walk through the first-run wizard with screenshots, and finish with a tested Docker alternative if you’d rather skip the package.
What you need before you start
Artifactory is a JVM application, so its working set lives in RAM. The idle service sat at 4.2 GB resident on this lab’s 4 vCPU and 16 GB virtual machine with default heap settings. Treat 2 vCPU and 8 GB as the floor for a test box, because the JVM won’t run comfortably under that.
Plan 4 vCPU and 16 GB for a small production node. That floor is where installs fail in practice: the idle service already held 4.2 GB resident on this lab’s 16 GB VM with an empty repository, and PostgreSQL adds its own footprint on top. Metadata grows with every project you onboard, so give the disk the same headroom you give the RAM, because a full filestore takes the whole service down with it.
Each item below was true on both lab machines, so treat them as your starting checklist rather than hard limits. Anything you already have in place, you can skip.
- Run a sudo user on Ubuntu 26.04 LTS or 24.04 LTS, the two releases every command here was verified on
- Install PostgreSQL on the same host, or point at a server reachable over the network; the next section covers the local install
- Keep at least 10 GB of free disk for the packages and the database before you upload a single artifact
- Prepare a DNS name and open port 8082, if you plan to serve the web UI beyond localhost
Install PostgreSQL first
Start with the database, because Artifactory refuses to boot without one. JFrog removed the embedded Derby database from the distribution back in the 7.84.3 release, and the package installer says so itself in its closing note. Skip this step and you’ll watch the service start, fill the log with a DbTypeNotAllowedException, and stop.
Install PostgreSQL, then create the user and schema that Artifactory will use. Pick a strong password and keep it handy, because you’ll type it into the configuration file in a minute. A password manager or a scratch note works; losing it means dropping the database and starting over.
Use your own password in every block below, because the three places that hold it must match. One more caveat: Ubuntu’s newest release ships a PostgreSQL version JFrog has not added to its support matrix yet, and this lab ran fine on it, but a production install should pin the newest release JFrog’s PostgreSQL documentation lists.
sudo apt-get update sudo apt-get install -y postgresql
The second command creates the user and the database in one pass through psql, and the two options on the database line matter. OWNER=artifactory gives your service account full rights without superuser, which is what the schema migration expects, and UTF8 keeps collation predictable for metadata with unusual names. If you prefer separate statements, run them one after the other; the result is the same.
sudo -u postgres psql -c "CREATE USER artifactory WITH PASSWORD 'ArtPass_5037';" -c "CREATE DATABASE artifactory WITH OWNER=artifactory ENCODING='UTF8';"
The capture below shows both commands as they ran on the lab’s 26.04 node, with the CREATE lines returning clean.

If PostgreSQL is new to you, our guide on installing and configuring PostgreSQL on Ubuntu covers users, authentication and remote access in more depth. Nothing later in this guide needs anything beyond the two commands above.
Add the JFrog APT repository
Artifactory publishes its Debian packages in one rolling repository, so the same lines serve every Ubuntu release. Import the signing key in dearmored form, which replaces the deprecated apt-key command that older tutorials still show.
echo "deb https://releases.jfrog.io/artifactory/artifactory-debs xenial main" | sudo tee /etc/apt/sources.list.d/artifactory.list curl -fsSL https://releases.jfrog.io/artifactory/api/gpg/key/public | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/artifactory.gpg sudo apt-get update
That xenial component looks odd on a current release, but JFrog keeps publishing every new build under that label, so the same line is correct on 26.04 and 24.04 alike. The refresh pulls only a few hundred kB of package lists from releases.jfrog.io. After it finishes, apt-cache policy jfrog-artifactory-oss shows the candidate version.
Install the Artifactory package
The package is large: about 1.8 GB of download and over 2 GB unpacked, so plan the disk before you start. It pulls in net-tools as a dependency, so current apt lists matter.
The install lays everything under /opt/jfrog/artifactory, registers artifactory.service as enabled, and bundles its own Temurin runtime, so you don’t need a JDK.
sudo apt-get install -y jfrog-artifactory-oss
The tail of the lab’s install output is below, and it is worth reading rather than scrolling past.

Read the installer’s closing note before you move on, because it names PostgreSQL as the supported database and links to JFrog’s PostgreSQL for Artifactory documentation for the full matrix.
Note the service state too: registered as enabled, but deliberately left stopped. That pause is your cue to wire up the database before the first boot.
Point Artifactory at PostgreSQL
Database settings live in /opt/jfrog/artifactory/var/etc/system.yaml, a file that does not exist until you create it. Build it with the values from the PostgreSQL step, then fix ownership. The file must belong to the artifactory user with mode 640, or the service cannot read it.
sudo printf '%s\n' 'configVersion: 1' 'shared:' ' database:' ' type: postgresql' ' driver: org.postgresql.Driver' ' url: "jdbc:postgresql://localhost:5432/artifactory"' ' username: artifactory' ' password: "ArtPass_5037"' | sudo tee /opt/jfrog/artifactory/var/etc/system.yaml > /dev/null sudo chown artifactory:artifactory /opt/jfrog/artifactory/var/etc/system.yaml sudo chmod 640 /opt/jfrog/artifactory/var/etc/system.yaml
Start the service and give it time, because first boot creates the schema, runs migrations and warms the JVM. On both lab machines that took between one and two minutes.
Watch the status until it reports active, then confirm the web endpoint answers. A status that flips back to activating usually means the database is still unreachable.
sudo systemctl start artifactory.service systemctl status artifactory.service --no-pager curl -sI http://localhost:8082/ui/ | head -3
The status block from the lab is below, captured once startup had finished on the 26.04 node.

The status block above comes from the 26.04 lab node: the main PID runs the bundled Java runtime at 4.2 GB resident. A first boot that stops again almost always means a database problem, and /opt/jfrog/artifactory/var/log/artifactory-service.log names the cause in plain text.
One detail worth knowing: on first start Artifactory rewrites the password line in system.yaml into an encrypted form, so do not be surprised when the plaintext value you typed is gone from the file. That is intended behavior, not corruption. Later database changes go through the same file with a fresh value.
Finish onboarding in the browser
Point a browser at http://10.0.1.50:8082/ui/ with your server’s address in place of the example IP, then sign in with the defaults: admin as the username, password as the password. A welcome screen opens, and the Get Started button moves you into the setup steps.

The wizard walks through four settings in this order:
- Set a new admin password in the New Password and Retype Password fields, which retires the well-known default credentials immediately
- Set the base URL to the address your users will actually type
- Configure a default proxy, a step most installs skip without consequence
- Create the starter repositories, then review the summary screen before finishing

- 1New Password
- 2Retype Password
- 3Next
For the base URL, use the address your users will type rather than the local interface name. Leave it empty if you’re not sure yet, because the setting lives under the administration UI later and the wizard doesn’t force a value.
Getting it wrong costs nothing at this stage. You can correct it once users start hitting the wrong links.

- 1Base URL
- 2Next
The remaining steps create starter repositories and show a summary before the dashboard opens. If a step refuses to advance in your browser, use Skip. Every one of these settings is editable afterwards from the administration UI, so nothing is lost by deferring it.
Two login quirks cost time if you don’t expect them. Repeated failed sign-ins trigger a block where the page reports “This request is blocked due to recurrent request failures” with a countdown, and the only fix is waiting it out before trying again.
Expect the welcome screen to greet you again after a later login, because that is normal behavior in the current build. It clears once you walk through or skip the remaining steps. The wizard also reopens if you close the tab mid-setup, and the steps you already finished stay finished. Neither quirk affects the install itself, and there is nothing to fix, so treat both as cosmetic.
Run Artifactory in Docker instead
The package install isn’t the only route. JFrog publishes an official image at releases-docker.jfrog.io/jfrog/artifactory-oss, and it behaves like the deb install once it can reach a PostgreSQL server. Note the registry name, because the docker.bintray.io paths that older tutorials use no longer resolve.
You need Docker CE installed, which our Docker CE on Ubuntu guide covers, plus PostgreSQL reachable from the Docker bridge network, because the image ships without a database. The host’s PostgreSQL needs four small changes:
- Set PostgreSQL to listen on the Docker bridge instead of localhost only
- Allow the artifactory user in from the bridge subnet with a pg_hba.conf rule
- Create a separate database for the container, never the one the deb install uses
- Restart PostgreSQL so the listener and access changes take effect
sudo sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/" /etc/postgresql/*/main/postgresql.conf echo "host all artifactory 172.17.0.0/16 scram-sha-256" | sudo tee -a /etc/postgresql/*/main/pg_hba.conf sudo -u postgres psql -c "CREATE DATABASE artifactory2 WITH OWNER=artifactory ENCODING='UTF8';" sudo systemctl restart postgresql
Two details in that block matter. The pg_hba rule grants the artifactory user every database from the bridge subnet, because a rule scoped to a single database name leaves the container failing with a no pg_hba.conf entry error at boot.
Watch the firewall here. listen_addresses on a star exposes port 5432 on every interface, so a server without a cloud firewall or ufw rule would publish your database to the internet. Restrict 5432 to the Docker subnet and your own management IPs before the container’s first run.
The separate database matters just as much, and the block creates artifactory2 for exactly that reason. Two Artifactory instances pointed at one schema fight over it during startup, and neither wins cleanly. Give each stack its own schema and both stay healthy.
Settings for the container live in a system.yaml inside the mounted data directory. Use 172.17.0.1 as the database host, because that’s the Docker bridge gateway the container reaches PostgreSQL through.
UID 1030 is the artifactory user inside the image, and it needs write access to the whole tree. Skipping the chown leaves the container writing logs it cannot read back.
sudo mkdir -p /srv/jfrog/var/etc sudo printf '%s\n' 'configVersion: 1' 'shared:' ' database:' ' type: postgresql' ' driver: org.postgresql.Driver' ' url: "jdbc:postgresql://172.17.0.1:5432/artifactory2"' ' username: artifactory' ' password: "ArtPass_5037"' | sudo tee /srv/jfrog/var/etc/system.yaml > /dev/null sudo chown -R 1030:1030 /srv/jfrog/var
Then run the container with the command below. The published ports are the repository API on 8081 and the router with the web UI on 8082.
The restart policy brings the stack back after a host reboot without any unit file of your own. It also restarts the container if the JVM dies, which saves you a 3 a.m. login.
sudo docker run --name artifactory -d \ --restart unless-stopped \ -p 8081:8081 -p 8082:8082 \ -v /srv/jfrog/var:/var/opt/jfrog/artifactory \ -e EXTRA_JAVA_OPTIONS='-Xms512m -Xmx2g' \ releases-docker.jfrog.io/jfrog/artifactory-oss:latest
The capture below shows the container up and the UI answering on the lab.

Initialization took about a minute on the lab once the schema existed, and the log line “service initialization completed” marks the moment the UI is safe to open. Watch for it in docker logs artifactory rather than guessing.
The EXTRA_JAVA_OPTIONS line sets the same 512 MB to 2 GB heap the package install shipped with on the lab. A larger heap is fine as long as you pair it with more host RAM rather than swapping.
If you’re migrating from the package install onto Docker, stop and disable artifactory.service before the first run. Both stacks want ports 8081 and 8082, so the container crash-loops against the running service until they’re free. Disabling rather than stopping keeps it from grabbing the ports again at boot. Recovery once you see the loop is simple: stop the container, free the ports, and run the same command again.
Quick reference
| Item | Where |
|---|---|
| Service | artifactory.service, start with systemctl |
| Install root | /opt/jfrog/artifactory |
| Main config | /opt/jfrog/artifactory/var/etc/system.yaml |
| Logs | /opt/jfrog/artifactory/var/log/ |
| Web UI | Port 8082 at /ui/ |
| Repository API | Port 8081 at /artifactory |
| Docker data | /srv/jfrog/var on the host, UID 1030 |
From here, put Artifactory behind Nginx with TLS for a proper endpoint, or move to running Artifactory on Kubernetes once a single node stops being enough.