phramusca

This is my homepage.

View on GitHub

Docker

J’utilise Docker pour faire tourner quelques services sur mon Raspberry Pi.

Installation

Installation depuis la liste des logiciels

Sinon, manuellement

Suppression

# Arrêter Docker
sudo systemctl stop docker
sudo systemctl stop docker.socket

# Désinstaller Docker et ses dépendances
sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Supprimer les fichiers de configuration et données
# /!\ Ne pas supprimer si vous voulez garder les volumes, ...
# sudo rm -rf /var/lib/docker
# sudo rm -rf /var/lib/containerd
# sudo rm -rf /etc/docker

Docker Compose

Portainer CE

Vérifier la compatibilité entre votre version de Docker Engine et Portainer sur les prérequis Portainer (les exigences évoluent avec les versions).

Doc installation docker linux

services:
  portainer:
    image: portainer/portainer-ce:lts
    container_name: portainer
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ${VOLUME_PATH}/portainer:/data
    ports:
      - "9443:9443"

with .env file:

  VOLUME_PATH="/chemin/avec des espaces"

Forgejo

Doc installation

services:
  forgejo:
    image: codeberg.org/forgejo/forgejo:9.0.0
    container_name: forgejo
    restart: unless-stopped
    volumes:
      - ${VOLUME_PATH}/forgejo/data:/data
    ports:
      - 3000:3000

with .env file:

  VOLUME_PATH="/chemin/avec des espaces"

Se connecter aux repos git avec ssh

  1. Configuration de Forgejo

    • Modifier le fichier /data/gitea/conf/app.ini pour activer le serveur SSH intégré de Forgejo sur le port 2222:

      [server]
DOMAIN = rpi5.local
SSH_DOMAIN = rpi5.local
START_SSH_SERVER = true
SSH_LISTEN_PORT = 2222

    • Modifier le fichier docker-compose.yml pour exposer le port 2222:

       ports:
   - "3000:3000"
   - "2222:2222"

    • Redémarrer le conteneur Docker pour prendre en compte la nouvelle configuration.

  2. Configuration du client SSH

    • Créer l’hôte forgejo dans ~/.ssh/config sur la machine cliente :

       # Pour Git/Forgejo (git@rpi5.local)
 Host forgejo
   HostName rpi5.local
   User git
   Port 2222

    • Changer l’URL du remote Git :

      git remote set-url origin git@forgejo:phramusca/taratata-downloader.git

    • Ajouter la clé publique du client dans l’interface web Forgejo (Settings > SSH Keys).

    • Tester la connexion SSH :

       ssh git@rpi5.local -p 2222

      ou

       ssh git@forgejo

      Ce qui doit donner un message du genre:

       PTY allocation request failed on channel 0
 Hi there, xxxxxx! You've successfully authenticated with the key named yyyyy, but Forgejo does not provide shell access.
 If this is unexpected, please log in with password and setup Forgejo under another user.
 Connection to rpi5.local closed.

    • Tester les commandes Git (git fetch, git pull, git push, …) qui doivent fonctionner sans demander de mot de passe.

Lazy Docker

Doc installation

Pour Raspberry Pi 5:

services:
  lazydocker:
    build:
      context: https://github.com/jesseduffield/lazydocker.git
      args:
        BASE_IMAGE_BUILDER: arm64v8/golang
        GOARCH: arm64
        GOARM:
    image: lazyteam/lazydocker
    container_name: lazydocker
    stdin_open: true
    tty: true
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ${VOLUME_PATH}/lazydocker/config:/.config/jesseduffield/lazydocker

with .env file:

  VOLUME_PATH="/chemin/avec des espaces"

Then launch it using:

docker exec -it lazydocker lazydocker

Romm

Doc installation

volumes:
  mysql_data:

services:
  romm:
    image: rommapp/romm:3.7.3
    container_name: romm
    restart: unless-stopped
    environment:
      - DB_HOST=romm-db
      - DB_NAME=romm # Should match MYSQL_DATABASE in mariadb
      - DB_USER=romm-user # Should match MYSQL_USER in mariadb
      - DB_PASSWD=${DB_PASSWD} # Should match MYSQL_PASSWORD in mariadb
      - ROMM_AUTH_SECRET_KEY=${ROMM_AUTH_SECRET_KEY} # Generate a key with `openssl rand -hex 32`
      - IGDB_CLIENT_ID=${IGDB_CLIENT_ID} # Generate an ID and SECRET in IGDB
      - IGDB_CLIENT_SECRET=${IGDB_CLIENT_SECRET} # https://api-docs.igdb.com/#account-creation
      - MOBYGAMES_API_KEY=${MOBYGAMES_API_KEY} # https://www.mobygames.com/info/api/
      - STEAMGRIDDB_API_KEY=${STEAMGRIDDB_API_KEY} # https://github.com/rommapp/romm/wiki/Generate-API-Keys#steamgriddb
    volumes:
      - ${VOLUME_PATH}/cache/romm_resources:/romm/resources # Resources fetched from IGDB (covers, screenshots, etc.)
      - ${VOLUME_PATH}/cache/romm_redis_data:/redis-data # Cached data for background tasks
      - ${VOLUME_PATH}/library:/romm/library # Your game library
      - ${VOLUME_PATH}/assets:/romm/assets # Uploaded saves, states, etc.
      - ${VOLUME_PATH}/config:/romm/config # Path where config.yml is stored
    ports:
      - 80:8080
    depends_on:
      - romm-db

  romm-db:
    image: linuxserver/mariadb:10.11.8
    container_name: romm-db
    restart: unless-stopped
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Etc/UTC
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD} # Use a unique, secure password
      - MYSQL_DATABASE=romm
      - MYSQL_USER=romm-user
      - MYSQL_PASSWORD=${DB_PASSWD}
    volumes:
      - ${VOLUME_PATH}/mariadb/config:/config

with .env file:

VOLUME_PATH="/chemin/avec des espaces"
DB_PASSWD=
MYSQL_ROOT_PASSWORD=
ROMM_AUTH_SECRET_KEY=
IGDB_CLIENT_ID=
IGDB_CLIENT_SECRET=
MOBYGAMES_API_KEY=
STEAMGRIDDB_API_KEY=

Calibre Web

https://github.com/janeczku/calibre-web

services:
  calibre-web:
    image: linuxserver/calibre-web
    container_name: calibre-web
    ports:
      - 8083:8083
    volumes:
      - ${VOLUME_PATH}/books:/app/calibre-web/books
      - ${VOLUME_PATH}/config:/config
    restart: unless-stopped

with .env file:

VOLUME_PATH="/chemin/avec des espaces"

Wanderer

Wanderer est une base de données de sentiers GPX (ou Kml) décentralisée et auto-hébergée. Vous pouvez télécharger vos trajets GPS enregistrés ou en créer de nouveaux et ajouter diverses métadonnées pour créer un catalogue facilement consultable.

x-common-env: &cenv
  MEILI_URL: http://search:7700
  MEILI_MASTER_KEY: ${MEILI_MASTER_KEY}

services:
  search:
    container_name: wanderer-search
    image: getmeili/meilisearch:v1.36.0
    environment:
      <<: *cenv
      MEILI_NO_ANALYTICS: "true"
    ports:
      - 7700:7700
    networks:
      - wanderer
    volumes:
      - ${WANDERER_DATA_DIR:-./data}/data.ms:/meili_data/data.ms
    restart: unless-stopped
    healthcheck:
      test: curl --fail http://localhost:7700/health || exit 1
      interval: 15s
      retries: 10
      start_period: 20s
      timeout: 10s
  db:
    container_name: wanderer-db
    image: flomp/wanderer-db
    depends_on:
      search:
        condition: service_healthy
    environment:
      <<: *cenv
      POCKETBASE_ENCRYPTION_KEY: ${POCKETBASE_ENCRYPTION_KEY}
      ORIGIN: ${WANDERER_ORIGIN:-http://localhost:3000}
      POCKETBASE_CRON_SYNC_SCHEDULE: ${POCKETBASE_CRON_SYNC_SCHEDULE}
    ports:
      - "8090:8090"
    networks:
      - wanderer
    restart: unless-stopped
    volumes:
      - ${WANDERER_DATA_DIR:-./data}/pb_data:/pb_data
    healthcheck:
      test: ["CMD", "/curl", "--fail", "http://localhost:8090/health"]
      interval: 15s
      retries: 10
      start_period: 20s
      timeout: 10s
  web:
    container_name: wanderer-web
    image: flomp/wanderer-web
    depends_on:
      search:
        condition: service_healthy
      db:
        condition: service_healthy
    environment:
      <<: *cenv
      ORIGIN: ${WANDERER_ORIGIN:-http://localhost:3000}
      BODY_SIZE_LIMIT: Infinity
      PUBLIC_POCKETBASE_URL: http://db:8090
      PUBLIC_DISABLE_SIGNUP: "false"
      UPLOAD_FOLDER: /app/uploads
      UPLOAD_USER: ${UPLOAD_USER:-}
      UPLOAD_PASSWORD: ${UPLOAD_PASSWORD:-}
      PUBLIC_OVERPASS_API_URL: https://overpass-api.de
      PUBLIC_VALHALLA_URL: https://valhalla1.openstreetmap.de
      PUBLIC_NOMINATIM_URL: https://nominatim.openstreetmap.org
    volumes:
      - ${WANDERER_DATA_DIR:-./data}/uploads:/app/uploads
      # - ${WANDERER_DATA_DIR:-./data}/about.md:/app/build/client/md/about.md
    ports:
      - "${WANDERER_WEB_PORT:-3000}:3000"
    networks:
      - wanderer
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "/curl", "--fail", "http://localhost:3000/"]
      interval: 15s
      retries: 10
      start_period: 20s
      timeout: 10s

networks:
  wanderer:
    driver: bridge

Fichier .env (README, doc) :

# Chemin des données de Wanderer
WANDERER_DATA_DIR="/chemin/vers/données/wanderer"

# URL exacte navigateur : protocole + hôte + port, sinon CORS.
# WANDERER_ORIGIN=http://localhost:3000
# Port sur l'hôte pour l'interface web. Doit être cohérent avec WANDERER_ORIGIN.
# WANDERER_WEB_PORT=3000

# MEILI_MASTER_KEY : en prod / instance exposée, clé obligatoire (pas celle du dépôt). Générer : openssl rand -hex 32
MEILI_MASTER_KEY=

# POCKETBASE_ENCRYPTION_KEY : base neuve — openssl rand -hex 16 avant le 1er lancement (doc Wanderer) ; ne pas changer après (déchiffrement cassé)
POCKETBASE_ENCRYPTION_KEY=

# POCKETBASE_CRON_SYNC_SCHEDULE : pas dans le compose d’origine ; expr. cron synchro PocketBase (décommenter si besoin)
# POCKETBASE_CRON_SYNC_SCHEDULE="0 */2 * * *"

# UPLOAD_USER / UPLOAD_PASSWORD : optionnel ; HTTP basic sur l’endpoint d’upload si renseignés
# UPLOAD_USER=
# UPLOAD_PASSWORD=

Monter un disque externe avant de lancer docker

J’utilise un disque externe pour stocker les données des services Docker. Le disque doit être monté avant docker.service. Un script automatise les unités .mount et le drop-in docker.service (After= / Requires=).

Script docker-pre-mount-disks.sh

chmod +x docker-pre-mount-disks.sh
sudo ./docker-pre-mount-disks.sh          # menu interactif
sudo ./docker-pre-mount-disks.sh list
sudo ./docker-pre-mount-disks.sh add      # liste + numéro ; chemin [défaut = montage actuel]
sudo ./docker-pre-mount-disks.sh remove   # liste des unités avec détail, puis numéro

Vérification après redémarrage :

sudo systemctl status media-…-.mount
sudo systemctl status docker

Référence manuelle (sans script)

Voici les étapes pour le faire :

(voir systemd.mount).