Déployer NetBox en réseau isolé avec Rocky Linux 8.10 et Podman

EdwardMoon

Déployer NetBox en réseau isolé consiste à collecter les paquets et images OCI sur un serveur connecté à Internet, à vérifier leur intégrité, puis à les importer dans l'environnement hors ligne. Copier uniquement les archives d'images conduit souvent à des échecs liés aux dépendances RPM de Podman, aux tags d'images, à l'initialisation de la base, à la sécurité ou au démarrage automatique.

Ce guide utilise Podman avec les privilèges root sur Rocky Linux 8.10 x86_64. Les versions de l'exemple, vérifiées le 20 juillet 2026, sont le conteneur NetBox v4.6.5-5.0.2, PostgreSQL 18-alpine et Valkey 9.1-alpine. Revérifiez toujours les notes de version officielles et les empreintes du registre avant d'importer un ensemble destiné à la production.

Prérequis et critères de validation

• Utilisez la même version mineure de Rocky Linux, la même architecture CPU et les mêmes dépôts activés sur le serveur de préparation et le serveur isolé.
• Utilisez des tags de version exacts plutôt que latest et consignez leurs empreintes.
• Téléchargez les RPM avec --resolve --alldeps pour inclure les dépendances déjà installées sur le serveur de préparation.
• Après la préparation en ligne, reproduisez l'installation hors ligne sur un serveur de test aux caractéristiques identiques.
• Ne mélangez pas Podman rootful et rootless en production. Toutes les commandes hors ligne de ce guide utilisent systématiquement sudo podman.

cat /etc/rocky-release
uname -m
sudo dnf repolist --enabled
sudo podman --version

Architecture NetBox en réseau isolé

Placez l'application web NetBox, son worker, PostgreSQL et deux instances Valkey distinctes pour les tâches et le cache dans un même pod. Les conteneurs du pod partagent un namespace réseau : l'application accède à la base et à Valkey via 127.0.0.1. Publiez uniquement le port NetBox 8080 sur le port hôte 8000.

netbox-pod
├── netbox             127.0.0.1:8080  ← host:8000
├── netbox-worker      RQ worker
├── netbox-postgres    127.0.0.1:5432
├── netbox-valkey      127.0.0.1:6379  (tasks)
└── netbox-valkey-cache 127.0.0.1:6380 (cache)

Si le réseau des conteneurs vous est peu familier, commencez par l'introduction pratique aux conteneurs du site.

Préparer l'ensemble hors ligne sur un serveur connecté

1. Fixer les versions et les chemins

Définissez des variables de version explicites afin de retrouver les mêmes tags après importation. Inclure les versions et l'architecture dans les noms de fichiers permet aussi de distinguer les ensembles conservés au même endroit.

NETBOX_TAG="v4.6.5-5.0.2"
POSTGRES_TAG="18-alpine"
VALKEY_TAG="9.1-alpine"
BUNDLE_ID="netbox-airgap-${NETBOX_TAG}-rocky8-$(uname -m)"
BUNDLE_ROOT="/opt/${BUNDLE_ID}"

sudo mkdir -p "${BUNDLE_ROOT}"/{rpms,images,env,scripts,manifests}
sudo chown -R "$(id -u):$(id -g)" "${BUNDLE_ROOT}"

2. Collecter les RPM de Podman et leurs dépendances

dnf download --resolve seul peut ignorer les paquets déjà installés sur le serveur de préparation. Ajoutez --alldeps pour un ensemble hors ligne. Des dépôts différents entre préparation et cible peuvent entraîner des problèmes de signature ou de dépendances : conservez aussi leur liste dans le manifeste.

sudo dnf install -y dnf-plugins-core

sudo dnf download --resolve --alldeps   --destdir="${BUNDLE_ROOT}/rpms"   podman tar gzip openssl

sudo dnf repolist --enabled > "${BUNDLE_ROOT}/manifests/dnf-repolist.txt"
rpm -Kv "${BUNDLE_ROOT}"/rpms/*.rpm   > "${BUNDLE_ROOT}/manifests/rpm-signatures.txt"

3. Télécharger et enregistrer les tags exacts des images

NetBox Docker publie des tags combinant la version de NetBox et celle des fichiers d'accompagnement netbox-docker. Utilisez des tags exacts en production et consignez l'empreinte et l'ID de chaque image juste après téléchargement. podman save préserve les couches et les tags ; à l'inverse, podman export aplatit le système de fichiers d'un conteneur.

podman pull "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"
podman pull "docker.io/postgres:${POSTGRES_TAG}"
podman pull "docker.io/valkey/valkey:${VALKEY_TAG}"

{
  podman image inspect --format 'netbox {{.Digest}} {{.Id}}'     "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"
  podman image inspect --format 'postgres {{.Digest}} {{.Id}}'     "docker.io/postgres:${POSTGRES_TAG}"
  podman image inspect --format 'valkey {{.Digest}} {{.Id}}'     "docker.io/valkey/valkey:${VALKEY_TAG}"
} > "${BUNDLE_ROOT}/manifests/image-digests.txt"

podman save --format oci-archive   -o "${BUNDLE_ROOT}/images/netbox.tar"   "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"
podman save --format oci-archive   -o "${BUNDLE_ROOT}/images/postgres.tar"   "docker.io/postgres:${POSTGRES_TAG}"
podman save --format oci-archive   -o "${BUNDLE_ROOT}/images/valkey.tar"   "docker.io/valkey/valkey:${VALKEY_TAG}"

4. Générer les fichiers d'environnement sans mots de passe par défaut

Ne publiez ni ne réutilisez jamais les mots de passe des exemples. Ces commandes génèrent des secrets aléatoires lors de la préparation en ligne et limitent les fichiers d'environnement au mode 600. Remplacez les adresses et noms de ALLOWED_HOSTS par ceux de votre réseau isolé.

umask 077

DB_PASSWORD="$(openssl rand -hex 24)"
VALKEY_PASSWORD="$(openssl rand -hex 24)"
VALKEY_CACHE_PASSWORD="$(openssl rand -hex 24)"
ADMIN_PASSWORD="$(openssl rand -hex 18)"
API_TOKEN_PEPPER_1="$(openssl rand -hex 32)"
SECRET_KEY="$(podman run --rm   "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"   python /opt/netbox/netbox/generate_secret_key.py)"

cat > "${BUNDLE_ROOT}/env/postgres.env" << EOF
POSTGRES_DB=netbox
POSTGRES_USER=netbox
POSTGRES_PASSWORD=${DB_PASSWORD}
EOF

cat > "${BUNDLE_ROOT}/env/valkey.env" << EOF
VALKEY_PASSWORD=${VALKEY_PASSWORD}
EOF

cat > "${BUNDLE_ROOT}/env/valkey-cache.env" << EOF
VALKEY_PASSWORD=${VALKEY_CACHE_PASSWORD}
EOF

cat > "${BUNDLE_ROOT}/env/netbox.env" << EOF
DB_HOST=127.0.0.1
DB_PORT=5432
DB_NAME=netbox
DB_USER=netbox
DB_PASSWORD=${DB_PASSWORD}

REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_DATABASE=0
REDIS_PASSWORD=${VALKEY_PASSWORD}
REDIS_SSL=false

REDIS_CACHE_HOST=127.0.0.1
REDIS_CACHE_PORT=6380
REDIS_CACHE_DATABASE=1
REDIS_CACHE_PASSWORD=${VALKEY_CACHE_PASSWORD}
REDIS_CACHE_SSL=false

SECRET_KEY=${SECRET_KEY}
API_TOKEN_PEPPER_1=${API_TOKEN_PEPPER_1}
ALLOWED_HOSTS=netbox.internal 10.20.30.40 localhost
TIME_ZONE=Asia/Seoul
LOGIN_REQUIRED=true
ISOLATED_DEPLOYMENT=true
CENSUS_REPORTING_ENABLED=false
COPILOT_ENABLED=false

SKIP_SUPERUSER=false
SUPERUSER_NAME=admin
SUPERUSER_EMAIL=netbox-admin@example.internal
SUPERUSER_PASSWORD=${ADMIN_PASSWORD}
EOF

chmod 600 "${BUNDLE_ROOT}"/env/*
printf 'admin password: %s
' "${ADMIN_PASSWORD}"   > "${BUNDLE_ROOT}/env/initial-admin-password.txt"
chmod 600 "${BUNDLE_ROOT}/env/initial-admin-password.txt"

Après la première connexion, changez le mot de passe administrateur, retirez SUPERUSER_PASSWORD de netbox.env et définissez SKIP_SUPERUSER=true. L'image officielle utilise SUPERUSER_NAME, et non SUPERUSER_USERNAME.

5. Créer le script de démarrage NetBox

Attendez que PostgreSQL et les deux instances Valkey soient prêts avant de démarrer l'application web et le worker NetBox. Pour respecter la configuration officielle, exécutez-les sous netbox:root et désactivez la création du superutilisateur dans le worker.

cat > "${BUNDLE_ROOT}/scripts/run-netbox-pod.sh" << 'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail

NETBOX_TAG="v4.6.5-5.0.2"
POSTGRES_TAG="18-alpine"
VALKEY_TAG="9.1-alpine"
BUNDLE_ROOT="/opt/netbox-airgap-${NETBOX_TAG}-rocky8-$(uname -m)"

NETBOX_ENV="${BUNDLE_ROOT}/env/netbox.env"
PG_ENV="${BUNDLE_ROOT}/env/postgres.env"
VALKEY_ENV="${BUNDLE_ROOT}/env/valkey.env"
VALKEY_CACHE_ENV="${BUNDLE_ROOT}/env/valkey-cache.env"

for file in "${NETBOX_ENV}" "${PG_ENV}" "${VALKEY_ENV}" "${VALKEY_CACHE_ENV}"; do
  [[ -r "${file}" ]] || { echo "[ERROR] missing ${file}" >&2; exit 1; }
done

if ! podman pod exists netbox-pod; then
  podman pod create --name netbox-pod -p 8000:8080
fi

for volume in netbox-postgres netbox-valkey-data netbox-valkey-cache-data               netbox-media-files netbox-reports-files netbox-scripts-files; do
  podman volume inspect "${volume}" >/dev/null 2>&1 || podman volume create "${volume}"
done

if ! podman container exists netbox-postgres; then
  podman run -d --name netbox-postgres --pod netbox-pod     --env-file "${PG_ENV}"     -v netbox-postgres:/var/lib/postgresql     "docker.io/postgres:${POSTGRES_TAG}"
fi

if ! podman container exists netbox-valkey; then
  podman run -d --name netbox-valkey --pod netbox-pod     --env-file "${VALKEY_ENV}"     -v netbox-valkey-data:/data     "docker.io/valkey/valkey:${VALKEY_TAG}"     sh -c 'valkey-server --appendonly yes --port 6379 --requirepass "$VALKEY_PASSWORD"'
fi

if ! podman container exists netbox-valkey-cache; then
  podman run -d --name netbox-valkey-cache --pod netbox-pod     --env-file "${VALKEY_CACHE_ENV}"     -v netbox-valkey-cache-data:/data     "docker.io/valkey/valkey:${VALKEY_TAG}"     sh -c 'valkey-server --port 6380 --requirepass "$VALKEY_PASSWORD"'
fi

dependencies_ready=0
for attempt in $(seq 1 90); do
  if podman exec netbox-postgres sh -c        'pg_isready -q -t 2 -d "$POSTGRES_DB" -U "$POSTGRES_USER"'     && podman exec netbox-valkey sh -c        'valkey-cli --pass "$VALKEY_PASSWORD" -p 6379 ping 2>/dev/null | grep -qx PONG'     && podman exec netbox-valkey-cache sh -c        'valkey-cli --pass "$VALKEY_PASSWORD" -p 6380 ping 2>/dev/null | grep -qx PONG'; then
    dependencies_ready=1
    break
  fi
  sleep 2
done

[[ "${dependencies_ready}" -eq 1 ]] || {
  echo "[ERROR] PostgreSQL or Valkey did not become ready" >&2
  exit 1
}

if ! podman container exists netbox; then
  podman run -d --name netbox --pod netbox-pod     --user netbox:root     --env-file "${NETBOX_ENV}"     -v netbox-media-files:/opt/netbox/netbox/media     -v netbox-reports-files:/opt/netbox/netbox/reports     -v netbox-scripts-files:/opt/netbox/netbox/scripts     "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"
fi

netbox_ready=0
for attempt in $(seq 1 120); do
  if podman exec netbox curl -fsS http://127.0.0.1:8080/login/ >/dev/null 2>&1; then
    netbox_ready=1
    break
  fi
  sleep 2
done

[[ "${netbox_ready}" -eq 1 ]] || {
  echo "[ERROR] NetBox did not become ready" >&2
  podman logs --tail 100 netbox >&2
  exit 1
}

if ! podman container exists netbox-worker; then
  podman run -d --name netbox-worker --pod netbox-pod     --user netbox:root     --env-file "${NETBOX_ENV}"     -e SKIP_SUPERUSER=true     -v netbox-media-files:/opt/netbox/netbox/media     -v netbox-reports-files:/opt/netbox/netbox/reports     -v netbox-scripts-files:/opt/netbox/netbox/scripts     "docker.io/netboxcommunity/netbox:${NETBOX_TAG}"     /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py rqworker
fi

podman pod ps
podman ps --pod
echo "NetBox: http://<server-ip>:8000"
SCRIPT

chmod 700 "${BUNDLE_ROOT}/scripts/run-netbox-pod.sh"

6. Créer un script d'arrêt et de réinitialisation préservant les données

Supprimer tous les conteneurs et volumes dont le nom contient postgres ou redis, comme le faisait une ancienne version de cet article, peut détruire les données d'autres services. Ce script cible les noms exacts des ressources NetBox et conserve les volumes de données par défaut.

cat > "${BUNDLE_ROOT}/scripts/reset-netbox-pod.sh" << 'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail

mode="${1:-keep-data}"

podman pod rm -f netbox-pod 2>/dev/null || true
podman rm -f netbox netbox-worker netbox-postgres   netbox-valkey netbox-valkey-cache 2>/dev/null || true

if [[ "${mode}" == "--delete-data" ]]; then
  read -r -p '데이터를 완전히 삭제하려면 DELETE-NETBOX-DATA 입력: ' answer
  [[ "${answer}" == "DELETE-NETBOX-DATA" ]] || {
    echo "취소했습니다."
    exit 1
  }

  for volume in netbox-postgres netbox-valkey-data netbox-valkey-cache-data                 netbox-media-files netbox-reports-files netbox-scripts-files; do
    podman volume rm -f "${volume}" 2>/dev/null || true
  done
else
  echo "컨테이너만 제거했습니다. 데이터 볼륨은 보존됩니다."
fi
SCRIPT

chmod 700 "${BUNDLE_ROOT}/scripts/reset-netbox-pod.sh"

7. Créer le manifeste SHA-256 et l'archive

chmod 600 "${BUNDLE_ROOT}"/env/*

(
  cd "${BUNDLE_ROOT}"
  find rpms images env scripts manifests -type f -print0     | sort -z     | xargs -0 sha256sum > SHA256SUMS
)

cd /opt
sudo tar --xattrs --selinux -czf "${BUNDLE_ID}.tar.gz" "${BUNDLE_ID}"
sudo sha256sum "${BUNDLE_ID}.tar.gz" > "${BUNDLE_ID}.tar.gz.sha256"

Installer NetBox hors ligne

1. Vérifier l'archive et son contenu

Contrôlez la somme SHA-256 externe avant d'extraire l'archive, puis vérifiez le manifeste à l'intérieur. Au moindre échec, interrompez l'installation et examinez le support de transfert et l'ensemble d'origine.

cd /opt
sudo sha256sum -c netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64.tar.gz.sha256
sudo tar --xattrs --selinux -xzf netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64.tar.gz

cd /opt/netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64
sudo sha256sum -c SHA256SUMS
sudo chown -R root:root .
sudo chmod 600 env/*

2. Installer Podman sans dépôts externes

cd /opt/netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64
sudo dnf install -y --disablerepo='*' ./rpms/*.rpm
sudo podman --version

En cas d'erreur de dépendances, n'ajoutez pas des RPM arbitraires au serveur isolé. Vérifiez que le serveur de préparation correspond au système cible, à son architecture et à ses dépôts, puis reconstruisez l'ensemble.

3. Charger les images OCI et vérifier les tags

cd /opt/netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64

sudo podman load -i images/netbox.tar
sudo podman load -i images/postgres.tar
sudo podman load -i images/valkey.tar

sudo podman images --digests   | grep -E 'netboxcommunity/netbox|postgres|valkey/valkey'
cat manifests/image-digests.txt

Ne démarrez pas l'application si les images chargées diffèrent du manifeste. Les images chargées en mode rootless ne sont pas visibles par sudo podman : chargez-les et exécutez-les dans le même contexte utilisateur.

4. Restreindre le pare-feu et démarrer l'application

L'exemple autorise le port TCP 8000 uniquement depuis le réseau d'administration 10.20.0.0/16. Remplacez-le par votre véritable sous-réseau. Configurer le pare-feu avant le démarrage des conteneurs limite le besoin de réappliquer leurs règles réseau.

sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="10.20.0.0/16" port protocol="tcp" port="8000" accept'
sudo firewall-cmd --reload

cd /opt/netbox-airgap-v4.6.5-5.0.2-rocky8-x86_64
sudo ./scripts/run-netbox-pod.sh

curl -fsS http://127.0.0.1:8000/login/ -o /dev/null
sudo podman pod ps
sudo podman ps --pod

Ouvrez http://<IP-du-serveur-isole>:8000 dans un navigateur. Pour une exploitation durable, évitez une large exposition du port 8000 et utilisez un proxy inverse interne avec TLS.

Configurer le démarrage automatique après redémarrage

Avant le passage à systemd ci-dessous, le script de démarrage crée de nouvelles ressources. Si des conteneurs arrêtés portant ces noms existent déjà, démarrez-les avec sudo podman pod start netbox-pod. Après le passage à systemd, utilisez systématiquement systemctl pour les démarrages et arrêts. Avant le script de réinitialisation, arrêtez le service gestionnaire avec sudo systemctl stop pod-netbox-pod.service.

La version de Podman des dépôts Rocky Linux 8.10 prend en charge la génération d'unités systemd. La sortie de --new est produite au mieux des possibilités : examinez chaque fichier avant installation. Cette commande est dépréciée dans Podman 5 ; privilégiez Quadlet pour une nouvelle plateforme.

unit_dir="$(mktemp -d)"
cd "${unit_dir}"
sudo podman generate systemd --new --files --name netbox-pod

sudo install -m 0644 ./*.service /etc/systemd/system/
sudo restorecon -Rv /etc/systemd/system

sudo podman pod rm -f netbox-pod
sudo systemctl daemon-reload
sudo systemctl enable --now pod-netbox-pod.service
sudo systemctl status pod-netbox-pod.service --no-pager

Sécuriser NetBox en réseau isolé

• Évitez ALLOWED_HOSTS=* ; indiquez uniquement les véritables FQDN, adresses IP et localhost.
• Générez des mots de passe aléatoires et limitez les fichiers d'environnement et de sauvegarde au mode 600.
• Changez le mot de passe administrateur après la première connexion et retirez le secret initial du fichier d'environnement.
• Restreignez le port 8000 au réseau d'administration et utilisez si possible un proxy TLS interne.
• Consignez les empreintes des images et le SHA-256 de l'ensemble complet avec les tags dans le dossier de validation.
• Vérifiez que le script de réinitialisation ne supprime que les ressources NetBox précisément nommées et n'exécute jamais automatiquement de prune global.

Vérifier les services et diagnostiquer les pannes

Examiner l'état et les journaux

sudo podman pod ps
sudo podman ps -a --pod

sudo podman logs --tail 100 netbox
sudo podman logs --tail 100 netbox-worker
sudo podman logs --tail 100 netbox-postgres
sudo podman logs --tail 100 netbox-valkey
sudo podman logs --tail 100 netbox-valkey-cache

sudo podman exec netbox   /opt/netbox/venv/bin/python /opt/netbox/netbox/manage.py version

Si les journaux remplissent le système de fichiers racine, ne supprimez pas des conteneurs sans discernement. Suivez la démarche de diagnostic No space left on device pour distinguer les blocs épuisés, les inodes épuisés et les fichiers supprimés encore ouverts.

Erreurs fréquentes et causes

sudo podman exec netbox-postgres sh -c   'pg_isready -d "$POSTGRES_DB" -U "$POSTGRES_USER"'

sudo podman exec netbox-valkey sh -c   'valkey-cli --pass "$VALKEY_PASSWORD" -p 6379 ping'

sudo podman network reload --all

NetBox effectue les migrations au démarrage du conteneur. N'exécutez manage.py migrate manuellement qu'en dernier recours, après vérification d'une sauvegarde de la base et de la compatibilité de la version de l'image.

Sauvegarde et restauration

Sauvegardez ensemble un dump PostgreSQL et le volume des médias avant toute mise à niveau ou tout redéploiement. Redis et Valkey contiennent les files de tâches et les caches ; PostgreSQL et les médias contiennent les données de référence. Conservez aussi les volumes scripts et reports selon les objectifs de récupération de l'organisation.

# Sauvegarder ensemble la base et les médias pendant une maintenance, écritures applicatives arrêtées.
sudo bash -euo pipefail <<'BASH'
backup_dir="/var/backups/netbox/$(date +%F-%H%M%S)"
install -d -m 0700 "$backup_dir"
umask 077
podman exec netbox-postgres pg_dump -U netbox -d netbox -Fc > "$backup_dir/netbox.dump"
test -s "$backup_dir/netbox.dump"
podman exec -i netbox-postgres pg_restore --list < "$backup_dir/netbox.dump" > "$backup_dir/dump-contents.txt"
podman volume export --output "$backup_dir/netbox-media-files.tar" netbox-media-files
(cd "$backup_dir" && sha256sum netbox.dump netbox-media-files.tar dump-contents.txt > SHA256SUMS && sha256sum -c SHA256SUMS)
BASH

Créer des fichiers de sauvegarde ne suffit pas. Testez régulièrement la restauration PostgreSQL et l'accès aux pièces jointes sur un serveur de test distinct.

Questions fréquentes

Pourquoi utiliser un pod pour NetBox en réseau isolé ?

Les conteneurs d'un pod partagent un namespace réseau : ils atteignent la base et Valkey sur 127.0.0.1, et les ports publiés sont gérés au même endroit. Si l'isolation des ressources ou une mise à l'échelle indépendante est prioritaire, envisagez des pods séparés ou un orchestrateur.

Quelles caractéristiques le serveur de préparation RPM doit-il reproduire ?

La configuration la plus sûre reprend Rocky Linux 8.10, l'architecture CPU et les dépôts activés de la cible. Utilisez --alldeps pour inclure les dépendances déjà présentes sur le serveur de préparation.

Puis-je utiliser le tag latest ?

Ce n'est pas recommandé. Un même tag peut pointer vers une autre image, rendant difficile la reproduction d'un ensemble approuvé. Consignez les tags exacts et les empreintes, puis validez chaque mise à niveau comme un nouvel ensemble distinct.

Conclusion

Un déploiement NetBox sécurisé en réseau isolé repose sur bien plus qu'une copie de fichiers. Fixez les versions, reproduisez les conditions des dépôts RPM, vérifiez les empreintes et SHA-256, protégez les secrets, ciblez précisément les suppressions et testez les restaurations. Ces mesures rendent le déploiement Podman reproductible, même sans accès Internet sur le serveur Rocky Linux.

Références officielles

• Dépôt officiel NetBox Docker et politique des tags
• Tags officiels des images NetBox Docker
• Documentation du module DNF download
• Documentation de Podman save
• Génération systemd dans Podman 4.4