JuiceFS Documentation

https://juicefs.com/docs
Admin
JuiceFS is a distributed file system that supports object storage and provides high performance and...
Tokens:615,477
Snippets:4,984
Trust Score:9.4
Update:5 days ago
Show doc for...
Tokens:
Raw
### Enable virtual-hosted-style with MINIO_DOMAIN and gateway command

Source: https://juicefs.com/docs/cloud/guide/gateway

Set MINIO_DOMAIN and start the gateway to enable virtual-hosted-style requests. This is the same as the earlier MINIO_DOMAIN example but includes the gateway startup command.

```bash
export MINIO_DOMAIN=mydomain.com
juicefs gateway myjfs 111.2.3.4:9000
```

--------------------------------

### Start incremental sync consumer

Source: https://juicefs.com/docs/community/administration/changelog

Start the consumer using the version recorded in the metadata backup as the starting point.

```bash
juicefs changelog SOURCE-META-URL --from VERSION
```

--------------------------------

### Enable and start the gateway systemd service

Source: https://juicefs.com/docs/cloud/guide/gateway

Reload systemd, enable the service to start at boot, and start it immediately. Then check its status.

```bash
systemctl daemon-reload
systemctl enable juicefs-gateway --now
systemctl status juicefs-gateway
```

--------------------------------

### Install Compiled SDK

Source: https://juicefs.com/docs/community/deployment/python_sdk

Install the generated wheel file using pip.

```bash
pip install juicefs-1.3.0-py3-none-any.whl  
```

--------------------------------

### Start Samba and verify ports

Source: https://juicefs.com/docs/cloud/deployment/samba

Enable and start the Samba services, then verify that the smb ports are listening.

```bash
systemctl enable --now {smb,nmb}  
# Check listening ports and verify network connectivity  
lsof -PiTCP | grep smb  
```

--------------------------------

### Direct Installation via Script

Source: https://juicefs.com/docs/csi/getting_started

Install the driver directly using the provided script.

```bash
./juicefs-csi-webhook-install.sh install  
```

--------------------------------

### Google Cloud SDK Installation

Source: https://juicefs.com/docs/cloud/reference/how_to_set_up_object_storage

Command to download and install the Google Cloud SDK.

```bash
curl https://sdk.cloud.google.com | bash
```

--------------------------------

### Install JuiceFS on macOS using pre-compiled binary

Source: https://juicefs.com/docs/community/getting-started/installation

Install the downloaded darwin-amd64 binary to a system executable path using the sudo install command.

```bash
sudo install juicefs /usr/local/bin  
```

--------------------------------

### Interactive Mount Example

Source: https://juicefs.com/docs/cloud/getting_started

Example of the interactive credential input process when mounting a file system for the first time.

```bash
$ sudo juicefs mount myjfs /jfs  
Token for myjfs: xxxxx  
Access key ID for oss://juicefs-myjfs: xxxxx  
Access key secret for oss://juicefs-myjfs: xxxxx  
OK, myjfs is ready at /jfs.
```

--------------------------------

### juicefs webdav command synopsis

Source: https://juicefs.com/docs/community/command_reference

The synopsis and an example usage for starting a WebDAV server with a metadata engine URL and address.

```bash
juicefs webdav [command options] META-URL ADDRESS  
  
juicefs webdav redis://localhost localhost:9007  
```

--------------------------------

### Enable and start systemd mount

Source: https://juicefs.com/docs/community/mount_juicefs_at_boot_time

After creating the unit file, create the required symlink and enable the service to start at boot.

```bash
ln -s /usr/local/bin/juicefs /sbin/mount.juicefs  
systemctl enable juicefs.mount  
systemctl start juicefs.mount
```

--------------------------------

### Install JuiceFS client

Source: https://juicefs.com/docs/community/tutorials/juicefs_on_wsl

Execute this command on the Linux subsystem to install the JuiceFS client.

```bash
curl -sSL https://d.juicefs.com/install | sh -  
```

--------------------------------

### Start Thumbnailer

Source: https://juicefs.com/docs/cloud/guide/gateway

Start the Thumbnailer service using the webhook configuration.

```bash
NODE_ENV=webhook node thumbnail-webhook.js  
```

--------------------------------

### GET /api/v1/volumes request example

Source: https://juicefs.com/docs/cloud/reference/console_api

Example of a GET request to retrieve the file system list, including the required Host and Authorization headers.

```http
GET /api/v1/volumes  
  
Host: juicefs.com  
Authorization: 4dca13af31e45740c1c1fe3acaca8752a093b43ccc169f890f1305f51f038bf8  
...  
```

--------------------------------

### Add custom policy help and example

Source: https://juicefs.com/docs/cloud/guide/gateway

Displays help for adding a new policy and provides an example of adding a canned policy from a JSON file.

```bash
$ mc admin policy add -h  
NAME:  
  mc admin policy add - add new policy  
  
USAGE:  
  mc admin policy add TARGET POLICYNAME POLICYFILE  
  
POLICYNAME:  
  Name of the canned policy on MinIO server.  
  
POLICYFILE:  
  Name of the policy file associated with the policy name.  
  
EXAMPLES:  
  1. Add a new canned policy 'writeonly'.  
     $ mc admin policy add myjfs writeonly /tmp/writeonly.json  
```

--------------------------------

### Install FoundationDB on Ubuntu

Source: https://juicefs.com/docs/community/fdb_best_practices

Download and install the FoundationDB client and server DEB packages.

```bash
// Download the server and client DEB packages.  
wget https://github.com/apple/foundationdb/releases/download/6.3.23/foundationdb-clients_6.3.23-1_amd64.deb  
wget https://github.com/apple/foundationdb/releases/download/6.3.23/foundationdb-server_6.3.23-1_amd64.deb  
// Install the packages.  
sudo dpkg -i foundationdb-clients_6.3.23-1_amd64.deb \
foundationdb-server_6.3.23-1_amd64.deb  
```

--------------------------------

### Automate JuiceFS setup with a shell script

Source: https://juicefs.com/docs/cloud/automation

Create a bash script to download the binary, authenticate, and mount the volume. Execute the script with the required parameters to perform the setup without interaction.

```bash
#!/bin/sh
set -e
curl -sSL juicefs.com/static/juicefs -o /usr/local/bin/juicefs && chmod +x /usr/local/bin/juicefs
sudo juicefs auth "$1" --token "$2" --accesskey "$3" --secretkey "$4"
sudo juicefs mount "$1" "$5"
```

```bash
./setup-juicefs.sh $VOL_NAME $JFS_TOKEN $ACCESSKEY $SECRETKEY $JFS_MOUNTPONT
```

--------------------------------

### Install fsspec

Source: https://juicefs.com/docs/community/deployment/python_sdk

Install the fsspec library to enable integration.

```bash
pip install fsspec  
```

--------------------------------

### Enable and Start Service

Source: https://juicefs.com/docs/community/guide/gateway

Reload the systemd daemon and enable the gateway service to start at boot.

```bash
systemctl daemon-reload  
systemctl enable juicefs-gateway --now  
systemctl status juicefs-gateway  
```

--------------------------------

### Simple juicefs find examples

Source: https://juicefs.com/docs/cloud/guide/find

Basic usage examples for searching files by name, type, size, and performing actions like deletion or listing.

```bash
juicefs find /mnt/jfs -name "*.log"
juicefs find /mnt/jfs -type f -size +10M -print
juicefs find /mnt/jfs -name "*.tmp" -a -delete
juicefs find /mnt/jfs -type f -exec ls -l {} \;
```

--------------------------------

### Install JuiceFS via wget

Source: https://juicefs.com/docs/cloud/getting_started

Download and install the JuiceFS binary to /usr/local/bin using wget.

```bash
wget https://juicefs.com/static/juicefs -O /usr/local/bin/juicefs && chmod +x /usr/local/bin/juicefs
```

--------------------------------

### juicefs load synopsis and example

Source: https://juicefs.com/docs/cloud/commands_reference

Shows the juicefs load command syntax and an example importing a metadata backup file into the file system.

```bash
juicefs load [command options] PATH [FILE]  

# Import the metadata backup file into the file system  
juicefs load /mnt/jfs meta-dump.json.gz  
```

--------------------------------

### Start WebDAV server

Source: https://juicefs.com/docs/cloud/webdav

Start the WebDAV server for the specified file system on the given address.

```bash
juicefs webdav myjfs localhost:9007  
```

--------------------------------

### Install Thumbnailer

Source: https://juicefs.com/docs/cloud/guide/gateway

Clone and install dependencies for the Thumbnailer project.

```bash
git clone https://github.com/minio/thumbnailer/  
npm install  
```

--------------------------------

### Start Redis at boot with Homebrew

Source: https://juicefs.com/docs/community/mount_juicefs_at_boot_time

If using Homebrew to manage Redis, use this command to ensure it starts at boot.

```bash
brew services start redis  
```

--------------------------------

### Install mingw-w64 for Windows cross-compilation

Source: https://juicefs.com/docs/community/hadoop_java_sdk

Prerequisite package installation on Ubuntu for cross-compiling the client for Windows.

```bash
sudo apt install mingw-w64  
```

--------------------------------

### Gateway Startup Output

Source: https://juicefs.com/docs/cloud/guide/gateway

Example output showing successful connection and available access endpoints.

```text
2023/03/21 20:15:49.945403 juicefs[97188] <INFO>: connected to 47.103.20.252:9308 [client.go:874]  
2023/03/21 20:15:49.965411 juicefs[97188] <INFO>: Cache: /Users/herald/.juicefs/cache/jfs8 capacity: 102400 MB [disk_cache.go:747]  
Endpoint: http://127.0.0.1:9000  
  
Browser Access:  
   http://127.0.0.1:9000  
  
Object API (Amazon S3 compatible):  
   Go:         https://docs.min.io/docs/golang-client-quickstart-guide  
   Java:       https://docs.min.io/docs/java-client-quickstart-guide  
   Python:     https://docs.min.io/docs/python-client-quickstart-guide  
   JavaScript: https://docs.min.io/docs/javascript-client-quickstart-guide  
   .NET:       https://docs.min.io/docs/dotnet-client-quickstart-guide  
```

--------------------------------

### Install FoundationDB client on RHEL

Source: https://juicefs.com/docs/community/databases_for_metadata

Commands to download and install the FoundationDB client library on RHEL and derivative systems.

```bash
curl -O https://github.com/apple/foundationdb/releases/download/6.3.25/foundationdb-clients-6.3.25-1.el7.x86_64.rpm  
sudo rpm -Uvh foundationdb-clients-6.3.25-1.el7.x86_64.rpm  
```

--------------------------------

### Install libgfapi on RHEL

Source: https://juicefs.com/docs/community/how_to_setup_object_storage

Install Gluster development libraries on RHEL and derivative systems.

```bash
sudo yum install glusterfs glusterfs-api-devel glusterfs-libs
```

--------------------------------

### Navigate to LTP Installation Directory

Source: https://juicefs.com/docs/community/posix_compatibility

Change the working directory to the default LTP installation path.

```bash
cd /opt/ltp  
```

--------------------------------

### Example values-mycluster.yaml Configuration

Source: https://juicefs.com/docs/csi/getting_started

An example of a customized values file including image repository overrides and the kubelet directory setting.

```yaml
kubeletDir: <kubelet-dir>  
  
image:  
  repository: registry.example.com/juicefs-csi-driver  
dashboardImage:  
  repository: registry.example.com/csi-dashboard  
sidecars:  
  livenessProbeImage:  
    repository: registry.example.com/k8scsi/livenessprobe  
  nodeDriverRegistrarImage:  
    repository: registry.example.com/k8scsi/csi-node-driver-registrar  
  csiProvisionerImage:  
    repository: registry.example.com/k8scsi/csi-provisioner  
  csiResizerImage:  
    repository: registry.example.com/k8scsi/csi-resizer  
```

--------------------------------

### juicefs version synopsis and examples

Source: https://juicefs.com/docs/cloud/commands_reference

Shows the juicefs version command syntax and examples for upgrading with seamless restart and rolling back to a previous major version using the JFSCHAN environment variable.

```bash
juicefs version [options]  

# Upgrade client version and seamless restart  
juicefs version -u -r  

# When a new major version is released, there might be compatibility issues,  
# use the following variable to rollback, e.g. downgrade from 5.2 to 5.1  
export JFSCHAN=5.1  
juicefs version -u  
```

--------------------------------

### Install FoundationDB client on Debian

Source: https://juicefs.com/docs/community/databases_for_metadata

Commands to download and install the FoundationDB client library on Debian and derivative systems.

```bash
curl -O https://github.com/apple/foundationdb/releases/download/6.3.25/foundationdb-clients_6.3.25-1_amd64.deb  
sudo dpkg -i foundationdb-clients_6.3.25-1_amd64.deb  
```

--------------------------------

### Start Prometheus service

Source: https://juicefs.com/docs/community/administration/monitoring

Run the Prometheus binary pointing to your modified configuration file.

```bash
./prometheus --config.file=prometheus.yml  
```

--------------------------------

### Install JuiceFS kubectl plugin via script

Source: https://juicefs.com/docs/csi/troubleshooting

Use this script to download and install the latest version of the plugin on Linux or macOS systems. The default installation path is /usr/local/bin.

```bash
# default installation path is /usr/local/bin  
curl -sSL https://d.juicefs.com/kubectl-jfs-install | sh -
```

--------------------------------

### Install JuiceFS via curl

Source: https://juicefs.com/docs/cloud/getting_started

Download and install the JuiceFS binary to /usr/local/bin using curl.

```bash
curl -L https://juicefs.com/static/juicefs -o /usr/local/bin/juicefs && chmod +x /usr/local/bin/juicefs
```

--------------------------------

### Install JuiceFS Python SDK

Source: https://juicefs.com/docs/cloud/deployment/python-sdk

Install the standard JuiceFS Python SDK using pip.

```bash
pip install https://static.juicefs.com/misc/juicefs-5.2.15.20250930-py3-none-any.whl
```

--------------------------------

### Install pre-commit hooks

Source: https://juicefs.com/docs/community/development/contributing_guide

Run this command in the root of the repository to set up pre-commit hooks for static analysis.

```bash
pre-commit install
```

--------------------------------

### Install FoundationDB on RHEL / CentOS

Source: https://juicefs.com/docs/community/fdb_best_practices

Download and install the FoundationDB client and server RPM packages.

```bash
// Download the server and client RPM packages.  
wget https://github.com/apple/foundationdb/releases/download/6.3.12/foundationdb-clients-6.3.23-1.el7.x86_64.rpm  
wget https://github.com/apple/foundationdb/releases/download/6.3.23/foundationdb-server-6.3.23-1.el7.x86_64.rpm  
// Install the packages.  
sudo rpm -Uvh foundationdb-clients-6.3.23-1.el7.x86_64.rpm \
foundationdb-server-6.3.23-1.el7.x86_64.rpm  
```

--------------------------------

### Verify JuiceFS installation

Source: https://juicefs.com/docs/community/clouds/aliyun

Run the juicefs command to verify the installation and view the available commands and options.

```bash
$ juicefs  
NAME:  
   juicefs - A POSIX file system built on Redis and object storage.  
  
USAGE:  
   juicefs [global options] command [command options] [arguments...]  
  
VERSION:  
   0.15.2 (2021-07-07T05:51:36Z 4c16847)  
  
COMMANDS:  
   format   format a volume  
   mount    mount a volume  
   umount   unmount a volume  
   gateway  S3-compatible gateway  
   sync     sync between two storage  
   rmr      remove directories recursively  
   info     show internal information for paths or inodes  
   bench    run benchmark to read/write/stat big/small files  
   gc       collect any leaked objects  
   fsck     Check consistency of file system  
   profile  analyze access log  
   status   show status of JuiceFS  
   warmup   build cache for target directories/files  
   dump     dump metadata into a JSON file  
   load     load metadata from a previously dumped JSON file  
   help, h  Shows a list of commands or help for one command  
  
GLOBAL OPTIONS:  
   --verbose, --debug, -v  enable debug log (default: false)  
   --quiet, -q             only warning and errors (default: false)  
   --trace                 enable trace log (default: false)  
   --no-agent              disable pprof (:6060) agent (default: false)  
   --help, -h              show help (default: false)  
   --version, -V           print only the version (default: false)  
  
COPYRIGHT:  
   Apache License 2.0
```

--------------------------------

### Manage gateway users

Source: https://juicefs.com/docs/cloud/guide/gateway

Examples of adding a user and listing users in standard or JSON format.

```bash
# Add a new user.  
$ mc admin user add myjfs user1 admin123  
  
# List current users.  
$ mc admin user list myjfs  
enabled    user1  
  
# List current users in JSON format.  
$ mc admin user list myjfs --json  
{  
 "status": "success",  
 "accessKey": "user1",  
 "userStatus": "enabled"  
}
```

--------------------------------

### Start encrypted WebDAV server

Source: https://juicefs.com/docs/cloud/webdav

Start the WebDAV server using the generated certificate and private key files for HTTPS.

```bash
# Set username and password  
export WEBDAV_USER=root  
export WEBDAV_PASSWORD=1234  
# Start WebDAV server  
juicefs webdav --cert-file client.crt --key-file client.key myjfs localhost:9007  
```

--------------------------------

### juicefs fsck synopsis and example

Source: https://juicefs.com/docs/cloud/commands_reference

Shows the juicefs fsck command syntax and an example invocation to check file system consistency.

```bash
juicefs fsck [command options] VOLUME-NAME  

juicefs fsck $VOL_NAME  
```

--------------------------------

### Install JuiceFS CSI Driver via Helm

Source: https://juicefs.com/docs/csi/guide/resource-optimization

Installs the driver using the customized values.yaml file.

```bash
helm install juicefs-csi-driver juicefs/juicefs-csi-driver -n kube-system -f ./values.yaml  
```

--------------------------------

### Install Sidecar Mode via kubectl Script

Source: https://juicefs.com/docs/csi/getting_started

Download and execute the installation script to generate and apply YAML files.

```bash
# Sidecar mode uses local generated certificates, rendered into the YAML files, this is all handled in the installation script  
wget https://raw.githubusercontent.com/juicedata/juicefs-csi-driver/master/scripts/juicefs-csi-webhook-install.sh  
chmod +x ./juicefs-csi-webhook-install.sh  
  
# Generate installation files  
./juicefs-csi-webhook-install.sh print > juicefs-csi-sidecar.yaml  
  
# Thoroughly check this YAML file, and install  
kubectl apply -f ./juicefs-csi-sidecar.yaml  
```

--------------------------------

### Install and manage JuiceFS via Snapcraft

Source: https://juicefs.com/docs/community/getting-started/installation

Commands for installing, configuring, and updating JuiceFS using the Snap package manager.

```bash
sudo snap install juicefs
```

```bash
sudo ln -s -f /snap/juicefs/current/juicefs /snap/bin/juicefs
```

```bash
sudo snap refresh juicefs
```

--------------------------------

### Load and test the LaunchAgent

Source: https://juicefs.com/docs/community/mount_juicefs_at_boot_time

Use launchctl to load and start the service, then verify the mount point. Ensure the metadata engine is running.

```bash
launchctl load ~/Library/LaunchAgents/io.juicefs.<NAME>.plist  
launchctl start ~/Library/LaunchAgents/io.juicefs.<NAME>  
ls <MOUNTPOINT>  
```

--------------------------------

### Volume Quota API Operations

Source: https://juicefs.com/docs/cloud/reference/console_api

Examples of GET, POST, and PUT requests for managing volume quotas.

```python
    url = f'{API_URL}/volumes/1/quotas'  
    request('GET', url)  
  
  
def create_volume_quota():  
    url = f'{API_URL}/volumes/1/quotas'  
    request('POST', url, data={'path': '/path/to/subdir', 'inodes': 1 << 20, 'size': 1 << 30})  
  
  
def update_volume_quota():  
    url = f'{API_URL}/volumes/1/quotas/9'  
    request('PUT', url, data={'path': '/foo', 'size': 10 << 30})  
```

--------------------------------

### Configure Flume for JuiceFS

Source: https://juicefs.com/docs/cloud/hadoop/installation

Example Flume configuration file setup to sink data into a JuiceFS path.

```properties
jfs.sources =r1  
jfs.sources.r1.type = org.apache.flume.source.StressSource  
jfs.sources.r1.size = 10240  
jfs.sources.r1.maxTotalEvents=10  
jfs.sources.r1.batchSize=10  
jfs.sources.r1.channels = c1  
  
jfs.channels = c1  
jfs.channels.c1.type = memory  
jfs.channels.c1.capacity = 100  
jfs.channels.c1.transactionCapacity = 100  
  
jfs.sinks = k1  
jfs.sinks.k1.type = hdfs  
jfs.sinks.k1.channel = c1  
jfs.sinks.k1.hdfs.path =jfs://${VOL_NAME}/tmp/flume  
jfs.sinks.k1.hdfs.writeFormat= Text  
jfs.sinks.k1.hdfs.fileType= DataStream  
```

--------------------------------

### Install NFS Client Packages

Source: https://juicefs.com/docs/cloud/deployment/nfs

Install the necessary NFS client packages based on the Linux distribution.

```bash
# Debian / Ubuntu  
sudo apt install -y nfs-common  
  
# RHEL / CentOS / Rocky / AlmaLinux  
sudo yum install -y nfs-utils
```

--------------------------------

### Compile and Install LTP

Source: https://juicefs.com/docs/community/posix_compatibility

Commands to unarchive, configure, and build the LTP test suite from source.

```bash
tar -xvf ltp-full-20260529.tar.xz  
cd ltp-full-20260529  
./configure  
make all  
make install  
```

--------------------------------

### Install WSL with default distribution

Source: https://juicefs.com/docs/community/tutorials/juicefs_on_wsl

Run this command in PowerShell or Windows Command Prompt as an administrator to download the Linux kernel and install the default distribution.

```bash
wsl --install  
```

--------------------------------

### Install and enable netmount on Alpine Linux

Source: https://juicefs.com/docs/community/administration/troubleshooting

Use these commands to install the netmount service and ensure JuiceFS mounts correctly after a system reboot on Alpine Linux.

```bash
# use --update-fstab to add juicefs mount to /etc/fstab  
  
# install and enable netmount service  
apk add openrc  
  
rc-update add netmount boot  
# * service netmount added to runlevel boot  
  
 rc-service netmount start  
# / # rc-service netmount start  
# * Mounting network filesystems ...
```

--------------------------------

### Install NFS Client

Source: https://juicefs.com/docs/community/deployment/nfs

Install the NFS common package on all Linux hosts that need to access the NFS shares.

```bash
sudo apt install nfs-common
```

--------------------------------

### Volume management API operations

Source: https://juicefs.com/docs/cloud/reference/console_api

Example functions for performing GET, DELETE, POST, and PUT operations on volumes and volume exports using the request helper.

```python
def get_volumes():  
    url = f'{API_URL}/volumes'  
    request('GET', url)  
  
  
def delete_volume():  
    url = f'{API_URL}/volumes/1'  
    request('DELETE', url)  
  
  
def get_volume_exports():  
    url = f'{API_URL}/volumes/1/exports'  
    request('GET', url)  
  
  
def create_volume_export():  
    url = f'{API_URL}/volumes/1/exports'  
    request(  
        'POST',  
        url,  
        data={  
            'desc': 'for mount',  
            'iprange': '192.168.0.1/24',  
            'apionly': False,  
            'readonly': False,  
            'appendonly': False,  
        },  
    )  
  
  
def update_volume_export():  
    url = f'{API_URL}/volumes/1/exports/1'  
    request('PUT', url, data={'desc': 'for mount', 'iprange': '192.168.100.1/24'})
```

--------------------------------

### Install JuiceFS client

Source: https://juicefs.com/docs/community/clouds/aliyun

Download and install the latest version of the JuiceFS client on Ubuntu Server 20.04 64-bit.

```bash
curl -sSL https://d.juicefs.com/install | sh -
```

--------------------------------

### Get Help Information

Source: https://juicefs.com/docs/community/deployment/python_sdk

Use the help function to inspect the Client class.

```python
import juicefs  
  
help(juicefs.Client)  
```

--------------------------------

### Kafka Connect: Configure hadoop.conf.dir and store.url

Source: https://juicefs.com/docs/community/hadoop_java_sdk

Example configuration for Kafka Connect HDFS Sink Connector to use JuiceFS. Specify hadoop.conf.dir as the directory containing core-site.xml and store.url as a path starting with jfs://.

```properties
# Other configuration items are omitted.  
hadoop.conf.dir=/path/to/hadoop-conf  
store.url=jfs://path/to/store  
```

--------------------------------

### Avoid Incorrect Resource Omission

Source: https://juicefs.com/docs/csi/guide/configurations

Setting requests to "0" causes Kubernetes to set requests equal to limits, which may prevent the Mount Pod from starting. This example demonstrates the incorrect configuration and its resulting effect.

```yaml
# this is BAD example, do not copy and use  
juicefs/mount-cpu-limit: "32"  
juicefs/mount-memory-limit: "64Gi"  
# zero causes csi-node to omit the requests field  
juicefs/mount-cpu-requests: "0"  
juicefs/mount-memory-requests: "0"  
```

```yaml
resources:  
  limits:  
    cpu: 32  
    memory: 64Gi  
  requests:  
    cpu: 32  
    memory: 64Gi  
```

--------------------------------

### JuiceFS CLI mount command example

Source: https://juicefs.com/docs/csi/guide/configurations

Example of a standard JuiceFS mount command using cache size and FUSE options.

```bash
juicefs mount ... --cache-size=204800 -o writeback_cache,debug  
```

--------------------------------

### Install JuiceFS on Ubuntu via PPA

Source: https://juicefs.com/docs/community/getting-started/installation

Use the PPA repository to install the latest JuiceFS client on Ubuntu systems.

```bash
sudo add-apt-repository ppa:juicefs/ppa
```

```bash
sudo apt-get update
```

```bash
sudo apt-get install juicefs
```

--------------------------------

### Install JuiceFS Docker plugin

Source: https://juicefs.com/docs/cloud/use_juicefs_in_docker

Install the JuiceFS Docker volume plugin. Grant permissions when prompted during installation.

```bash
docker plugin install juicedata/juicefs  
```

--------------------------------

### Clone and Navigate to SDK Directory

Source: https://juicefs.com/docs/community/deployment/python_sdk

Initial steps to prepare the environment for compilation by cloning the repository and entering the Python SDK directory.

```bash
# Clone JuiceFS repository  
git clone https://github.com/juicedata/juicefs.git  
# Enter JuiceFS directory  
cd juicefs/sdk/python  
```

--------------------------------

### Install JuiceFS on Windows using Scoop

Source: https://juicefs.com/docs/community/getting-started/installation

Use the Scoop package manager to install the latest version of the JuiceFS client on Windows.

```bash
scoop install juicefs  
```

--------------------------------

### Install JuiceFS kubectl plugin via krew

Source: https://juicefs.com/docs/csi/troubleshooting

If krew is already installed in your cluster, you can use it to manage the plugin installation.

```bash
kubectl krew update  
kubectl krew install jfs
```

--------------------------------

### Verify JuiceFS installation

Source: https://juicefs.com/docs/community/tutorials/windows

Run this command in Command Prompt or PowerShell to confirm the JuiceFS client is correctly installed and accessible.

```text
juicefs version  
```

--------------------------------

### Start S3 Gateway with Mountpoint

Source: https://juicefs.com/docs/cloud/guide/gateway

Command to start the gateway with the --mountpoint flag to resolve absolute symbolic links.

```bash
juicefs gateway myjfs 127.0.0.1:8888 --mountpoint=/jfs  
```

--------------------------------

### Deploy with default kubelet path

Source: https://juicefs.com/docs/csi/getting_started

Use these commands if the kubelet root directory is the default /var/lib/kubelet.

```bash
# Kubernetes version >= v1.18  
kubectl apply -f https://raw.githubusercontent.com/juicedata/juicefs-csi-driver/master/deploy/k8s.yaml  
  
# Kubernetes version < v1.18  
kubectl apply -f https://raw.githubusercontent.com/juicedata/juicefs-csi-driver/master/deploy/k8s_before_v1_18.yaml  
```

--------------------------------

### juicefs dump synopsis and examples

Source: https://juicefs.com/docs/cloud/commands_reference

Shows the juicefs dump command syntax and two examples: exporting metadata to meta-dump.json and exporting metadata for a subdirectory.

```bash
juicefs dump [command options] PATH JSON-PATH  

# Export metadata to meta-dump.json  
juicefs dump /jfs meta-dump.json  

# Export metadata for only one subdirectory of the file system  
juicefs dump /jfs/subdir meta-dump.json  
```

--------------------------------

### Instantiate JuiceFS Client

Source: https://juicefs.com/docs/community/deployment/python_sdk

Create a client instance and list files in the root directory.

```python
from juicefs import Client  
  
# Create JuiceFS client  
jfs = Client(name='', meta='redis://192.168.1.8/0')  
  
# List files in a directory  
jfs.listdir('/')  
```

--------------------------------

### Verify Vdbench Installation

Source: https://juicefs.com/docs/community/performance_evaluation_guide

Command to verify that Vdbench is installed successfully on a node.

```bash
./vdbench -t
```

--------------------------------

### Start Spark Thrift JDBC/ODBC Server

Source: https://juicefs.com/docs/community/hadoop_java_sdk

Command to initialize the Spark resident process for task submission.

```bash
${SPARK_HOME}/sbin/start-thriftserver.sh \
  --master yarn \
  --driver-memory 8g \
  --executor-memory 10g \
  --executor-cores 3 \
  --num-executors 3 \
  --conf spark.locality.wait=100 \
  --conf spark.sql.crossJoin.enabled=true \
  --hiveconf hive.server2.thrift.port=10001  

```

--------------------------------

### Create user and directory on Ubuntu host

Source: https://juicefs.com/docs/cloud/guide/guid_auto_map

Setup a user with UID 1001 and create a directory on an Ubuntu host.

```bash
[ubuntu]$ useradd -m -G sudo -u 1001 juicefs  
[ubuntu]$ id juicefs  
uid=1001(juicefs) gid=1001(juicefs) groups=1001(juicefs),27(sudo)  
[ubuntu]$ su juicefs  
[ubuntu]$ mkdir /jfs/juicefs@ubuntu  
```

--------------------------------

### Install JuiceFS Operator

Source: https://juicefs.com/docs/csi/guide/juicefs-operator

Install the JuiceFS Operator using a custom values file.

```bash
# Modify values-mycluster.yaml as needed  
helm upgrade --install juicefs-operator juicefs/juicefs-operator -n juicefs-operator --create-namespace -f values-mycluster.yaml  
```

--------------------------------

### Mounting Multiple Files or Directories

Source: https://juicefs.com/docs/csi/guide/configurations

Example of mounting multiple paths by separating them with commas.

```yaml
juicefs/host-path: "/data/file1.txt,/data/file2.txt,/data/dir1"  
```

--------------------------------

### JuiceFS format command output

Source: https://juicefs.com/docs/community/clouds/aliyun

Example output confirming the successful formatting of the JuiceFS volume.

```text
2021/07/13 16:37:14.264445 juicefs[22290] <INFO>: Meta address: redis://@herald-sh-abc.redis.rds.aliyuncs.com:6379/1  
2021/07/13 16:37:14.277632 juicefs[22290] <WARNING>: maxmemory_policy is "volatile-lru", please set it to 'noeviction'.  
2021/07/13 16:37:14.281432 juicefs[22290] <INFO>: Ping redis: 3.609453ms  
2021/07/13 16:37:14.527879 juicefs[22290] <INFO>: Data uses oss://mytest/mystor/  
2021/07/13 16:37:14.593450 juicefs[22290] <INFO>: Volume is formatted as {Name:mystor UUID:4ad0bb86-6ef5-4861-9ce2-a16ac5dea81b Storage:oss Bucket:https://mytest340 AccessKey:LTAI4G4v6ioGzQXy56m3XDkG SecretKey:removed BlockSize:4096 Compression:none Shards:0 Partitions:0 Capacity:0 Inodes:0 EncryptKey:}  
```

--------------------------------

### Start JuiceFS WebDAV Server

Source: https://juicefs.com/docs/cloud/commands_reference

Starts a WebDAV server to access a JuiceFS file system. Authentication is configured via WEBDAV_USER and WEBDAV_PASSWORD environment variables.

```bash
juicefs webdav [command options] NAME ADDRESS  
  
# Set username and password  
export WEBDAV_USER=root  
export WEBDAV_PASSWORD=1234  
  
# Start WebDAV server on port 9007  
juicefs webdav myjfs localhost:9007
```

--------------------------------

### Cross-compile Windows Client on Linux

Source: https://juicefs.com/docs/community/getting-started/installation

Install MinGW-w64 and compile the Windows binary on a Linux system.

```bash
sudo apt install mingw-w64
```

```bash
make juicefs.exe
```

--------------------------------

### Install libgfapi on Debian

Source: https://juicefs.com/docs/community/how_to_setup_object_storage

Install Gluster development libraries on Debian and derivative systems.

```bash
sudo apt-get install uuid-dev libglusterfs-dev glusterfs-common
```

--------------------------------

### Example API Request for File System Creation

Source: https://juicefs.com/docs/cloud/reference/console_api

A sample POST request structure used to demonstrate the signing algorithm.

```http
POST /api/v1/volumes?a=1&a=2&b=3&c=4  
  
Host: juicefs.com  
Content-Type: application/json  
...  
  
  
{"name": "test", "bucket": "https://test.s3.us-east-1.amazonaws.com"}  
```

--------------------------------

### Initialize Client with existing configuration

Source: https://juicefs.com/docs/cloud/deployment/python-sdk

Initialize the juicefs.Client using an existing configuration file located in ~/.juicefs by specifying the file system name.

```python
import juicefs

# Initialize the client object using the file system named myjfs
jfs = juicefs.Client("myjfs")
```

--------------------------------

### Install librados2-devel on RHEL

Source: https://juicefs.com/docs/community/how_to_setup_object_storage

Install the librados development library on RHEL and derivative systems.

```bash
sudo yum install librados2-devel
```

--------------------------------

### Install librados-dev on Debian

Source: https://juicefs.com/docs/community/how_to_setup_object_storage

Install the librados development library on Debian and derivative systems.

```bash
sudo apt-get install librados-dev
```

--------------------------------

### Launch JuiceFS Gateway

Source: https://juicefs.com/docs/cloud/guide/gateway

Start the gateway service on the specified address after setting credentials.

```bash
juicefs gateway myjfs 127.0.0.1:9000  
```

--------------------------------

### Create a simple test volume

Source: https://juicefs.com/docs/community/command_reference

Initializes a volume using a local SQLite database for metadata storage.

```bash
juicefs format sqlite3://myjfs.db myjfs
```

--------------------------------

### Client.warmup(paths, threads=10, priority=0, retry=3, max_failure=0, evict=False, follow_link=False, check=False, background=False, samples=0, expand=0)

Source: https://juicefs.com/docs/cloud/deployment/python-sdk

Warm up the cache. Like the `juicefs warmup` command, it downloads files to the cache in advance to speed up subsequent access.

```APIDOC
## Client.warmup(paths, threads=10, priority=0, retry=3, max_failure=0, evict=False, follow_link=False, check=False, background=False, samples=0, expand=0)

### Description
Warm up the cache. Like the `juicefs warmup` command, it downloads files to the cache in advance to speed up subsequent access.

### Method
Client.warmup

### Parameters
- **paths** (str) - Required - File or directory path to warm up.
- **threads** (int) - Optional - Download concurrency. Default is `10`.
- **priority** (int) - Optional - Cache block priority. Valid values are `0`, `1`, `2`, and `3`. The higher the number, the higher the priority. Default is `0`.
- **retry** (int) - Optional - Maximum retry times for downloading a single data block. Default is `3`.
- **max_failure** (int) - Optional - Maximum number of failed data blocks allowed. Default is `0`.
- **evict** (bool) - Optional - Actively evict the cache content of the given path. Default is `False`.
- **follow_link** (bool) - Optional - Whether to follow symbolic links. Default is `False`.
- **check** (bool) - Optional - Check whether the given path has been cached. Default is `False`.
- **background** (bool) - Optional - Whether to run in the background. Default is `False`.
- **samples** (int) - Optional - Number of data blocks to sample for warmup. Default is `0`, which means warming up all data.
- **expand** (int) - Optional - Additional range to warm up. Default is `0`.

### Return Value
A dictionary with the warmup result.
```

--------------------------------

### Initialize Client class

Source: https://juicefs.com/docs/cloud/deployment/python-sdk

The Client class handles authentication and session establishment with the Metadata Service. Options mirror the juicefs auth and mount commands.

```python
class Client(name, *, token="", conf_dir="", console_url="https://juicefs.com",  
             bucket=None, access_key=None, secret_key=None, session_token=None, shards=0, storage_class=None,  
             bucket2=None, access_key2=None, secret_key2=None, session_token2=None, shards2=0, storage_class2=None,  
             rsa_key_path="", rsa_passphrase=None, internal=False, external=False,  
             max_uploads=20, max_downloads=200, prefetch=1, put_timeout="60s", get_timeout="5s",  
             upload_limit='', download_limit='', writeback=False, writeback_threshold_size="0",  
             metacache=True, max_cached_inodes=500000, opencache=False,  
             attr_cache="1s", entry_cache="0s", dir_entry_cache="1s",  
             buffer_size="300M", cache_size="100M", cache_items=0, free_space_ratio=0.1, cache_dir="memory",  
             cache_evict="2-random", cache_expire="0s", cache_scan_interval="3600s", verify_cache_checksum="extend",  
             cache_group="", group_ip="", group_weight=100, group_weight_unit="0M", group_port=0, no_sharing=False,  
             second_group="", cache_partial_only=False, cache_large_write=False, cache_try_dio=True,  
             fill_group_cache=False, cache_priority=0,  
             mount_point="/jfs", access_log="", debug=False, flip=False, no_bgjob=False, log="", read_only=False)  
```

--------------------------------

### List available WSL distributions

Source: https://juicefs.com/docs/community/tutorials/juicefs_on_wsl

Use this command to view all Linux distributions available for installation on WSL.

```bash
wsl --list --online
```

--------------------------------

### Verify and Mount from Client

Source: https://juicefs.com/docs/cloud/deployment/nfs

List exported directories from the server and mount the share on a client machine.

```bash
# List exported directories  
showmount -e <NFS-SERVER-IP>  
  
# Mount from Linux client (example)  
sudo mount -t nfs -o vers=4 <NFS-SERVER-IP>:/mnt/myjfs/media /mnt/media
```

--------------------------------

### Install Sidecar Mode with CertManager via Script

Source: https://juicefs.com/docs/csi/getting_started

Generate or install the sidecar configuration with CertManager support.

```bash
# Generate installation files  
./juicefs-csi-webhook-install.sh print --with-certmanager > juicefs-csi-sidecar.yaml  
kubectl apply -f ./juicefs-csi-sidecar.yaml  
  
# Directly install  
./juicefs-csi-webhook-install.sh install --with-certmanager  
```

--------------------------------

### Install Kirk Test Runner

Source: https://juicefs.com/docs/community/posix_compatibility

Install the kirk package, which serves as the replacement for the deprecated runltp tool.

```bash
pip install kirk  
```

--------------------------------

### Install NFS Server Packages

Source: https://juicefs.com/docs/cloud/deployment/nfs

Install the necessary NFS server packages based on the Linux distribution.

```bash
# Debian / Ubuntu  
sudo apt install -y nfs-kernel-server  
  
# RHEL / CentOS / Rocky / AlmaLinux  
sudo yum install -y nfs-utils
```

--------------------------------

### Create user and directory on CentOS host

Source: https://juicefs.com/docs/cloud/guide/guid_auto_map

Setup a user with UID 2002 and create a directory on a CentOS host.

```bash
[centos]$ useradd -m -G wheel -u 2002 juicefs  
[centos]$ id juicefs  
uid=2002(juicefs) gid=2002(juicefs) groups=2002(juicefs),10(wheel)  
[centos]$ su juicefs  
[centos]$ mkdir /jfs/juicefs@centos  
```

--------------------------------

### Access log format example

Source: https://juicefs.com/docs/community/fault_diagnosis_and_analysis

An example of the raw output format for a JuiceFS access log entry.

```text
2021.01.15 08:26:11.003330 [uid:0,gid:0,pid:4403] write (17669,8666,4993160): OK <0.000010>  
```

--------------------------------

### Enable multi-bucket support

Source: https://juicefs.com/docs/cloud/guide/gateway

Use the --multi-buckets flag at startup to export subdirectories as separate buckets.

```bash
juicefs gateway myjfs localhost:9000 --multi-buckets
```

--------------------------------

### Configure Cache Priority with mount and warmup

Source: https://juicefs.com/docs/cloud/guide/distributed-cache

Examples of applying cache priority to mount points and warmup commands to manage data importance during cache eviction.

```bash
# Add this option directly to a mount point, then all cache built through  
# this mount point will carry the specified priority.  
# This is especially helpful in Kubernetes CSI, as you can associate different priority  
# to different PV, to distinguish imporance of application cache data  
juicefs mount myjfs /jfs --cache-group=mygroup --no-sharing --cache-priority=3  
  
# Add this option to the warmup command, and the data built via warmup will have the specified priority  
juicefs warmup /jfs/big-dir --cache-priority=3
```

--------------------------------

### Install NFS Server

Source: https://juicefs.com/docs/community/deployment/nfs

Install the NFS kernel server package on the host where the JuiceFS file system is mounted.

```bash
sudo apt install nfs-kernel-server
```

--------------------------------

### Dockerfile to install JuiceFS client

Source: https://juicefs.com/docs/community/how_to_use_on_kubernetes

Integrate the JuiceFS client into an application image by downloading and installing the latest release.

```dockerfile
FROM alpine:latest  
LABEL maintainer="Juicedata <https://juicefs.com>"  
  
# Install JuiceFS client  
RUN apk add --no-cache curl && \
  JFS_LATEST_TAG=$(curl -s https://api.github.com/repos/juicedata/juicefs/releases/latest | grep 'tag_name' | cut -d '"' -f 4 | tr -d 'v') && \
  wget "https://github.com/juicedata/juicefs/releases/download/v${JFS_LATEST_TAG}/juicefs-${JFS_LATEST_TAG}-linux-amd64.tar.gz" && \
  tar -zxf "juicefs-${JFS_LATEST_TAG}-linux-amd64.tar.gz" && \
  install juicefs /usr/bin && \
  rm juicefs "juicefs-${JFS_LATEST_TAG}-linux-amd64.tar.gz" && \
  rm -rf /var/cache/apk/* && \
  apk del curl  
  
ENTRYPOINT ["/usr/bin/juicefs", "mount"]  
```

--------------------------------

### Execute Account Sync Playbook

Source: https://juicefs.com/docs/community/sync_accounts_between_multiple_hosts

Run the playbook using an inventory file containing target host IP addresses. This example creates the user 'alice' with UID 1200 and group 'staff' with GID 500.

```bash
~/account-sync$ cat hosts
172.16.255.163
172.16.255.180
~/account-sync$ ansible-playbook -i hosts -u root --ssh-extra-args "-o StrictHostKeyChecking=no" \
--extra-vars "group=staff gid=500 user=alice uid=1200" play.yaml

PLAY [all] ************************************************************************************************

TASK [Gathering Facts] ************************************************************************************
ok: [172.16.255.180]
ok: [172.16.255.163]

TASK [Ensure group staff with gid 500 exists] *************************************************************
ok: [172.16.255.163]
ok: [172.16.255.180]

TASK [Ensure user alice with uid 1200 exists] *************************************************************
changed: [172.16.255.180]
changed: [172.16.255.163]

PLAY RECAP ************************************************************************************************
172.16.255.163             : ok=3    changed=1    unreachable=0    failed=0
172.16.255.180             : ok=3    changed=1    unreachable=0    failed=0
```

--------------------------------

### Install JuiceFS on macOS using Homebrew

Source: https://juicefs.com/docs/community/getting-started/installation

Use the Homebrew package manager to install the JuiceFS client on macOS.

```bash
brew install juicefs  
```

--------------------------------

### Run juicefs objbench

Source: https://juicefs.com/docs/community/command_reference

Example of running a benchmark on an S3 object storage bucket, providing credentials via environment variables.

```bash
juicefs objbench [command options] BUCKET  
  
# Run benchmarks on S3  
ACCESS_KEY=myAccessKey SECRET_KEY=mySecretKey juicefs objbench --storage=s3 https://mybucket.s3.us-east-2.amazonaws.com -p 6
```

--------------------------------

### Compile and install JuiceFS on Arch Linux

Source: https://juicefs.com/docs/community/getting-started/installation

Manually compile and install JuiceFS from the AUR repository using makepkg.

```bash
sudo pacman -S base-devel git go
```

```bash
git clone https://aur.archlinux.org/juicefs.git
```

```bash
cd juicefs
```

```bash
makepkg -si
```

--------------------------------

### Install JuiceFS on Arch Linux via AUR

Source: https://juicefs.com/docs/community/getting-started/installation

Install the JuiceFS client using the Yay package manager.

```bash
yay -S juicefs
```

--------------------------------

### Deploy Storage Class

Source: https://juicefs.com/docs/community/juicefs_on_k3s

Apply the configuration file to create the storage class in the cluster.

```bash
kubectl apply -f juicefs-sc.yaml
```

--------------------------------

### Client.makedirs method

Source: https://juicefs.com/docs/cloud/deployment/python-sdk

Creates a directory at the specified path.

```python
Client.makedirs(path, mode=0o777, exist_ok=False)  
```

--------------------------------

### Install Samba on RHEL and derivatives

Source: https://juicefs.com/docs/community/deployment/samba

Use the dnf package manager to install Samba on RHEL-based Linux distributions.

```bash
sudo dnf install samba  
```
Tokens:
Raw