Initial commit: image Dopbase à partir du binaire officiel (étapes de install.sh)

This commit is contained in:
claude Bot committed 2026-11-10 17:45:17 +01:00
commit c5f32b71f7
5 files changed
+200

No files matched your search

+6
View File
@@ -0,0 +1,6 @@
# cp .env.example .env
DOPBASE_VERSION=0.1.10
DOPBASE_PORT=8840
DOPBASE_PUBLIC_URL=http://localhost:8840
# DOPBASE_ROOT_EMAIL=admin@example.com
# DOPBASE_TRUSTED_PROXIES=172.16.0.0/12
+1
View File
@@ -0,0 +1 @@
.env
+65
View File
@@ -0,0 +1,65 @@
# Dopbase : image a partir du binaire officiel des releases GitHub.
# Reprend les etapes de https://dopbase.com/install.sh (sans la telemetrie Umami) :
# resolution de version -> checksums.txt -> archive -> SHA-256 -> extraction du seul membre
# "dopbase" -> controle "dopbase --version".
# Le binaire Linux est un executable musl statique (static-pie) : aucune dependance glibc.
# Tag de release (sans prefixe v, ex: 0.1.10) ou "latest"
ARG DOPBASE_VERSION=0.1.10
# --- 1. Telechargement et verification ---------------------------------------
FROM alpine:3.22 AS fetch
ARG DOPBASE_VERSION
ARG TARGETARCH
RUN apk add --no-cache curl
WORKDIR /tmp/dl
RUN set -eu; \
repo="https://github.com/dopbase/dopbase"; \
dl() { curl --fail --show-error --silent --location --connect-timeout 10 --retry 3 "$@"; }; \
# Architecture : TARGETARCH (buildx) sinon uname -m
case "${TARGETARCH:-$(uname -m)}" in \
amd64|x86_64) arch=amd64 ;; \
arm64|aarch64) arch=arm64 ;; \
*) echo "Architecture non supportee : ${TARGETARCH:-$(uname -m)}" >&2; exit 1 ;; \
esac; \
# Version : figee, ou resolue via la redirection de /releases/latest
if [ "${DOPBASE_VERSION}" = latest ]; then \
tag=$(dl --head --output /dev/null --write-out '%{url_effective}' "${repo}/releases/latest"); \
tag=${tag##*/}; \
else \
tag=${DOPBASE_VERSION}; \
fi; \
version=${tag#v}; \
echo "${version}" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+$' || { echo "Version invalide : ${tag}" >&2; exit 1; }; \
archive="dopbase_${version}_linux_${arch}.tar.gz"; \
base="${repo}/releases/download/${tag}"; \
dl --output checksums.txt "${base}/checksums.txt"; \
expected=$(awk -v a="${archive}" '$2 == a { n++; c = $1 } END { if (n != 1 || length(c) != 64) exit 1; print c }' checksums.txt); \
dl --output "${archive}" "${base}/${archive}"; \
echo "${expected} ${archive}" | sha256sum -c -; \
tar -tzf "${archive}" | grep -qx dopbase; \
tar -xOzf "${archive}" dopbase > /tmp/dopbase; \
chmod 755 /tmp/dopbase; \
reported=$(/tmp/dopbase --version); \
[ "${reported}" = "v${version}" ] || { echo "Attendu v${version}, le binaire annonce ${reported}" >&2; exit 1; }
# --- 2. Runtime --------------------------------------------------------------
FROM alpine:3.22
# UID 10001 identique a la variante "src" : le volume /data est interchangeable.
RUN apk add --no-cache ca-certificates \
&& addgroup -S -g 10001 dopbase \
&& adduser -S -D -H -u 10001 -G dopbase -h /data -s /sbin/nologin dopbase \
&& mkdir /data && chown dopbase:dopbase /data
COPY --from=fetch /tmp/dopbase /usr/local/bin/dopbase
ENV DOPBASE_DATA_DIR=/data \
DOPBASE_HOST=0.0.0.0 \
DOPBASE_PORT=8840
USER dopbase
VOLUME ["/data"]
EXPOSE 8840
ENTRYPOINT ["dopbase"]
CMD ["server", "start"]
+94
View File
@@ -0,0 +1,94 @@
# dopbase-docker-binaire
Déploiement de [Dopbase](https://github.com/dopbase/dopbase) en docker-compose à partir du **binaire officiel** publié dans les releases GitHub. L'image reproduit les étapes de l'installeur officiel `https://dopbase.com/install.sh`, sans sa télémétrie.
Variante « compilée depuis les sources » : [dopbase-docker-src](https://gitea.vlab.bzh/vLab-BZH/dopbase-docker-src).
## Contenu
| Fichier | Rôle |
|---|---|
| `Dockerfile` | Téléchargement et vérification du binaire, puis image runtime Alpine |
| `docker-compose.yml` | Service `dopbase`, volume `dopbase-data`, healthcheck HTTP |
| `.env.example` | Variables à copier dans `.env` |
## Installation
```bash
git clone git@gitea.vlab.bzh:vLab-BZH/dopbase-docker-binaire.git
cd dopbase-docker-binaire
cp .env.example .env
# éditer .env : DOPBASE_VERSION, DOPBASE_PUBLIC_URL, etc.
docker compose up -d --build
```
Les tags upstream n'ont **pas** de préfixe `v` : `DOPBASE_VERSION=0.1.10`. La valeur `latest` résout la dernière release au moment du build. Une version figée reste recommandée pour des builds reproductibles.
Le build prend quelques secondes : seul un téléchargement d'environ 9 Mo est nécessaire.
### Premier démarrage
```bash
docker compose logs dopbase
```
Au premier démarrage, Dopbase affiche dans les logs un token / lien de setup. L'interface d'admin redirige vers `/setup` tant que le compte root n'est pas créé.
Alternative : renseigner `DOPBASE_ROOT_EMAIL` dans `.env` avant le premier démarrage. Le compte root est alors créé directement, avec un mot de passe généré affiché **une seule fois** dans les logs.
### Vérification
```bash
docker compose ps # état healthy attendu
curl http://localhost:8840/api/v1/health
```
## Variables (`.env`)
| Variable | Défaut | Description |
|---|---|---|
| `DOPBASE_VERSION` | `0.1.10` | Tag de release à installer, ou `latest` |
| `DOPBASE_PORT` | `8840` | Port publié sur l'hôte |
| `DOPBASE_PUBLIC_URL` | `http://localhost:8840` | URL vue par les clients (lien de setup, CLI). À adapter derrière un reverse proxy |
| `DOPBASE_ROOT_EMAIL` | vide | Optionnel : crée le root sans passer par le setup web |
| `DOPBASE_TRUSTED_PROXIES` | vide | IP/CIDR du reverse proxy, pour des logs d'audit corrects |
## Architecture du Dockerfile
Build multi-stage en 2 étapes :
```
┌────────────────────────────────┐ ┌─────────────────────────┐
│ 1. fetch (alpine + curl) │ │ 2. runtime (alpine) │
│ checksums.txt + archive .tar.gz │ ──▶ │ ca-certificates │
│ SHA-256, extraction, --version │ │ user dopbase (10001) │
└────────────────────────────────┘ └─────────────────────────┘
```
1. **fetch**, équivalent de `install.sh` :
- choix de l'architecture via `TARGETARCH` (buildx) ou `uname -m` : `amd64` ou `arm64` ;
- résolution de la version (figée, ou `latest` via la redirection `releases/latest`) ;
- téléchargement de `checksums.txt` puis de `dopbase_<version>_linux_<arch>.tar.gz` ;
- vérification SHA-256 de l'archive ;
- extraction du seul membre `dopbase` (`tar -xOzf`), sans restaurer chemins ni permissions ;
- contrôle que `dopbase --version` renvoie exactement `v<version>`.
2. **runtime** : Alpine avec `ca-certificates` (nécessaire pour les appels sortants, OIDC par exemple), binaire dans `/usr/local/bin/dopbase`, exécution en utilisateur non-root `dopbase` (UID 10001, identique à la variante src). Écoute sur `0.0.0.0:8840`, données dans `/data`. Commande : `dopbase server start`.
Le binaire Linux officiel est un exécutable **musl statique** (`static-pie`, cible `x86_64-unknown-linux-musl`) : il n'a aucune dépendance glibc et tourne sur Alpine. L'UI d'admin Vue est embarquée dans le binaire.
Différences avec `install.sh` : pas de télémétrie Umami, pas d'installation dans `~/.local/bin`.
## Données et sauvegarde
Le volume `dopbase-data` (`/data`) contient la base SQLite, `master.key` et les sauvegardes `.dop`. Sauvegarder le volume, et conserver `master.key` **séparément** de la base.
## Exposition réseau
Par défaut le port est publié sur toutes les interfaces de l'hôte. Pour un accès réseau, placer un reverse proxy TLS devant (recommandé par la doc upstream) et renseigner `DOPBASE_PUBLIC_URL` et `DOPBASE_TRUSTED_PROXIES`. Pour limiter à l'hôte local, préfixer le mapping par `127.0.0.1:` dans `docker-compose.yml`.
## Mise à jour
```bash
# changer DOPBASE_VERSION dans .env, puis
docker compose up -d --build
```
+34
View File
@@ -0,0 +1,34 @@
services:
dopbase:
build:
context: .
args:
# tag de release dopbase/dopbase, sans prefixe v (ex: 0.1.10), ou "latest"
DOPBASE_VERSION: ${DOPBASE_VERSION:-0.1.10}
image: dopbase:bin-${DOPBASE_VERSION:-0.1.10}
container_name: dopbase
restart: unless-stopped
ports:
# Publie sur toutes les interfaces de l'hote. Prefixer par "127.0.0.1:" pour limiter a l'hote,
# et mettre un reverse proxy TLS devant pour tout acces reseau (recommande par la doc).
- "${DOPBASE_PORT:-8840}:8840"
environment:
# URL que les clients utilisent (lien de setup, CLI). A adapter si reverse proxy.
DOPBASE_PUBLIC_URL: ${DOPBASE_PUBLIC_URL:-http://localhost:8840}
# Optionnel : cree root sans passer par le setup web (mot de passe genere, affiche UNE fois dans les logs).
# Laisser vide pour utiliser le lien de setup web affiche dans les logs au premier demarrage.
DOPBASE_ROOT_EMAIL: ${DOPBASE_ROOT_EMAIL:-}
# Si un reverse proxy tourne devant (IP/CIDR du proxy), pour des logs d'audit corrects.
DOPBASE_TRUSTED_PROXIES: ${DOPBASE_TRUSTED_PROXIES:-}
volumes:
# SQLite + master.key + backups (.dop) : a sauvegarder, la cle separement de la base.
- dopbase-data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8840/api/v1/health"]
interval: 30s
timeout: 5s
retries: 3
start_period: 20s
volumes:
dopbase-data: