Install F5 License Proxy manually

F5 License Proxy (FLP) is a lightweight service that automates and centralizes the licensing of F5 BIG-IP Virtual Editions. Instead of handling licensing manually on each device, FLP acts as a proxy between your BIG-IP instances and the F5 licensing servers.

These instructions let you manually install FLP, use automation tools, or automate the installation process as part of a CI/CD pipeline.

Note

Prior to installing f5-license-proxy, verify that no Persistent Volume Claims (PVCs) from a previous f5-license-proxy installation remain. If any are present, delete them manually before proceeding.

Prepare working directories

Create the required directories for volume, backup, and restore operations and set appropriate permissions

Note: If using CSI-based storage (NetApp Trident, EBS CSI, etc.), skip Step 1b.

1a: Create volume directories

```shell
mkdir -p \
    /root/.flp_spk_volume/postgresql/mtls \
    /root/.flp_spk_volume/vault/ssl \  
    /root/.flp_spk_volume/flp \
    /root/.flp_spk_volume/certificates \
    /root/.flp_spk_backup \
    /root/.flp_spk_restore \
&& chmod -R 0777 /root/.flp_spk_volume \
&& chmod 0777 /root/.flp_spk_backup \
&& chmod 0777 /root/.flp_spk_restore
```

1b: Fix vault host directory permissions

Skip this step if you are using CSI-based storage (NetApp Trident, EBS CSI, etc.)

```shell
mkdir -p /var/lib/f5/vault-data /var/lib/f5/vault-client /var/lib/f5/postgresql-data
chown -R 100:1000 /var/lib/f5/vault-data
chown -R 100:1000 /var/lib/f5/vault-client
chown -R 1001:1001 /var/lib/f5/postgresql-data
chmod -R 775 /var/lib/f5/vault-data
chmod -R 775 /var/lib/f5/vault-client
chmod -R 775 /var/lib/f5/postgresql-data
```

Generate root certificates

Manually create a root certificate if no existing backup is available. Generate Root CA Key and Certificate with below command

To generate the F5 License Proxy (FLP) server certificate, you can either use the OpenSSL commands provided below to create a self-signed root CA certificate, or supply an existing Certificate Authority (CA)-issued root certificate.

Important

Regardless of which option you choose, you must retain and securely back up a copy of the root CA certificate.

The root CA certificate is required for any future FLP restoration. When restoring the FLP, you must use the same root CA certificate that was originally used during setup. The FLP and the BIG-IP Next (BNK/CNE) cluster establish a mutual trust relationship based on this certificate — using a different root CA during restoration will break that trust and cause communication failures between the FLP and the cluster.

```shell
openssl req \
-new \
-newkey ec:<(openssl ecparam -name prime256v1) \
-days 3650 -nodes -x509 \
-subj "/C=US/ST=Washington/L=Seattle/O=F5/emailAddress=flp@f5.com/CN=flp.ca" \
-keyout /root/.flp_spk_volume/certificates/root-ca.key \
-out /root/.flp_spk_volume/certificates/root-ca.crt
```

Back up/restore root certificates

Retaining or taking back up of the root certificate is mandatory as it will be required for any future restoration of the FLP. Restoring or reconfiguring the FLP with the same root certificate is essential to preserve the trust relationship between the FLP and the BIG-IP Next for Kubernetes cluster. Using a different root certificate during restoration may disrupt the trust relationship and cause communication issues.

Backup

If required, encrypt your root certificate files.

```shell
tar -czf backup.tgz -C /root/.flp_spk_volume/certificates/ root-ca.crt root-ca.key
openssl enc -aes-256-cbc -pbkdf2 -pass pass:<your_password> -in backup.tgz -out backup.tgz.enc
mv backup.tgz.enc /root/.flp_spk_backup
rm backup.tgz
```

Restore

If a backup exists, decrypt and extract it.

```shell
openssl aes-256-cbc -d -pbkdf2 -pass pass:<your_password> \
-in /root/.flp_spk_backup/<backup-file-name>.enc -out backup.tgz
tar -xvf backup.tgz -C /root/.flp_spk_volume/certificates
rm backup.tgz
```

Note

Never rename or manually move backup files to the restore directory, as this may damage the metadata and result in unsuccessful restorations.

Generate certificates for mTLS

Mutual TLS (mTLS) certificates are required to establish secure, authenticated communication between all services within the FLP pod. Unlike standard TLS — which only authenticates the server — mTLS enforces two-way authentication, ensuring that every container can verify the identity of the others before exchanging data. This is especially critical in distributed, cloud-native deployments where trust between internal services cannot be assumed.

Note

You must generate mTLS certificates for each container in the FLP pod. Skipping this step for any container will prevent it from participating in secure inter-service communication.

PostgreSQL mTLS

  1. Generate Private Key and Certificate Signing Request (CSR).

    openssl ecparam -out /root/.flp_spk_volume/postgresql/mtls/tls.key -name prime256v1 -genkey
    openssl req -new \
    -sha512 \
    -key /root/.flp_spk_volume/postgresql/mtls/tls.key \
    -out /root/.flp_spk_volume/postgresql/mtls/tls.csr \
    -subj "/C=US/ST=Washington/L=Seattle/O=F5/emailAddress=flp@f5.com/CN=postgresql"
    
  2. Sign the CSR with Root CA.

    openssl x509 -req \
    -sha512 \
    -in /root/.flp_spk_volume/postgresql/mtls/tls.csr \
    -CA /root/.flp_spk_volume/certificates/root-ca.crt \
    -CAkey /root/.flp_spk_volume/certificates/root-ca.key \
    -CAcreateserial \
    -out /root/.flp_spk_volume/postgresql/mtls/tls.crt \
    -days 3650 \
    -extfile <(printf "subjectAltName=DNS:postgresql,DNS:localhost")
    
  3. Create Kubernetes Secrets.

    cp .flp_spk_volume/certificates/root-ca.crt .flp_spk_volume/postgresql/mtls/ca.crt
    cp .flp_spk_volume/certificates/root-ca.key .flp_spk_volume/postgresql/mtls/ca.key
    
    kubectl create secret generic postgresql-mtls-secret \
    --from-file=ca.crt=/root/.flp_spk_volume/postgresql/mtls/ca.crt \
    --from-file=tls.crt=/root/.flp_spk_volume/postgresql/mtls/tls.crt \
    --from-file=tls.key=/root/.flp_spk_volume/postgresql/mtls/tls.key \
      --dry-run=client -o yaml | kubectl apply -f -
    

Vault SSL

To generate Vault SSL certificates, follow the same key generation, CSR creation, and signing steps used for PostgreSQL SSL — with two key differences:

  • Paths: Update all file paths to reflect the Vault-specific directory structure.

  • Common Name (CN): Set the CN to vault in both the CSR and the signed certificate.

  1. Generate Private Key and Certificate Signing Request (CSR).

    openssl genrsa -out "/root/.flp_spk_volume/vault/ssl/tls.key" 8192
    openssl req \
        -newkey rsa:8192 \
        -sha512 \
        -nodes \
        -out "/root/.flp_spk_volume/vault/ssl/tls.csr" \
        -key "/root/.flp_spk_volume/vault/ssl/tls.key" \
        -subj "/C=US/ST=Washington/L=Seattle/O=F5/emailAddress=flp@f5.com/CN=vault"
    
  2. Sign the CSR with Root CA.

    cp .flp_spk_volume/certificates/root-ca.crt .flp_spk_volume/vault/ssl/ca.crt
    cp .flp_spk_volume/certificates/root-ca.key .flp_spk_volume/vault/ssl/ca.key
    
    openssl x509 \
        -req \
        -sha512 \
        -days 3650 \
        -in "/root/.flp_spk_volume/vault/ssl/tls.csr" \
        -CA "/root/.flp_spk_volume/vault/ssl/ca.crt" \
        -CAkey "/root/.flp_spk_volume/vault/ssl/ca.key"\
        -set_serial 01 \
        -out "/root/.flp_spk_volume/vault/ssl/tls.crt" \
        -extfile <(printf "subjectAltName=DNS:vault,DNS:localhost,DNS:vault-postgresql-service,DNS:localhost")
    
  3. Create Secrets in Kubernetes.

    kubectl create secret generic vault-ssl-secret \
    --from-file=ca.crt=/root/.flp_spk_volume/vault/ssl/ca.crt \
    --from-file=tls.crt=/root/.flp_spk_volume/vault/ssl/tls.crt \
    --from-file=tls.key=/root/.flp_spk_volume/vault/ssl/tls.key \
      --dry-run=client -o yaml | kubectl apply -f -
    

FLP

To generate FLP SSL certificates, follow the same key generation, CSR creation, and signing steps used for PostgreSQL SSL — with two key differences:

  • Paths: Update all file paths to reflect the FLP-specific directory structure.

  • Common Name (CN): Set the CN to flp in both the CSR and the signed certificate.

  1. Generate private key and Certificate Signing Request (CSR).

    openssl genrsa -out "/root/.flp_spk_volume/flp/tls.key" 8192
    openssl req \
        -newkey rsa:8192 \
        -sha512 \
        -nodes \
        -out "/root/.flp_spk_volume/flp/tls.csr" \
        -key "/root/.flp_spk_volume/flp/tls.key" \
        -subj "/C=US/ST=Washington/L=Seattle/O=F5/emailAddress=flp@f5.com/CN=flp"
    
  2. Sign the CSR with Root CA.

    cp .flp_spk_volume/certificates/root-ca.crt .flp_spk_volume/flp/ca.crt
    cp .flp_spk_volume/certificates/root-ca.key .flp_spk_volume/flp/ca.key
    
    # HOST is used as a Subject Alternative Name (SAN) in the TLS certificate below.
    #
    # FLP_HOST should be set to the OpenShift Route hostname when deploying to an
    # OpenShift cluster (this is how external clients will reach the service).
    #
    # If FLP_HOST is not set, we fall back to the local machine's FQDN
    # (`hostname -f`), or the short hostname if the FQDN cannot be resolved.
    
    HOST="${FLP_HOST:-$(hostname -f 2>/dev/null || hostname)}"
    
    
    openssl x509 \
        -req \
        -sha512 \
        -days 3650 \
        -in "/root/.flp_spk_volume/flp/tls.csr" \
        -CA "/root/.flp_spk_volume/flp/ca.crt" \
        -CAkey "/root/.flp_spk_volume/flp/ca.key"\
        -set_serial 01 \
        -out "/root/.flp_spk_volume/flp/tls.crt" \
        -extfile <(printf "subjectAltName=DNS:flp,DNS:localhost,DNS:localhost,DNS:${HOST}")
    
  3. Create secrets in Kubernetes.

    kubectl create secret generic flp-mtls-secret \
        --from-file=ca.crt=/root/.flp_spk_volume/flp/ca.crt \
        --from-file=tls.crt=/root/.flp_spk_volume/flp/tls.crt \
        --from-file=tls.key=/root/.flp_spk_volume/flp/tls.key \
        --dry-run=client -o yaml | kubectl apply -f -
    

FLP-jwt-Secret

Create secrets in Kubernetes:

```shell
kubectl create secret generic flp-jwt-secret \
--from-literal=jwt_secret=$JWT_TOKEN \
--dry-run=client -o yaml | kubectl apply -f -
```

Deploy Helm chart to install FLP

Provide the path to your Helm chart

  1. Run one of the following commands to deploy and install FLP.

    Important

    • Update the command with the correct path to your Helm chart before executing.

    • Ensure the Helm chart is downloaded from F5 Artifact Registry (FAR).

    • Verify that the Chart.yaml file exists in the intended folder.

    1a. Run this command if you are using a default storage class.

     ```shell
     helm upgrade --install f5-license-proxy /root/f5-license-proxy   --namespace default   --timeout 600s --set flp.image.repository=<<image_path>> --set vaultInit.image.repository=<<image_path>> --set vault.image.repository=<<image_path>> --set postgresql.image.repository=<<images_path>> --set flp.imagePullSecrets="far-secret"
     ```
    

    1b. Run this command if you are using a non-default storage class like netapp-trident.

        helm upgrade install f5-license-proxy /root/f5-license-proxy   --namespace default   --timeout 600s --set flp.image.repository=<<image_path>> --set vaultInit.image.repository=<<image_path>> --set vault.image.repository=<<image_path>> --set postgresql.image.repository=<<images_path>> --set storage.createPV=false --set storage.storageClassName=netapp-trident --set route.enabled=true \
    --set route.host=flp.apps.mycluster.example.com --set flp.imagePullSecrets="far-secret"
        ```
    
  2. Add or update configurations using Helm flags (--set) to dynamically pass key-value pairs.

Examples:

```shell
--set flp.isProxyTlsEnabled=true
--set flp.isProxyAuthEnabled=true
```
  1. Check deployment status.

    helm list
    kubectl get pods
    

Proxy configuration

If you choose to use a proxy, export the proxy’s settings via Kubernetes Secrets.

  1. Create the proxy Secret.

    kubectl create secret generic flp-secret \
    --from-literal=host=<proxy_host> \
    --from-literal=port=<proxy_port> \
    --from-literal=protocol=http \
    --from-literal=username=<username> \
    --from-literal=password=<password>
    
  2. Optional: Add CA Certificate for HTTPS.

    kubectl create secret generic flp-ssl-secret \
    --from-file=ca.crt=<path_to_ca.crt>