---
updatedAt: 2026-10-22T07:04:26.000Z
agentTools:
  siteIndex: https://docs.jfrog.com/llms.txt
  projectIndex: https://docs.jfrog.com/installation/llms.txt
---

# Platform Installation with Helm Charts

Install and configure JFrog Platform Helm chart: licenses, enable products, configure external PostgreSQL database.

This page covers post-install configuration for the JFrog Platform Helm chart. If you have not yet installed, start with the [Helm Quick Start](install-jfrog-platform-via-helm-quick-start).

For license requirements by product combination, see the [License Matrix](license-matrix-pro-x-enterprise-x-enterprise).

## Install the License

Choose one of these methods to install the JFrog Platform license. Use only one method — switching methods while the cluster is running may disable the Artifactory HA cluster:

* **Artifactory UI** (recommended) — once the primary cluster is running, insert licenses via the UI.
* **REST API** — use the [Install License API](/administration/reference/installlicense).
* **Kubernetes Secret** — create a Secret from a license file, or embed it inline in the Helm release. Applies to initial deployment only.

<Accordion title="Add Licenses" icon="key">
  To activate Artifactory HA, install an appropriate license.

  <Callout icon="📘" theme="info">
    **Specify multiple licenses**

    Whether in the Artifactory UI, via the REST API, or in the `artifactory.cluster.license` section, separate licenses with a newline.
  </Callout>

  <Callout icon="⚠️" theme="warning">
    **Warning**

    Use only one of these methods. Switching between them while a cluster is running might disable your Artifactory HA cluster.
  </Callout>

  Select a method below for step-by-step instructions.

  <Tabs>
    <Tab title="Artifactory UI (Recommended)">
      Once the primary cluster is running, open the Artifactory UI and insert the license(s).

      Enter all licenses at once, each separated by a newline. Adding them one at a time can redirect you to an unlicensed node where the UI will not load.

      This method applies to initial deployment only — once Artifactory is deployed, update the license via the UI or REST API.
    </Tab>

    <Tab title="REST API">
      Add licenses via the [Install License API](/administration/reference/installlicense). The REST API uses `\n` for newlines in the license string.
    </Tab>

    <Tab title="Kubernetes Secret">
      Deploy the Artifactory license(s) as a <a href="https://kubernetes.io/docs/concepts/configuration/secret/" target="_blank">Kubernetes Secret</a>. Prepare a text file with the license(s) written in it. If adding multiple licenses, include them in the same file with **two new lines between each** license block.

      **Option A: External secret file**

      1. Create the Kubernetes secret (assuming the local license file is `art.lic`).

         ```bash
         kubectl create secret generic artifactory-cluster-license --from-file=./art.lic
         ```
      2. Create a `license-values.yaml`.

         ```yaml
         artifactory:
           license:
             secret: artifactory-cluster-license
             dataKey: art.lic
         ```
      3. Install with the `license-values.yaml`.

         Run the following command for JFrog Platform.

         ```bash
         helm upgrade --install jfrog-platform --namespace jfrog-platform --create-namespace jfrog/jfrog-platform -f license-values.yaml
         ```

         Run the following command for Artifactory.

         ```bash
         helm upgrade --install artifactory --set artifactory.license.secret=artifactory-cluster-license,artifactory.license.dataKey=art.lic --namespace artifactory --create-namespace jfrog/artifactory
         ```

      **Option B: Inline secret as part of the Helm release**

      1. Create a `license-values.yaml`.

         ```yaml
         artifactory:
           license:
             licenseKey: |-
               <LICENSE_KEY1>
               <LICENSE_KEY2>
               <LICENSE_KEY3>
         ```
      2. Install with the `license-values.yaml`.

         ```bash
         helm upgrade --install jfrog-platform --namespace jfrog-platform --create-namespace jfrog/jfrog-platform -f license-values.yaml
         ```

      <Callout icon="📘" theme="info">
        **Note**

        Both options apply to initial deployment only. Once Artifactory is deployed, do not keep passing these parameters — the license is already persisted into Artifactory's storage and will be ignored. Update the license via the Artifactory UI or REST API instead.

        To keep managing the license via Kubernetes Secret, use the `copyOnEveryStartup` example in the `values.yaml` file.
      </Callout>
    </Tab>
  </Tabs>
</Accordion>

## Enable Additional Products

The JFrog Platform Helm chart lets you enable or disable products after your initial install using a `custom-values.yaml` file and a `helm upgrade` command.

For example:

1. To deploy Xray, create a `custom-values.yaml` file with the following content.

   ```yaml
   xray:
     enabled: true
   ```
2. Run the upgrade command.

   ```bash
   helm upgrade --install jfrog-platform --namespace jfrog-platform --create-namespace jfrog/jfrog-platform  -f custom-values.yaml
   ```
3. Configure each JFrog product separately with the following steps:

   1. Copy the configurations to update from the main `values.yaml` into a `custom-values.yaml` file.
   2. Set your custom values in `custom-values.yaml`.

      Any values not present in `custom-values.yaml` fall back to the defaults in the main `values.yaml`.
   3. Run the upgrade command.

      ```bash
      helm upgrade --install jfrog-platform --namespace jfrog-platform --create-namespace jfrog/jfrog-platform  -f custom-values.yaml
      ```

<Callout icon="📘" theme="info">
  **Note**

  If you install Xray with the JFrog Platform charts, the RabbitMQ vhost is named "xray". The standalone Xray Helm chart sets "/" as the RabbitMQ vhost.
</Callout>

## JFrog Platform Product Configuration

Apply any of the following configurations after installation:

### System YAML Configuration File

Configure all system settings using the `system.yaml` file in `$JFROG_HOME/artifactory/var/etc`. For more information, see [System Configuration](system-configuration). If you do not have a `system.yaml` file in that folder, copy the template from the same directory and name it `system.yaml`.

<Callout icon="📘" theme="info">
  **Note**

  Unlike other installations, you make changes in `values.yaml`; Helm applies them to `system.yaml`.

  To apply configuration changes:

  1. Update `values.yaml`.
  2. Run the following command.

     ```bash
     helm upgrade --install <jfrog product> --namespace <jfrog product> -f values.yaml
     ```
</Callout>

### Database

The JFrog Platform Helm chart includes a bundled PostgreSQL database for evaluation use only. Configure an [alternative supported database](database-configuration) before deploying to production.

### Customize Java Opts (Optional)

Set JVM parameters using the `artifactory.extraJavaOpts` property in `$JFROG_HOME/artifactory/var/etc/system.yaml`. Use the following Java memory parameters:

Scale `-Xms` and `-Xmx` with repository size and concurrent user count. With at least 512 MB reserved for Artifactory, the recommended minimal values are:

`-server -Xms512m -Xmx2g -Xss256k -XX:+UseG1GC`

For more recommendations about your hardware configuration, especially the `-Xmx` parameter, see [System Requirements](system-requirements).

### Additional Settings

Use additional settings to customize ports, join keys, and master keys. See [joinKey (`join.key`) and masterKey (`master.key`)](manage-keys).

<Callout icon="❗️" theme="error">
  **Master Key and Join Key Are Mandatory, With No Chart Default**

  The `jfrog-platform` chart has no default master key or join key. Every install and upgrade must supply both keys.

  - Set them with `global.masterKeySecretName` and `global.joinKeySecretName` (recommended), or `global.masterKey` and `global.joinKey`.
  - `helm install` and `helm upgrade` fail validation if either key is missing.
  - The chart rejects a join key that matches a previously published chart default. Generate a unique key for each deployment.
  - See [Manage Keys](manage-keys) for creation, rotation, and retrieval steps.
</Callout>

### Configure Filestore

By default, Artifactory uses the local file system for storage. It supports [additional filestore configurations](filestore-configuration-landing) for cloud storage, custom binary providers, and redundancy.

## Use an External PostgreSQL Database in the JFrog Platform Installation

Configure the JFrog Platform to use an external PostgreSQL database instead of the bundled one.

Create a `values-external-postgresql.yaml` file with the following YAML configuration.

```yaml
global:
  database:
    initDBCreation: false
postgresql:
  enabled: false
artifactory:
  database:
    type: postgresql
    driver: org.postgresql.Driver
    url: 'jdbc:postgresql://${POSTGRESQL_HOST}:${POSTGRESQL_PORT}/${ARTIFACTORY_DATABASE}'
    user: ${ARTIFACTORY_DATABASE_USER}
    password: ${ARTIFACTORY_DATABASE_PASSWORD}
xray:
  database:
    url: 'postgres://${POSTGRESQL_HOST}:${POSTGRESQL_PORT}/${XRAY_DATABASE}?sslmode=disable'
    user: ${XRAY_DATABASE_USER}
    password: ${XRAY_DATABASE_PASSWORD}
distribution:
  database:
    url: 'jdbc:postgresql://${POSTGRESQL_HOST}:${POSTGRESQL_PORT}/${DISTRIBUTION_DATABASE}?sslmode=disable'
    user: ${DISTRIBUTION_DATABASE_USER}
    password: ${DISTRIBUTION_DATABASE_PASSWORD}
```

Set `postgresql.enabled=false` in the YAML file and provide the external database details. Create the database and users before running the Helm install or upgrade command.

For more information, see [Using an External Database](use-an-external-database-with-artifactory-helm-installation).

## Access Logs

List pods to find the pod name:

```bash
kubectl --namespace <your namespace> get pods
```

Stream container logs:

```bash
kubectl --namespace <your namespace> logs -f <name of the pod> -c <name of the container>
```

## Related Topics

* [Helm Quick Start](install-jfrog-platform-via-helm-quick-start)
* [Helm Charts for Advanced Users](helm-charts-for-advanced-users)
* [All Products Customization](all-products-customization)
* [Use an External Database with Artifactory Helm Installation](use-an-external-database-with-artifactory-helm-installation)
* [Advanced Storage Options](advanced-storage-options)
* [Upgrade Helm Charts](upgrade-helm-charts)

## Frequently Asked Questions

This section provides answers to frequently asked questions.

<Accordion title="FAQs" icon="plus">

##### Q: What is the recommended method for installing a JFrog Platform license via Helm?

**A:** The Artifactory UI is the recommended method. Once the primary cluster is running, open the Artifactory UI and insert all licenses at once, separated by newlines. The REST API and Kubernetes Secret methods also work but must not be mixed with the UI method on the same cluster.

##### Q: Can I switch license installation methods after deploying?

**A:** No. Use only one method per cluster. Switching between the Artifactory UI, REST API, and Kubernetes Secret while the cluster is running may disable the Artifactory HA cluster.

##### Q: How do I enable JFrog Xray after a JFrog Platform Helm installation?

**A:** Create a `custom-values.yaml` containing `xray: enabled: true` and run `helm upgrade --install jfrog-platform jfrog/jfrog-platform --namespace jfrog-platform --create-namespace -f custom-values.yaml`.

##### Q: Why does `helm upgrade` fail with a missing key or an insecure-key error?

**A:** The chart requires a unique master key and join key for every install. It no longer ships a default. Provide both with `global.masterKeySecretName` and `global.joinKeySecretName` (or `global.masterKey` and `global.joinKey`). Make sure the join key is not a previously published chart default. See [Manage Keys](manage-keys).

</Accordion>