Artifactory version 6.x to 7.x upgrade with Docker Compose

Before you proceed, see System Requirements for information on supported platforms, supported browsers, and other requirements.

Artifactory System Requirements

Artifactory system requirements depend mainly upon the expected amount of active clients.

Number of Active Clients	Processor	Memory
0-20	4 core CPU	6 GB
20-100	6 core CPU	12 GB
100-200	8 core CPU	18 GB
200+	Contact JFrog Support	Contact JFrog Support

Operating Systems and Platform Support

The following table lists the supported operating systems and their versions:

Product	Debian	RHEL	Ubuntu	Amazon Linux	Windows Server
Artifactory	11.x, 12.x	8.x, 9.x	20.04, 22.04, 24.04	Amazon Linux 2023	2016, 2019, 2022

Note

Debian 12.x and Ubuntu 24.04 are supported from Artifactory 7.104 and Distribution 2.28.

Windows 2022 is supported from Artifactory 7.125.

Supported Platforms

The following table lists the supported platforms:

Product	x86-64	ARM64	Kubernetes	OpenShift
Artifactory			1.27+	4.14+

Installation on Kubernetes environments is through Helm Charts. Supported Helm version is Helm 3+.

Kubernetes Sizing Requirements

We have included YAML files with different sizing configurations for Artifactory , Xray, and Distribution in our GitHub pages. You can use these YAML files when you set up your cluster.

ARM64 Support for Container-Based Installations

Artifactory, Xray and Distribution supports installation on ARM64 architecture specifically through Helm and Docker installations. When deploying a product on an ARM64 platform, an external database must be set up as Artifactory does not support the bundled database for ARM64 installations. The appropriate ARM64 Container Image is automatically pulled during the Helm or Docker installation process.

Artifactory Database Requirements

Artifactory supports the following databases:

PostgreSQL
Tip
JFrog highly recommends using PostgreSQL for all products in the JFrog Platform. For more information, see Choose the right database.
Oracle
MySQL
Microsoft SQL Server
MariaDB

Artifactory HA requires an external database, which is fundamental for the management of binaries and is also used to store cluster-wide configuration files.

Since Artifactory HA contains multiple Artifactory cluster nodes, your database must be powerful enough to service all the nodes in the system. Moreover, your database must be able to support the maximum number of connections possible from all the Artifactory cluster nodes in your system.

If you are replicating your database, you must ensure that at any given point in time, all nodes see a consistent view of the database, regardless of which specific database instance they access. Eventual consistency and write-behind database synchronization are not supported.

Artifactory Filestore

The filestore is where the binaries are physically stored.

Artifactory provides the following options to store binaries:

Local file system stores binaries with redundancy, using a binary provider that manages the synchronization of files between cluster nodes according to the defined redundancy settings.
Cloud storage is done using Amazon S3, Microsoft Azure, and Google Cloud Storage.
Network File System (NFS)

For more information, see Filestore Configuration.

Binary Storage

While Artifactory can use a Networked File System (NFS) for its binary storage, you should not install the application itself on an NFS. The Artifactory application needs very fast, reliable access to its configuration files. Any latency from an NFS will result in poor performance when the application fails to read these files. Therefore, install Artifactory on a local disk mounted directly to the host.

To use an NFS to store binaries, use the file-system binarystore.xml configuration with the additional <baseDataDir> setting.

Working with Very Large Storage

In most cases, our recommendation for storage is at least 3 times the total size of stored artifacts, in order to accommodate system backups.Backups

However, when working with a very large volume of artifacts, the recommendation may vary greatly according to the specific setup of your system. Therefore, when working with over 10 TB of stored artifacts, contact JFrog support, who will work with you to provide a recommendation for storage that is customized to your specific setup.

Allocated storage space may vary

Xray downloads and then deletes fetched artifacts after indexing. However, in order to have more parallel indexing processes, and thereby more temporary files at the same time would require more space.

This is especially applicable for large BLOBs such as Docker images.

Artifactory Network Ports

Artifactory uses external network ports to communicate with services outside Artifactory and internal network ports to communicate with Artifactory and other JFrog Platform microservices.

External Network Ports

Artifactory uses the following external network ports by default:

8081
8082

Internal Network Ports

Artifactory uses the following internal network ports.

Microservice	Port
Artifactory	HTTP: 8081, 8091
Frontend	HTTP: 8070
Access	HTTP: 8040, 8015 gRPC: 8045, 8016
Topology	HTTP: 8020 gRPC: 8021
One Model	HTTP: 8071 gRPC: 8072
Apollo Router	HTTP: 8074
Metadata	HTTP: 8086
Router	HTTP: 8082, 8046, 8049 gRPC: 8047
Observability	HTTP: 8036 gRPC: 8037
Event	HTTP:8061 gRPC: 8062
Mission Control	HTTP: 8080
JFConnect	HTTP: 8030 gRPC: 8035
JFConfig	HTTP: 8010
Evidence	HTTP: 8051
Artifactory Federation Service (RTFS)	HTTP: 8025 gRPC: 8026

In addition, review the Docker requirements.

Docker Requirements

For Docker and Docker Compose installations, JFrog services require Docker Engine 25.0 and above, and Docker Compose v2 to be installed on the machine where you want to run them.

For more information, see Docker and Docker Compose.

Stop and remove the current containers.

Upgrading from Docker run

docker stop artifactory
docker rm -f artifactory

Upgrading from Docker Compose previously available in Bintray

docker stop artifactory postgresql  nginx
docker rm -f artifactory postgresql  nginx

Extract the contents of the compressed archive and go to the extracted folder.
```
tar -xvf jfrog-artifactory-<pro|oss|cpp-ce>-<version>-compose.tar.gz
```
.env file included within the Docker-Compose archive
The .env file is used by docker-compose and is updated during installations and upgrades.
Some operating systems do not display dot files by default. If you make any changes to the file, remember to backup before an upgrade.
Run the config.sh script to setup folders with required ownership.
```
./config.sh
```
Check that the migration has completed successfully, by reviewing the following files:
1. migration log: $JFROG_HOME/artifactory/var/log/migration.log
2. system.yaml configuration: $JFROG_HOME/artifactory/var/etc/system.yaml. This newly created file will contain your current custom configurations in the new format.
3. Depending on your choices, a selected docker-compose.yaml will be available in the extracted folder. However, there are a few docker-compose templates in the directory templates.You can choose any template and copy it to the extracted folder as docker-compose.yaml .

Manage Artifactory using native Docker Compose commands.

docker-compose -p rt-postgres -f 
docker-compose-postgres-9-6-11v.yaml up -d
docker-compose -p rt up -d
docker-compose -p rt ps
docker-compose -p rt down

Access Artifactory from your browser at: http://SERVER_HOSTNAME:8082/ui/.
For example, on your local machine: http://localhost:8082/ui/
Reverse Proxy Settings
If you had a reverse proxy or load balancer configured with your Artifactory 6.x, you will need to create a new reverse proxy configuration and update your reverse proxy settings.
You can generate a new configuration template by accessing the upgraded Artifactory server UI (by default http://localhost:8082/ui/), navigate to
Navigate to Administration > Artifactory > General > HTTP Settings to adjust your Reverse Proxy Settings and generate a new configuration template. See Reverse Proxy Settings.HTTP Settings
Check Artifactory Log.
```
tail -f $JFROG_HOME/artifactory/var/log/console.log
```
Configure log rotation of the console log
The console.log file can grow quickly since all services write to it. For more information, see configure the log rotation.Configuring Log Rotation for Tomcat

Artifactory version 6.x to 7.x Docker Compose Upgrade Using Docker Volumes

Stop and remove the current Docker containers.

docker stop artifactory postgresql
docker rm -f artifactory postgresql

Extract the contents of the compressed archive and go to the extracted folder.
```
tar -xvf jfrog-artifactory-<pro|oss|cpp-ce>-<version>-compose.tar.gz
```
Copy the docker-compose-volumes.yaml file to the extracted folder.
```
cp templates/docker-compose-volumes.yaml docker-compose.yaml
```

Add the entry to the .env file.

echo -e "JF_SHARED_NODE_IP=$(hostname -i)" >> .env
echo -e "JF_SHARED_NODE_ID=$(hostname -s)" >> .env
echo -e "JF_SHARED_NODE_NAME=$(hostname -s)" >> .env

Avoid duplicating the entry in the .env file.

Remove the following env from the docker-compose.yaml file.
```
- JF_SHARED_DATABASE_TYPE=postgresql
- JF_SHARED_DATABASE_USERNAME=artifactory
- JF_SHARED_DATABASE_PASSWORD=password
- JF_SHARED_DATABASE_URL=jdbc:postgresql://postgresql:5432/artifactory
- JF_SHARED_DATABASE_DRIVER=org.postgresql.Driver
```
Migration starts from within the container and a new system.yaml aligning to the migrated data from Artifactory 6.x is created. To leverage this process, remove the env here to ensure that the old connection details are taken from system.yaml because the ENV supercedes the system.yaml entries. You can also choose to update these environment values to the old connection details for the upgrade to be successful.
Manage Artifactory using the native Docker Compose commands.
```
docker-compose -p rt up -d
docker-compose -p rt ps
docker-compose -p rt down
```
Run this command from the extracted folder.

Enable TLS 1.0 and 1.1 for connectivity with older databases

Artifactory version 7.25.5 onwards includes OpenJDK version 11.0.11 and later. TLS 1.0 and TLS 1.1 are disabled by default from OpenJDK 11.0.11 onwards. If your database version does not support TLS 1.2, the Artifactory startup fails.

If you are unable to upgrade your database to a version that supports TLS 1.2 or later, perform the following steps to run Artifactory:

Download the java.security file that has TLS 1.0 and 1.1 enabled.
Create the directory, ${JFROG_HOME}/artifactory/var/bootstrap/artifactory/java.
```
mkdir -p ${JFROG_HOME}/artifactory/var/bootstrap/artifactory/java
```
Copy the java.security file into ${JFROG_HOME}/artifactory/var/bootstrap/artifactory/java.
Provide the appropriate permissions to the directory.
```
chmod 755 ${JFROG_HOME}/artifactory/var/bootstrap/artifactory/java/java.security
```
Artifactory startup takes a backup of the existing java.security file and bootstraps custom java.security into the ${JFROG_HOME}/artifactory/app/third-party/java/conf/security folder.