docs: update Netgrimoire/Pocket/Deployment_Guide

This commit is contained in:
Administrator 2026-02-22 05:00:13 +00:00 committed by John Smith
parent 8326126a6d
commit 5404b15726

View file

@ -2,7 +2,7 @@
title: Pocket Grimoire
description:
published: true
date: 2026-02-22T04:17:23.914Z
date: 2026-02-22T05:00:02.026Z
tags:
editor: markdown
dateCreated: 2026-02-20T04:41:35.122Z
@ -2195,6 +2195,540 @@ ls /srv/greenpg/Pocket/stash/generated/ | wc -l
---
## Drive Movement Workflow (VAULT, GREEN, MEDIA-FAMILY)
This section covers moving SSDs between Netgrimoire and Pocket Grimoire for syncing and swapping.
---
### VAULT Drive Movement
**VAULT is normally ALWAYS CONNECTED to Pocket Grimoire**, but you may need to move it back to Netgrimoire for:
- Initial population with backup data
- Major updates to backup repositories
- Troubleshooting or recovery
#### Connect VAULT to Netgrimoire
```bash
# On Netgrimoire
# Physical: Connect VAULT SSD via USB 3.0 or SATA
# Import pool
sudo zpool import pocket-vault
# Load encryption key
sudo zfs load-key pocket-vault
# Enter VAULT passphrase
# Mount datasets
sudo zfs mount -a
# Verify mounted
zfs list | grep pocket-vault
df -h | grep pocket-vault
```
#### Update VAULT on Netgrimoire
```bash
# On Netgrimoire
# Update Kopia repository
sudo kopia repository connect filesystem --path=/mnt/pocket-vault/kopia
sudo kopia snapshot create /path/to/backup/source
# Sync Git repositories
sudo rsync -avP /export/vault/repos/ /mnt/pocket-vault/repos/
# Sync Wiki backups
sudo rsync -avP /srv/wikijs/backups/ /mnt/pocket-vault/backups/wiki/
# Sync photo/document backups
sudo rsync -avP /export/vault/photos/ /mnt/pocket-vault/backups/photos/
sudo rsync -avP /export/vault/documents/ /mnt/pocket-vault/backups/documents/
# Verify updates
du -sh /mnt/pocket-vault/
```
#### Disconnect VAULT from Netgrimoire
```bash
# On Netgrimoire
# Unmount datasets
sudo zfs unmount pocket-vault
# Or unmount all at once:
# sudo zfs unmount -a (be careful with this!)
# Export pool
sudo zpool export pocket-vault
# Verify exported
zpool list | grep pocket-vault
# Should show nothing
# Physical: Disconnect VAULT SSD
```
#### Connect VAULT to Pocket Grimoire
```bash
# Physical: Connect to Anker USB-A port #2
# On Pocket Grimoire (SSH)
ssh user@pocket-grimoire.local
# Use unlock script (recommended)
/usr/local/sbin/unlock-pocket-grimoire.sh
# Enter VAULT passphrase when prompted
# Or manual:
sudo zpool import pocket-vault vaultpg
sudo zfs load-key vaultpg
sudo zfs set mountpoint=/srv/vaultpg vaultpg
sudo zfs mount -a
# Verify mounted
df -h | grep vaultpg
zfs list | grep vaultpg
```
---
### GREEN Drive Movement (Personal Media + Stash)
**GREEN is rotated** - connected during personal trips, synced on Netgrimoire when updates needed.
#### Connect GREEN to Netgrimoire
```bash
# On Netgrimoire
# Physical: Connect GREEN SSD via USB 3.0 or SATA
# Check if drive detected
lsblk
# Import pool
sudo zpool import greenpg
# Load encryption key
sudo zfs load-key greenpg
# Enter GREEN passphrase
# Mount datasets
sudo zfs mount -a
# Verify mounted
zfs list | grep greenpg
df -h | grep greenpg
# Should show:
# greenpg 5.00T 2.14T 280K /srv/greenpg
# greenpg/Pocket 5.00T 2.14T 5.00T /srv/greenpg/Pocket
```
#### Update GREEN on Netgrimoire
**Using Syncoid (Recommended):**
```bash
# On Netgrimoire
# Sync from vault/Green/Pocket to GREEN drive
sudo syncoid vault/Green/Pocket greenpg/Pocket
# Progress shown:
# Sending incremental vault/Green/Pocket@...
# 2.3GB 0:01:23 [28.4MB/s] [===============>] 100%
# Verify sync completed
zfs list greenpg/Pocket
du -sh /srv/greenpg/Pocket/
# Check latest snapshot
zfs list -t snapshot greenpg/Pocket | tail -3
```
**Manual file updates (if needed):**
```bash
# On Netgrimoire
# Add new media
sudo cp /path/to/new/movie.mp4 /srv/greenpg/Pocket/media/library/movies/
# Add new TV episodes
sudo cp -r /path/to/show/Season02 /srv/greenpg/Pocket/media/library/tv/ShowName/
# Add VeraCrypt containers
sudo cp /path/to/sensitive.vc /srv/greenpg/Pocket/veracrypt/
# Update Stash data (usually automatic via syncoid)
# Stash database, previews, and blobs sync automatically
```
#### Disconnect GREEN from Netgrimoire
```bash
# On Netgrimoire
# Stop any processes using the drive
sudo lsof | grep greenpg
# Kill processes if needed
# Unmount datasets
sudo zfs unmount greenpg/Pocket
sudo zfs unmount greenpg
# Export pool (CRITICAL!)
sudo zpool export greenpg
# Verify exported
zpool list | grep greenpg
# Should show nothing
# Verify ready for import elsewhere
sudo zpool import | grep greenpg
# Should show pool available
# Physical: Disconnect GREEN SSD
```
#### Connect GREEN to Pocket Grimoire
```bash
# Physical: Connect to Raspberry Pi USB 3.0 port (blue port)
# On Pocket Grimoire (SSH)
ssh user@pocket-grimoire.local
# Use unlock script (recommended)
/usr/local/sbin/unlock-pocket-grimoire.sh
# Enter passphrases when prompted
# Or manual:
sudo zpool import greenpg
sudo zfs load-key greenpg
sudo zfs set mountpoint=/srv/greenpg greenpg
sudo zfs set mountpoint=/srv/greenpg/Pocket greenpg/Pocket
sudo zfs mount -a
# Start Docker containers
cd /srv/pocket-grimoire/stacks/jellyfin && docker compose up -d
cd /srv/pocket-grimoire/stacks/stash && docker compose up -d
# Verify services
docker ps
```
**Test services:**
```bash
# From browser (on portapotty WiFi)
http://pocket-grimoire.local:8096 # Jellyfin
http://pocket-grimoire.local:9999 # Stash
```
#### Disconnect GREEN from Pocket Grimoire
```bash
# On Pocket Grimoire (SSH)
ssh user@pocket-grimoire.local
# Stop Docker containers using GREEN
cd /srv/pocket-grimoire/stacks/jellyfin
docker compose down
cd /srv/pocket-grimoire/stacks/stash
docker compose down
# Unmount VeraCrypt (if using)
sudo veracrypt --text --dismount-all
# Unmount datasets
sudo zfs unmount greenpg/Pocket
sudo zfs unmount greenpg
# Export pool
sudo zpool export greenpg
# Verify exported
zpool list | grep greenpg
# Should show nothing
# Physical: Disconnect GREEN SSD
```
---
### MEDIA-FAMILY Drive Movement (Family Content)
**MEDIA-FAMILY is rotated** - connected during family trips, manually updated as needed.
#### Connect MEDIA-FAMILY to Netgrimoire
```bash
# On Netgrimoire
# Physical: Connect MEDIA-FAMILY SSD via USB 3.0 or SATA
# Import pool (no encryption key needed - unencrypted)
sudo zpool import pocket-media
# Mount datasets
sudo zfs mount -a
# Verify mounted
zfs list | grep pocket-media
df -h | grep pocket-media
```
#### Update MEDIA-FAMILY on Netgrimoire
```bash
# On Netgrimoire
# Add new family movies
sudo cp /export/vault/media/family-movies/*.mp4 \
/mnt/pocket-media/library/movies/
# Add new family TV shows
sudo rsync -avP \
/export/vault/media/family-shows/NewShow/ \
/mnt/pocket-media/library/tv/NewShow/
# Remove old content to free space
sudo rm -rf /mnt/pocket-media/library/movies/OldMovie/
sudo rm -rf /mnt/pocket-media/library/tv/OldShow/
# Verify space usage
du -sh /mnt/pocket-media/library/
df -h /mnt/pocket-media
```
#### Disconnect MEDIA-FAMILY from Netgrimoire
```bash
# On Netgrimoire
# Unmount datasets
sudo zfs unmount pocket-media
# Export pool
sudo zpool export pocket-media
# Verify exported
zpool list | grep pocket-media
# Should show nothing
# Physical: Disconnect MEDIA-FAMILY SSD
```
#### Connect MEDIA-FAMILY to Pocket Grimoire
```bash
# Physical: Connect to Raspberry Pi USB 3.0 port (blue port)
# Note: Only connect ONE media drive at a time (GREEN or MEDIA-FAMILY)
# On Pocket Grimoire (SSH)
ssh user@pocket-grimoire.local
# Import pool and rename
sudo zpool import pocket-media mediapg
# Set mount point
sudo zfs set mountpoint=/srv/mediapg mediapg
# Mount datasets (no encryption key needed)
sudo zfs mount -a
# Verify mounted
df -h | grep mediapg
zfs list | grep mediapg
# Start Jellyfin
cd /srv/pocket-grimoire/stacks/jellyfin
docker compose up -d
# Verify
docker ps | grep jellyfin
```
**Test Jellyfin:**
```bash
# From browser
http://pocket-grimoire.local:8096
# Should show family-friendly media
```
#### Disconnect MEDIA-FAMILY from Pocket Grimoire
```bash
# On Pocket Grimoire (SSH)
ssh user@pocket-grimoire.local
# Stop Jellyfin
cd /srv/pocket-grimoire/stacks/jellyfin
docker compose down
# Unmount datasets
sudo zfs unmount mediapg
# Export pool
sudo zpool export mediapg
# Verify exported
zpool list | grep mediapg
# Should show nothing
# Physical: Disconnect MEDIA-FAMILY SSD
```
---
### Swapping Media Drives (GREEN ↔ MEDIA-FAMILY)
**To swap from GREEN to MEDIA-FAMILY on Pocket Grimoire:**
```bash
# On Pocket Grimoire
# 1. Disconnect GREEN (see above)
cd /srv/pocket-grimoire/stacks/jellyfin && docker compose down
cd /srv/pocket-grimoire/stacks/stash && docker compose down
sudo zfs unmount greenpg/Pocket
sudo zfs unmount greenpg
sudo zpool export greenpg
# Physically disconnect GREEN SSD
# 2. Connect MEDIA-FAMILY (see above)
# Physically connect MEDIA-FAMILY SSD
sudo zpool import pocket-media mediapg
sudo zfs set mountpoint=/srv/mediapg mediapg
sudo zfs mount -a
cd /srv/pocket-grimoire/stacks/jellyfin && docker compose up -d
# Note: Stash won't work with MEDIA-FAMILY (no Stash data on that drive)
# Only Jellyfin uses MEDIA-FAMILY
```
**To swap from MEDIA-FAMILY to GREEN:**
```bash
# On Pocket Grimoire
# 1. Disconnect MEDIA-FAMILY
cd /srv/pocket-grimoire/stacks/jellyfin && docker compose down
sudo zfs unmount mediapg
sudo zpool export mediapg
# Physically disconnect MEDIA-FAMILY SSD
# 2. Connect GREEN
# Physically connect GREEN SSD
sudo zpool import greenpg
sudo zfs load-key greenpg
sudo zfs mount -a
cd /srv/pocket-grimoire/stacks/jellyfin && docker compose up -d
cd /srv/pocket-grimoire/stacks/stash && docker compose up -d
# Both Jellyfin and Stash work with GREEN
```
---
### Quick Reference: Drive Movement Commands
**VAULT:**
```bash
# To Netgrimoire:
sudo zpool import pocket-vault
sudo zfs load-key pocket-vault
sudo zfs mount -a
# From Netgrimoire:
sudo zfs unmount pocket-vault
sudo zpool export pocket-vault
# To Pocket:
sudo zpool import pocket-vault vaultpg
sudo zfs load-key vaultpg
sudo zfs mount -a
```
**GREEN:**
```bash
# To Netgrimoire:
sudo zpool import greenpg
sudo zfs load-key greenpg
sudo zfs mount -a
sudo syncoid vault/Green/Pocket greenpg/Pocket # Update
# From Netgrimoire:
sudo zfs unmount greenpg/Pocket && sudo zfs unmount greenpg
sudo zpool export greenpg
# To Pocket:
/usr/local/sbin/unlock-pocket-grimoire.sh # Easy way
# Or manual: import → load-key → mount → start containers
# From Pocket:
docker compose down # Stop jellyfin & stash
sudo zfs unmount greenpg/Pocket && sudo zfs unmount greenpg
sudo zpool export greenpg
```
**MEDIA-FAMILY:**
```bash
# To Netgrimoire:
sudo zpool import pocket-media
sudo zfs mount -a
# Add/remove content
# From Netgrimoire:
sudo zfs unmount pocket-media
sudo zpool export pocket-media
# To Pocket:
sudo zpool import pocket-media mediapg
sudo zfs set mountpoint=/srv/mediapg mediapg
sudo zfs mount -a
docker compose up -d # Start jellyfin
# From Pocket:
docker compose down # Stop jellyfin
sudo zfs unmount mediapg
sudo zpool export mediapg
```
---
### Typical Use Cases
**Before Personal Trip:**
1. Connect GREEN to Netgrimoire
2. Update: `sudo syncoid vault/Green/Pocket greenpg/Pocket`
3. Disconnect from Netgrimoire
4. Connect GREEN to Pocket Grimoire
5. Test Jellyfin and Stash
**Before Family Visit:**
1. Disconnect GREEN from Pocket (if connected)
2. Connect MEDIA-FAMILY to Netgrimoire
3. Add/update family content
4. Disconnect from Netgrimoire
5. Connect MEDIA-FAMILY to Pocket Grimoire
6. Test Jellyfin
**Weekly at Home (No Drive Movement):**
- Leave drives in Pocket Grimoire
- Use network sync: `/usr/local/sbin/pocketgrimoire-zfs-pull.sh`
- Automatic every 6 hours
---
## Deployment Procedure
**Hotel/Travel Location Setup:**
@ -3070,4 +3604,3 @@ For issues or improvements to this documentation:
---
*This guide was created for Pocket Grimoire deployment and maintenance. Keep this documentation updated as the system evolves.*