How To Install JFrog Artifactory on Linux Mint 22

JFrog Artifactory stands as one of the most powerful universal artifact repository managers in the modern DevOps landscape. Whether you’re managing Docker containers, Maven artifacts, npm packages, or any binary files, Artifactory provides a centralized solution for storing, organizing, and distributing your software artifacts throughout your development lifecycle. This comprehensive guide walks you through installing JFrog Artifactory on Linux Mint 22, the latest release based on Ubuntu 24.04 LTS, ensuring you have a robust artifact management system up and running in your development environment.

Linux Mint 22 provides an excellent foundation for hosting Artifactory thanks to its stability, Ubuntu compatibility, and extensive package support. By the end of this tutorial, you’ll have a fully functional Artifactory instance configured with PostgreSQL database backend, accessible through your web browser, and ready to integrate with your CI/CD pipelines.

What is JFrog Artifactory?

JFrog Artifactory is a universal DevOps solution designed for hosting, managing, and distributing binaries and artifacts across your entire software development factory. The name itself reflects its core purpose—serving as a repository for any type of “artifact” needed in your software development processes. In the DevOps world, an artifact represents any object produced during software development and delivery, including application installers, container images, libraries, configuration files, and deployment packages.

Artifactory supports over 30 different package types, making it truly universal. From Maven and Gradle for Java projects to npm for JavaScript, PyPI for Python, Docker for containers, and Helm for Kubernetes—Artifactory handles them all seamlessly. This versatility makes it the central hub for your DevOps processes, where all dependencies, packages, and artifacts ultimately get stored and retrieved.

The platform comes in three main editions: Artifactory OSS (Open Source Software), Artifactory Pro, and Artifactory C++ CE (Community Edition). OSS provides basic functionality suitable for small teams and individual developers. Pro includes enterprise features like high availability, advanced security scanning, multi-site replication, and support for all package types. C++ CE focuses specifically on C++ development with Conan package management.

System Requirements for JFrog Artifactory on Linux Mint 22

Minimum Hardware Requirements

Before installing Artifactory, ensure your Linux Mint 22 system meets the necessary hardware specifications. For evaluation and small team usage, you’ll need at minimum 4 CPU cores, 8 GB of RAM, and 100 GB of SSD storage. However, production environments demand significantly more resources—8 or more CPU cores, 16-32 GB of RAM, and at least 500 GB of high-performance SSD storage.

Enterprise deployments or high-availability setups should provision 16-32 CPU cores, 32-64 GB RAM, and 1 TB or more of NVMe storage for optimal performance. Storage requirements scale with your artifact repository size, so plan accordingly based on your expected artifact volume. Network connectivity should support at least 1 Gbps throughput to handle concurrent artifact uploads and downloads efficiently.

Software Requirements

Linux Mint 22, being based on Ubuntu 24.04 LTS, provides an ideal operating system foundation for Artifactory. Java runtime is essential since Artifactory is a Java-based application. You’ll need OpenJDK 11 or OpenJDK 17, though Artifactory packages typically bundle the required Java version.

For production deployments, an external database is mandatory. JFrog strongly recommends PostgreSQL 12 or higher for optimal performance and reliability. MySQL 8.0+ and MariaDB 10.3+ are also supported, but PostgreSQL remains the preferred choice. You’ll need root or sudo privileges on your system, an active internet connection for downloading packages, and a modern web browser (Firefox, Chrome, or Edge) for accessing the Artifactory UI.

Prerequisites Before Installation

Start by ensuring your Linux Mint 22 system is fully updated. System updates provide the latest security patches and ensure package compatibility. Open your terminal and update the package repositories to get the most recent package information. You should also verify you have sufficient disk space available—check this using the df -h command to display disk usage in human-readable format.

Confirm your system architecture is x86-64, as Artifactory requires 64-bit systems. Run uname -m to verify your architecture returns “x86_64”. If you have firewall enabled, you’ll need to configure it later to allow traffic on ports 8081 and 8082, which Artifactory uses for its application and web interface.

Consider your network configuration as well. If you plan to access Artifactory from other machines, ensure your server has a static IP address or a properly configured hostname. This simplifies remote access and integration with CI/CD tools later.

Step 1: Update Linux Mint 22 System

Begin the installation process by updating your Linux Mint 22 system to ensure all packages are current. Open your terminal application and execute the update commands with sudo privileges. First, refresh your package repository metadata to get the latest package versions available.

sudo apt update

This command downloads package information from all configured repositories. Next, upgrade all installed packages to their newest versions:

sudo apt upgrade -y

The -y flag automatically confirms the upgrade without prompting, streamlining the process. After upgrading, remove any obsolete packages that are no longer required:

sudo apt autoremove -y

This cleanup step frees disk space by removing old kernel versions and unused dependencies. If kernel updates were installed, consider rebooting your system to ensure you’re running the latest kernel version. A simple sudo reboot command handles this, though it’s not always necessary for Artifactory installation.

Step 2: Install Java OpenJDK

Artifactory requires Java to run since it’s built on Java technologies. Linux Mint 22 makes installing OpenJDK straightforward through the APT package manager. Install both the Java Runtime Environment (JRE) and Java Development Kit (JDK) along with required font configurations:

sudo apt install fontconfig openjdk-17-jre openjdk-17-jdk -y

OpenJDK 17 is the recommended version for modern Artifactory releases and provides long-term support. The fontconfig package ensures proper font rendering in Java applications. Installation takes a few minutes depending on your internet connection speed.

After installation completes, verify Java is properly installed and accessible:

java --version

This command displays the installed Java version, which should show OpenJDK 17.x.x. Also verify the Java compiler:

javac --version

Both commands should return version information confirming successful installation. The Java binaries are automatically added to your system PATH, making them available system-wide without additional configuration.

Step 3: Install and Configure PostgreSQL Database

Install PostgreSQL

Artifactory requires an external database for production use to store configuration, metadata, and artifact information. PostgreSQL is the recommended database system for its performance, reliability, and full support from JFrog. Install PostgreSQL and its contributed extensions:

sudo apt install postgresql postgresql-contrib -y

Linux Mint 22 repositories typically include PostgreSQL 14 or 15, both of which work excellently with Artifactory. After installation, start the PostgreSQL service:

sudo systemctl start postgresql

Enable PostgreSQL to start automatically on system boot:

sudo systemctl enable postgresql

Verify the PostgreSQL service is running correctly:

sudo systemctl status postgresql

You should see “active (running)” status in green, indicating PostgreSQL is operational. The service listens on localhost port 5432 by default, which is perfect for local Artifactory connections.

Create Artifactory Database and User

PostgreSQL requires dedicated database and user credentials for Artifactory. Switch to the PostgreSQL system user to access the database console:

sudo -u postgres psql

This opens the PostgreSQL command-line interface. Create a dedicated database for Artifactory:

CREATE DATABASE artifactory_db;

Next, create a dedicated user with a secure password. Replace your_secure_password with a strong password of your choice:

CREATE USER artifactory_user WITH ENCRYPTED PASSWORD 'your_secure_password';

Grant all necessary privileges on the Artifactory database to this user:

GRANT ALL PRIVILEGES ON DATABASE artifactory_db TO artifactory_user;

Exit the PostgreSQL console:

\q

Store your database credentials securely as you’ll need them when configuring Artifactory. Consider using a password manager for secure credential storage. For enhanced security in production environments, configure PostgreSQL to require SSL connections and restrict access to specific IP addresses through the pg_hba.conf configuration file.

Step 4: Add JFrog Artifactory Repository

Rather than manually downloading Artifactory packages, configuring the official JFrog APT repository enables easy installation and future updates. First, download and add the JFrog public GPG key to verify package authenticity:

wget -qO - https://releases.jfrog.io/artifactory/api/gpg/key/public | sudo apt-key add -

You should see “OK” as output, confirming the key was added successfully. GPG keys ensure packages you download are authentic and haven’t been tampered with, providing crucial security for your system.

Determine your distribution codename, which Linux Mint uses to align with Ubuntu repositories:

DISTRO=$(lsb_release -cs)

Add the JFrog Artifactory repository to your system’s software sources:

echo "deb https://releases.jfrog.io/artifactory/artifactory-debs ${DISTRO} main" | sudo tee -a /etc/apt/sources.list.d/artifactory.list

This command creates a new repository configuration file specifically for Artifactory, keeping it separate from your main sources list. Update your package cache to include packages from the newly added repository:

sudo apt update

Your system can now access and install Artifactory packages directly from JFrog’s official repository, ensuring you always have access to the latest stable releases.

Step 5: Install JFrog Artifactory

With the repository configured, installing Artifactory becomes a single command operation. For the open-source version, execute:

sudo apt install jfrog-artifactory-cpp-ce -y

Alternatively, for the OSS version:

sudo apt install jfrog-artifactory-oss -y

Or for the Pro version if you have a license:

sudo apt install jfrog-artifactory-pro -y

The C++ CE (Community Edition) is free and suitable for most development needs. Installation takes several minutes as the package manager downloads and configures all necessary components. The installer automatically creates an artifactory system user and group for running the service securely.

Artifactory installs to /opt/jfrog/artifactory by default. This directory structure includes:

• /opt/jfrog/artifactory/app – Application binaries and libraries
• /opt/jfrog/artifactory/var – Data, logs, and configuration files
• /opt/jfrog/artifactory/var/etc – Configuration directory
• /opt/jfrog/artifactory/var/log – Log files

The installation process sets appropriate ownership and permissions automatically, ensuring the artifactory user can read and write necessary files.

Step 6: Configure Artifactory Database Connection

Before starting Artifactory, configure it to use your PostgreSQL database. Navigate to the Artifactory configuration directory and edit the system.yaml file:

sudo nano /opt/jfrog/artifactory/var/etc/system.yaml

If the file doesn’t exist, create it. Add or modify the database configuration section:

shared:
  database:
    type: postgresql
    driver: org.postgresql.Driver
    url: jdbc:postgresql://localhost:5432/artifactory_db
    username: artifactory_user
    password: your_secure_password

Replace your_secure_password with the actual password you set when creating the PostgreSQL user. The JDBC URL format specifies PostgreSQL protocol, localhost connection, port 5432 (PostgreSQL default), and your database name.

Save the file (Ctrl+O, Enter, then Ctrl+X in nano). The system.yaml file uses YAML format, so ensure proper indentation with spaces (not tabs). Incorrect indentation causes configuration parsing errors that prevent Artifactory from starting.

For enhanced security, restrict file permissions so only the artifactory user can read the file containing database credentials:

sudo chmod 600 /opt/jfrog/artifactory/var/etc/system.yaml
sudo chown artifactory:artifactory /opt/jfrog/artifactory/var/etc/system.yaml

Step 7: Configure Firewall Rules

If you have UFW (Uncomplicated Firewall) enabled on Linux Mint 22, configure it to allow incoming connections to Artifactory. Artifactory uses port 8082 for its web interface and API access, and port 8081 for direct Tomcat access:

sudo ufw allow 8082/tcp
sudo ufw allow 8081/tcp

Reload the firewall to apply changes:

sudo ufw reload

Verify the rules were added successfully:

sudo ufw status

You should see entries allowing TCP traffic on ports 8081 and 8082. For production environments, consider restricting access to specific IP addresses or subnets:

sudo ufw allow from 192.168.1.0/24 to any port 8082

This example allows access only from the 192.168.1.0/24 network range. Adjust the IP range according to your network configuration.

Step 8: Start and Enable Artifactory Service

With configuration complete, start the Artifactory service for the first time:

sudo systemctl start artifactory.service

Enable Artifactory to start automatically when your system boots:

sudo systemctl enable artifactory.service

Initial startup takes 2-5 minutes as Artifactory performs first-time setup, including database schema creation and service initialization. Check the service status:

sudo systemctl status artifactory.service

You should see “active (running)” status. Monitor the startup process in real-time by following the console log:

sudo tail -f /opt/jfrog/artifactory/var/log/console.log

Watch for the success message indicating all services started successfully:

### All services started successfully in XX seconds ###

This message confirms Artifactory is fully operational and ready to accept connections. Press Ctrl+C to exit the log viewer.

Step 9: Verify Installation and Port Status

Confirm Artifactory is listening on the correct ports using the ss (socket statistics) command:

sudo ss -tulnp | grep 8082

This shows processes listening on port 8082. You should see the Java process bound to this port. Similarly check port 8081:

sudo ss -tulnp | grep 8081

Test the Artifactory API endpoint locally using curl:

curl http://localhost:8082/artifactory/api/system/ping

A successful response returns “OK”, confirming the Artifactory API is responding correctly. You can also check the version endpoint:

curl http://localhost:8082/artifactory/api/system/version

This returns JSON with version information, confirming your Artifactory installation is accessible via HTTP.

Step 10: Access Artifactory Web Interface

Open your web browser and navigate to Artifactory’s web interface:

http://localhost:8082

For remote access, replace localhost with your server’s IP address:

http://your-server-ip:8082

The Artifactory welcome page loads, presenting a modern, clean interface. Click the “Get Started” button to proceed to the login screen. Use the default administrator credentials:

• Username: admin
• Password: password

These default credentials work for initial access but must be changed immediately for security. The first login triggers the initial setup wizard, guiding you through essential configuration steps. The interface may take a moment to fully load on first access as Artifactory initializes web components.

Step 11: Complete Initial Setup Wizard

Change Default Admin Password

The setup wizard immediately prompts you to change the default administrator password. This critical security step prevents unauthorized access to your Artifactory instance. Choose a strong password with at least 12 characters, including uppercase, lowercase, numbers, and special characters. Store this password securely in a password manager.

Set Base URL

Configure the base URL for your Artifactory instance. This URL is used for external integrations and artifact references. Enter:

http://your-domain-or-ip:8082/artifactory

Replace your-domain-or-ip with your actual hostname or IP address. The base URL ensures generated artifact URLs are correct for CI/CD integrations and remote access.

Configure Proxy Settings (Optional)

If your network requires a proxy for internet access, configure proxy settings in this step. Enter your proxy host, port, and authentication credentials if required. For most local installations, skip this step by clicking “Next” or “Skip”.

Create First Repository

The wizard offers to create your first repository. You can skip this step and create repositories manually later, or choose a repository type now based on your immediate needs. Common choices include Maven for Java projects, npm for Node.js, Docker for containers, or Generic for any file type.

Click “Finish” to complete the wizard. Artifactory displays the main dashboard, indicating successful setup completion.

Step 12: Create Your First Repository

Understanding Artifactory repository types is essential for effective artifact management. Local repositories store artifacts your team builds and publishes. Remote repositories cache artifacts from external sources like Maven Central or npm registry, improving build performance and reliability. Virtual repositories aggregate multiple repositories (local and remote) behind a single URL, simplifying configuration.

To create a repository, navigate to Administration → Repositories → Local in the left sidebar. Click the “New Local Repository” button. A repository selection screen displays various package types including Maven, Gradle, npm, Docker, PyPI, NuGet, and Generic.

Select Generic for a universal repository accepting any file type, perfect for learning and testing. Enter a repository key (name) like generic-local. This key becomes part of artifact URLs, so use lowercase letters, numbers, and hyphens only. Configure additional settings:

• Repository Layout: default
• Includes Pattern: ** (double asterisk – matches all files)
• Excludes Pattern: Leave empty

Click “Save & Finish”. Your first repository is now created and ready to receive artifacts. You can upload files directly through the web interface or programmatically via REST API or JFrog CLI.

Step 13: Configure User Access and Permissions

Navigate to Administration → Identity and Access → Users to manage user accounts. Click “New User” to create additional users beyond the admin account. Enter username, email address, and password for the new user. Assign the user to appropriate groups for role-based access control.

For team collaboration, create user groups under Administration → Identity and Access → Groups. Groups simplify permission management by allowing you to assign permissions to groups rather than individual users. Create groups like developers, devops, or release-managers based on your organizational structure.

Configure repository permissions under Administration → Identity and Access → Permissions. Create a permission target that specifies which repositories a group or user can access and what operations they can perform (read, write, deploy, delete, annotate). For example, give developers read and deploy permissions on local repositories while restricting delete operations to administrators only.

Best practices include using groups rather than individual user permissions, following the principle of least privilege (granting only necessary permissions), regularly reviewing and auditing permissions, and documenting your permission structure for team reference.

Step 14: Install JFrog CLI (Optional)

The JFrog CLI provides powerful command-line capabilities for interacting with Artifactory. Install it by downloading the installer script:

curl -fL https://getcli.jfrog.io | sh

This downloads and installs the latest JFrog CLI version. Move the binary to a directory in your PATH:

sudo mv jfrog /usr/local/bin/

Verify installation:

jfrog --version

Configure the CLI to connect to your Artifactory instance:

jfrog config add my-artifactory

The CLI prompts for your Artifactory URL (http://your-server:8082/artifactory), username, and password. Test the connection:

jfrog rt ping

A successful response confirms CLI connectivity. Use JFrog CLI for uploading artifacts, downloading dependencies, searching repositories, and automating deployment workflows. The CLI integrates seamlessly with CI/CD scripts, providing programmatic access to all Artifactory functionality.

Troubleshooting Common Issues

Artifactory Won’t Start

If Artifactory fails to start, check the logs for error messages:

sudo journalctl -u artifactory.service -n 50
sudo tail -n 100 /opt/jfrog/artifactory/var/log/console.log

Common causes include database connection failures (verify credentials in system.yaml), insufficient memory (increase JVM heap size), port conflicts (another service using 8081 or 8082), or Java version mismatches. Ensure PostgreSQL is running before starting Artifactory.

Cannot Access Web Interface

If you can’t reach the web interface, verify Artifactory is running (sudo systemctl status artifactory.service). Check firewall rules allow incoming connections on port 8082. Try accessing from localhost first using curl http://localhost:8082 to isolate network issues. Clear browser cache if the page loads incorrectly. Wait 2-5 minutes after starting Artifactory before attempting access, as initialization takes time.

Database Connection Errors

Database connectivity issues prevent Artifactory from starting. Verify PostgreSQL is running (sudo systemctl status postgresql). Test database connectivity manually:

psql -h localhost -U artifactory_user -d artifactory_db

Enter your database password when prompted. If connection fails, check PostgreSQL authentication settings in /etc/postgresql/*/main/pg_hba.conf. Ensure the connection method allows password authentication for local connections. Verify database credentials in system.yaml match those created in PostgreSQL exactly, including case sensitivity.

Performance Optimization Tips

Adjust JVM heap size based on your available RAM and expected load. Edit /opt/jfrog/artifactory/var/etc/system.yaml and add JVM settings:

shared:
  javaOpts:
    xms: "2g"
    xmx: "4g"

This allocates 2GB initial heap and 4GB maximum heap. For systems with 16GB+ RAM, allocate 6-8GB maximum heap for optimal performance. Restart Artifactory after configuration changes.

Configure binary storage provider for large artifact volumes. By default, Artifactory uses filesystem storage, but object storage backends (S3, Azure Blob, Google Cloud Storage) provide better scalability for enterprise deployments. Database tuning improves performance—increase PostgreSQL shared_buffers and effective_cache_size settings based on available memory.

Monitor resource usage regularly using system monitoring tools. Check CPU, memory, disk I/O, and network usage to identify bottlenecks. Implement regular maintenance tasks including cleaning up unused artifacts, garbage collection for binary storage, and periodic database vacuum operations to maintain optimal performance.

Security Best Practices

Immediately change the default admin password upon installation—this cannot be overemphasized. Enable HTTPS with SSL/TLS certificates for encrypted communication. Generate SSL certificates using Let’s Encrypt for public-facing installations or use self-signed certificates for internal deployments. Configure a reverse proxy (nginx or Apache) to handle SSL termination and provide additional security layers.

Integrate with enterprise authentication systems like LDAP, Active Directory, SAML, or OAuth for centralized user management. This eliminates password management overhead and improves security through single sign-on. Configure two-factor authentication for administrator accounts.

Enable audit logging to track all user activities, artifact uploads/downloads, and configuration changes. Regularly review audit logs for suspicious activities. Implement regular backup schedules—backup both the Artifactory filestore (/opt/jfrog/artifactory/var) and PostgreSQL database daily. Test backup restoration procedures periodically to ensure recovery capability.

Keep Artifactory updated to the latest stable version to receive security patches and bug fixes. Subscribe to JFrog security advisories for notification of critical updates. Restrict network access using firewall rules allowing only necessary connections. Implement API keys rather than passwords for programmatic access and CI/CD integrations.

Integrating with CI/CD Tools

Artifactory integrates seamlessly with popular CI/CD platforms. For Jenkins, install the JFrog plugin from the Jenkins plugin manager. Configure Artifactory server details in Jenkins global configuration, then use build steps to publish artifacts to Artifactory and resolve dependencies from it.

GitLab CI integration uses the JFrog CLI in pipeline scripts. Add CLI commands to your .gitlab-ci.yml file for uploading build artifacts:

deploy:
  script:
    - jfrog rt upload target/*.jar generic-local/myapp/

GitHub Actions uses the JFrog setup action for authentication and artifact management. Maven and Gradle projects configure Artifactory as a repository source in settings.xml or build.gradle, enabling dependency resolution and artifact deployment directly from build tools.

Docker registry functionality allows pushing and pulling container images. Configure Docker daemon to authenticate with Artifactory’s Docker registry at your-server:8082/artifactory-docker. Official JFrog documentation provides detailed integration guides for specific tools and platforms.

Maintenance and Backup

Establish regular backup procedures for business continuity. Stop Artifactory before backing up to ensure data consistency:

sudo systemctl stop artifactory.service

Backup the Artifactory data directory:

sudo tar -czf artifactory-backup-$(date +%Y%m%d).tar.gz /opt/jfrog/artifactory/var

Backup the PostgreSQL database separately:

sudo -u postgres pg_dump artifactory_db > artifactory-db-backup-$(date +%Y%m%d).sql

Store backups on separate storage systems or cloud storage for disaster recovery. Start Artifactory after backup completes:

sudo systemctl start artifactory.service

Schedule maintenance windows for system updates and Artifactory upgrades. Update Artifactory using the package manager:

sudo apt update
sudo apt upgrade jfrog-artifactory-cpp-ce

Monitor system health through the Artifactory UI under Administration → System Info. Review logs regularly for errors or warnings indicating potential issues. Clean up old artifacts periodically to manage storage usage effectively.

Congratulations! You have successfully installed JFrog. Thanks for using this tutorial to install the latest version of the JFrog open-source platform for software artifact management on Linux Mint 22 system. For additional help or useful information, we recommend you check the official JFrog website.