# rclone demo

## DEMO utilizzo di base

### configurazione di un remoto

TODO: configurare un remoto tipo la nostra claudia

```sh
# esempio con nextcloud
rclone config
#  n -> new remote
#  prossima-claudia1 -> remote name
#  55 -> WebDAV
#  https://cloud.bglug.it/remote.php/dav/files/demo1 -> url
#  2 Nextcloud -> vendor
#  demo1 -> user
#  demo1@asperti.com -> password
#  niente bearer token
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

#  n -> new remote
#  prossima-claudia2 -> remote name
#  55 -> WebDAV
#  https://cloud.bglug.it/remote.php/dav/files/demo2 -> url
#  2 Nextcloud -> vendor
#  demo2 -> user
#  demo2@asperti.com -> password
#  niente bearer token
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

```

### mount

```sh
mkdir my_claudia
rclone mount prossima-claudia1:/ ./my_claudia
```

### ncdu

```sh
rclone ncdu prossima-claudia1:
```

### sync

```sh
# one-way
rclone sync prossima-claudia1:/ prossima-claudia2:/ --verbose

# bidirezionale
rclone bisync prossima-claudia1:/ prossima-claudia2:/ --resync --verbose  # solo 1 volta
rclone bisync prossima-claudia1:/ prossima-claudia2:/ --verbose  # da mettere in cron
```

## DEMO utilizzo avanzato

### combine (unione di più remoti)

```sh
# esempio di unione tra google drive, dropbox, icloud
# si suppone di aver già configurato i remoti gdrive: dropbox: icloud:

rclone config
#  n -> new remote
#  claudie -> remote name
#  11 -> Combine several remotes into one
#  demo1=prossima-claudia1: demo2=prossima-claudia2: -> upstreams
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

rclone ncdu claudie:
```

### union

```sh
# esempio di unione di 2 remoti, uno in sola lettura e l'altro per le scritture

rclone config
#  n -> new remote
#  unione -> remote name
#  54 -> Union merges the contents of several upstream fs
#  prossima-claudia1:/:ro prossima-claudia2: -> upstreams
#  [lasciare vuoto] -> action_policy
#  [lasciare vuoto] -> create_policy
#  [lasciare vuoto] -> search_policy
#  [lasciare vuoto] -> cache_time
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

rclone ncdu unione:
```

### rcd e web gui

```sh
# lancia la webgui, per configurare i remoti
rclone rcd --rc-web-gui

# rc-serve abilita il "servizio" di remoti
rclone rcd --rc-serve --rc-web-gui --rc-no-auth 

# comando al server di fare una sync
rclone rc --rc-no-auth sync/copy srcFs=prossima-claudia1:gianni dstFs=prossima-claudia2:gianni

```

### creazione minio di prova

```sh
# prepariamo un server minio da usare come destinazione
docker run --rm --name minio -p 9000:9000 -p 9001:9001 \
  quay.io/minio/minio server /data --console-address ":9001"

# andare su http://127.0.0.1:9001 e loggarsi con minioadmin/minioadmin
# per verificare che tutto sia ok

# configurare rclone
rclone config
#  n -> new remote
#  miniodemo -> remote name
#  5 -> Amazon S3 Compliant Storage Providers
#  14 -> Minio Object Storage
#  1 -> Enter AWS credentials in the next step.
#  access key  (minioadmin)  ***
#  secret key  (minioadmin)  ***
#  empty region
#  http://127.0.0.1:9000 -> endpoint
#  lasciar vuoto la location
#  1 -> accesso privato
#  1 -> no server side encription
#  1 -> (di conseguenza) non server kms id
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

# test
rclone ncdu miniodemo:

```

### server (webdav/sftp/...)

```sh
rclone serve http miniodemo: --addr ':8080'
```

---

### server (volumi docker)

```sh
docker plugin list

docker plugin install rclone/docker-volume-rclone:amd64 args="-v" --alias rclone --grant-all-permissions

docker volume create minio1 -d rclone -o type=s3 -o s3-provider=Minio -o s3-endpoint=http://127.0.0.1:9000 \
  -o s3-access_key_id=minioadmin -o s3-secret_access_key=minioadmin -o path=volumi/pippo

sudo rclone serve docker --write-back-cache -vv

docker run --rm -ti -v minio1:/test alpine
```

---

## DEMO casi d'uso

### montaggio cartella remota compressa e crittografata

```sh
# NB: usare un rclone recente, ci sono stati bug in passato su queste cose

# creiamo un bucket
rclone mkdir miniodemo:diariosegreto

# aggiungiamo crittografia
rclone config
#  n -> new remote
#  segreto -> remote name
#  14 -> Encrypt/Decrypt a remote
#  miniodemo:diariosegreto -> remote
#  1 -> Encrypt the filenames
#  1 -> Encrypt directory names.
#  y -> Yes, type in my own password
#  ciccio -> password
#  n -> non serve la seconda password
#  n -> non ci serve modificare la config avanzata
#  y -> salvare

#  n -> new remote
#  diariocompresso -> remote name
#  12 -> Compress a remote
#  segreto: -> remote
#  1 -> Standard gzip compression with fastest parameters.
#  n -> non ci serve modificare la config avanzata
#  y -> salvare


mkdir diario
rclone mount diariocompresso: diario --daemon

cat > diario/2025-04-27.md <<EOF
Oggi ho mangiato le lasagne e non me ne pento.
EOF

wget -O diario/lasagne.jpg \
  https://upload.wikimedia.org/wikipedia/commons/thumb/2/26/Lasagna_bolognese.jpg/1920px-Lasagna_bolognese.jpg

killall rclone # per smontare

```

### mysqldump pippato su rclone

```sh
# facciam partire un server mariadb con docker
docker run --rm -d --name mariadb -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=ciaociao \
  mariadb:11

# database preso da qui: https://github.com/apburton84/data-mysql
git clone https://github.com/apburton84/data-mysql
cd data-mysql/
mysql -h 127.0.0.1 -u root -pciaociao < employees.sql 

# un dump veloce di test
mysqldump -h 127.0.0.1 -u root -pciaociao employees > dump.sql

# creiamo un bucket
rclone mkdir miniodemo:maisicuel

# dump e upload
mysqldump -h 127.0.0.1 -u root -pciaociao employees | rclone rcat miniodemo:maisicuel/dump.sql

# dump, compressione e upload
mysqldump -h 127.0.0.1 -u root -pciaociao employees | pigz | rclone rcat miniodemo:maisicuel/dump.sql.gz
```

### backup in docker compose

```yaml
services:
  db:
    image: mariadb:11
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root_password
      MYSQL_DATABASE: mydatabase
      MYSQL_USER: user_name
      MYSQL_PASSWORD: user_password
    volumes:
      - ./db:/var/lib/mysql

  miniodemo:
    image: quay.io/minio/minio
    restart: always
    ports:
      - 9000:9000
      - 9001:9001
    volumes:
      - ./miniodemo:/data
    command: ["server", "/data", "--console-address", ":9001"]

  rclone:
    image: rclone/rclone:latest
    restart: always
    volumes:
      - ./rclone:/config
    entrypoint: |
      /bin/sh -c "
        while true ; do
          which mysqldump || apk -U add mariadb-client ;
          mariadb-dump -h db -u root -proot_password mydatabase | gzip | rclone rcat miniodemo:maisicuel/dump-$(date +'%a').sql.gz --verbose ;
          sleep 30;
        done
      "
```

```sh
cat > rclone/rclone/rclone.conf <<EOF
[demo]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://miniodemo:9000
acl = private
EOF
```
