Gids voor het opzetten van NetBox in een afgesloten netwerk: Rocky Linux 8.10 + Podman-containerbundel

AI_Manager

Het opzetten van NetBox in een afgesloten netwerk is een proces waarbij pakketten en OCI-images worden verzameld op een server met internettoegang, waarna de integriteit wordt gecontroleerd voordat ze naar een offline server worden overgebracht. Het simpelweg kopiëren van image-bestanden leidt vaak tot fouten bij de Podman-afhankelijke RPM’s, image-tags, database-initialisatie, beveiligingsinstellingen en het automatisch opstarten na een herstart.

Deze gids is gebaseerd op rootful Podman op Rocky Linux 8.10 x86_64. De voorbeeldversies die op 20 juli 2026 zijn gecontroleerd, zijn NetBox-container v4.6.5-5.0.2, PostgreSQL 18-alpine en Valkey 9.1-alpine. Controleer vóór implementatie in productie altijd de officiële release notes en de digests in het register.

Voorwaarden en verificatiecriteria voor het opzetten van NetBox in een afgesloten netwerk.

• Zorg dat de Rocky Linux-minorversie, CPU-architectuur en actieve repositories van de bundelserver overeenkomen met die van de server in het afgesloten netwerk.
• Gebruik voor container-images de exacte versietag in plaats van latest en leg de digest vast.
• Download voor RPM’s ook de reeds geïnstalleerde afhankelijkheden met --resolve --alldeps.
• Maak de bundel in een online omgeving en simuleer vervolgens de offline installatie op een testserver met identieke condities.
• Combineer in productie geen rootful en rootless Podman. Dit artikel hanteert voor alle opdrachten in het afgesloten netwerk uitsluitend sudo podman.

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

Architectuur voor NetBox in een afgesloten netwerk

Plaats de NetBox-webserver en worker, PostgreSQL, Valkey voor taken en Valkey voor cache in één Pod. Omdat containers in dezelfde Pod een netwerk-namespace delen, kan de applicatie de database en Valkey benaderen via 127.0.0.1. Extern wordt alleen de 8080 van NetBox gepubliceerd op host 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)

Als u niet bekend bent met het concept van containernetwerken, kunt u eerst onze interne handleiding Containerconcepten in de praktijk raadplegen.

Online bundel maken voor NetBox in een afgesloten netwerk

1. Versie- en directory-fixatie

Zet versies vast als variabelen zodat dezelfde tags na overdracht kunnen worden gereproduceerd. Door versies en architectuur in de bestandsnaam op te nemen, voorkomt u verwarring bij het bewaren van meerdere bundels.

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. Podman RPM en afhankelijkheden verzamelen

Door alleen dnf download --resolve te gebruiken, kunt u pakketten overslaan die al op de productieserver zijn geïnstalleerd. Voor een bundel in een afgesloten netwerk moet u echter --alldeps gebruiken. Omdat de actieve repositories van de productieserver en de doelserver kunnen verschillen, wat kan leiden tot problemen met handtekeningen of afhankelijkheden, moet u ook de lijst met repositories in het manifest bewaren.

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. Exacte image-tags pullen en opslaan

NetBox Docker biedt tags die de NetBox-versie combineren met de versie van de netbox-docker-ondersteuningsbestanden. Gebruik voor productie de exacte tag en noteer de digest en image-ID direct na het pullen. podman save behoudt image-layers en tags, wat verschilt van podman export, dat alleen het container-bestandssysteem afvlakt.

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. Omgevingsbestand aanmaken zonder standaardwachtwoorden

Publiceer of hergebruik nooit voorbeeldwachtwoorden. Het onderstaande commando genereert tijdens het maken op het online systeem een willekeurig getal en beperkt de rechten van het omgevingsbestand tot 600. Pas het adres en de naam in ALLOWED_HOSTS aan aan de werkelijke omgeving van het afgesloten netwerk.

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"

Wijzig na de eerste keer inloggen het beheerderswachtwoord en verwijder de SUPERUSER_PASSWORD uit netbox.env, waarna u deze vervangt door SKIP_SUPERUSER=true voor de veiligheid. De variabelenaam in de officiële image is SUPERUSER_NAME en niet SUPERUSER_USERNAME.

5. Opstartscript voor NetBox-implementatie in een afgesloten netwerk

Start de NetBox-webinterface en worker nadat u heeft gecontroleerd of PostgreSQL en de twee Valkey-instanties gereed zijn. Om aan te sluiten bij de officiële configuratie worden de webinterface en worker uitgevoerd als de gebruiker netbox:root, waarbij het aanmaken van een superuser in de worker wordt overgeslagen.

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. Script voor het stoppen en initialiseren met behoud van gegevens

Zoals in eerdere artikelen vermeld, kan het verwijderen van alle containers en volumes die postgres of redis in hun naam bevatten, leiden tot het verlies van gegevens van andere services op dezelfde server. Het onderstaande script richt zich uitsluitend op de specifieke NetBox-resources en behoudt bij standaarduitvoering de datavolumes.

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. SHA-256 manifest en archiefbestand aanmaken

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"

NetBox-implementatie in een afgesloten netwerk: offline installatie

1. Integriteitscontrole van het archiefbestand en interne bestanden

Controleer de externe SHA-256-waarde voordat u het bestand uitpakt en verifieer het manifest in de bundel na de implementatie. Als er ook maar één controle mislukt, installeer dan niet en controleer het overdrachtsmedium en de originele bundel opnieuw.

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. Podman installeren zonder externe repository

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

Voeg bij afhankelijkheidsfouten geen willekeurige RPM’s toe in het afgesloten netwerk, maar controleer of het OS, de architectuur en de actieve repositories van de online productieserver overeenkomen met die van de doelserver en maak de bundel opnieuw aan.

3. OCI-image laden en tagverificatie

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

Start niet als het resultaat van het laden afwijkt van het manifest. Images die rootless zijn geladen, zijn niet zichtbaar in sudo podman, dus de gebruiker die de image laadt en de gebruiker die deze uitvoert, moeten overeenkomen.

4. Eerste opstart na firewall-beperkingen

Het voorbeeld staat TCP 8000-toegang alleen toe vanaf het beheernetwerk 10.20.0.0/16. Pas dit aan naar de werkelijke reeks van uw beheernetwerk. Door de firewall eerst te configureren en daarna de container te starten, kunt u problemen met netwerktoepassing verminderen.

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

Maak in de browser verbinding via http://<폐쇄망 서버 IP>:8000. Voor langdurig gebruik is het veiliger om poort 8000 niet breed open te stellen, maar een interne reverse proxy met TLS toe te passen.

Configuratie voor automatisch opstarten na herstart

Totdat de onderstaande systemd-conversie is voltooid, is het opstartscript bedoeld voor het aanmaken van nieuwe resources. Als er een gestopte container met dezelfde naam bestaat, start deze dan eerst met sudo podman pod start netbox-pod. Na de overstap naar systemd moet het starten en stoppen worden beheerd via systemctl, en moet u de beheerservices eerst stoppen met sudo systemctl stop pod-netbox-pod.service voordat u het initialisatiescript uitvoert.

In Podman op Rocky Linux 8.10 kunnen de gegenereerde systemd-units worden gebruikt. Het resultaat van --new wordt op ‘best-effort’-basis gegenereerd, dus controleer altijd de inhoud van het bestand voordat u het installeert. Aangezien dit commando in de Podman 5-serie als verouderd wordt beschouwd, dient u voor nieuwe platforms eerst Quadlet te overwegen.

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

Beveiligingscontrole voor NetBox-implementatie in een afgesloten netwerk

• Gebruik geen ALLOWED_HOSTS=*, maar specificeer alleen de werkelijke FQDN/IP en localhost.
• Gebruik geen standaardwachtwoorden uit voorbeelden, genereer willekeurige getallen en beperk de rechten van omgevings- en back-upbestanden tot 600.
• Wijzig na de eerste keer inloggen het beheerderswachtwoord en verwijder het initiële superuser-wachtwoord uit het omgevingsbestand.
• Beperk de firewall zodat poort 8000 alleen toegankelijk is vanuit het beheernetwerk en gebruik indien mogelijk een interne TLS-proxy.
• Leg niet alleen de image-tag vast, maar ook de digest en de SHA-256-waarde van de volledige bundel in het goedkeuringslogboek.
• Het initialisatiescript verwijdert alleen de specifieke NetBox-resources en voert niet automatisch een globale prune uit.

Statusverificatie en probleemoplossing bij NetBox-implementatie in een afgesloten netwerk

Controle van de basisstatus en logboeken

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

Als het root-bestandssysteem vol raakt door logboeken, verwijder dan niet zomaar containers, maar volg de diagnoseprocedure voor ‘No space left on device’ om eerst onderscheid te maken tussen blokken, inodes en verwijderde geopende bestanden.

Veelvoorkomende fouten en oorzaken

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

Migraties worden uitgevoerd tijdens het opstartproces van de NetBox-container. Handmatige manage.py migrate mag alleen als laatste redmiddel worden uitgevoerd nadat databaseback-ups en de compatibiliteit van de afbeeldingsversie zijn gecontroleerd.

Back-up en herstel

Maak vóór upgrades of herimplementaties een back-up van zowel de PostgreSQL-dump als de media-volumes. Aangezien Redis/Valkey worden gebruikt voor werkrijen en caching, zijn de essentiële brongegevens PostgreSQL en media, maar bewaar ook de scripts- en reports-volumes afhankelijk van de hersteldoelstellingen van de organisatie.

# Bewaar DB en media als één set in een wijzigingsvenster waarin applicatieschrijven is gestopt.
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

Het maken van back-upbestanden is niet voldoende. Controleer regelmatig het herstel van PostgreSQL en de toegang tot bijgevoegde bestanden op een afzonderlijke testserver.

Veelgestelde vragen

Waarom Pods gebruiken voor het bouwen van NetBox in een afgesloten netwerk?

Omdat containers in een Pod een netwerk-namespace delen, kunnen ze DB en Valkey verbinden via 127.0.0.1 en is het eenvoudig om externe openbare poorten op één plek te beheren. Als resource-isolatie en onafhankelijke schaalbaarheid echter belangrijker zijn, overweeg dan een afzonderlijke Pod of orchestrator-configuratie.

Wat zijn de vereisten voor een server die RPM’s maakt voor een afgesloten NetBox-omgeving?

De veiligste optie is dezelfde Rocky Linux 8.10, dezelfde CPU-architectuur en dezelfde actieve opslagplaatsen als de doelserver. Gebruik --alldeps om ook de afhankelijkheden op te nemen die al op de productieserver zijn geïnstalleerd.

Kan ik de latest-tag gebruiken?

Dit wordt niet aanbevolen. Omdat dezelfde naam naar een andere afbeelding kan verwijzen, is het moeilijk om een goedgekeurde bundel te reproduceren. Noteer de exacte versietag samen met de digest en voer upgrades uit door ze in een nieuwe bundel te scheiden en te valideren.

Samenvatting

Een veilige implementatie van NetBox in een afgesloten netwerk draait niet alleen om het kopiëren van bestanden, maar om versiebeheer, identieke RPM-opslagplaatscondities, afbeeldings-digests en SHA-256-verificatie, beheer van geheimen, nauwkeurige verwijderingsbereiken en het testen van back-up en herstel. Door deze volgorde te volgen, kunt u een op Podman gebaseerde NetBox reproduceerbaar beheren, zelfs in een Rocky Linux-omgeving zonder internet.

Officiële referentiedocumentatie

• Officiële NetBox Docker-repository en beleid voor afbeeldingstags
• Officiële NetBox Docker-afbeeldingstags
• Documentatie voor de DNF-download-plug-in
• Documentatie voor Podman save
• Documentatie voor het genereren van systemd met Podman 4.4