# Proxmox VE 8 & Custom ISOs on Netcup Root-Server G12.5: Debian-to-PVE, LXC NAT & /64 IPv6 Guide

> Install Proxmox VE 8 on Netcup RS 2000 G12.5 (€31.35/mo net): nested KVM limits, Debian 12 conversion, vmbr1 NAT + /64 IPv6, LVM-Thin vs ZFS & PBS.

- Canonical URL: https://euserverlab.com/guides/proxmox-ve-custom-iso-netcup-root-server/
- Language: en
- Published: 2026-11-02 | Updated: 2026-11-22
- Publisher: EUServerLab (https://euserverlab.com/methodology/)

## Key Findings (TL;DR)
- Hardware virtualization flags (SVM/VM-x) are disabled across Netcup KVM guests: deploy Proxmox VE 8 for native-speed Linux LXC containers, TurnKey appliances, Docker-in-LXC (nesting=1,keyctl=1), and Proxmox Backup Server (PBS) — NOT nested Windows or QEMU VMs.
- Converting Netcup's official Debian 12 image to Proxmox VE 8 preserves VirtIO drivers and dual-stack routing while keeping storage on ext4 / LVM-Thin instead of RAM-hungry ZFS.
- Because Netcup filters MAC addresses on public ens3, route LXC IPv4 traffic via an internal vmbr1 (10.10.10.1/24) MASQUERADE bridge and assign globally routable /64 IPv6 addresses with net.ipv6.conf.all.forwarding=1.
- RS 2000 G12.5 (8 dedicated Zen 5 threads, 16 GB DDR5 ECC, 256 GB NVMe, €31.35/mo net Year-1 with #rs2) is the sweet spot for multi-LXC hosts; lock port 8006 behind WireGuard/Tailscale in SCP Firewall.

## Execution Checklist
1. **Verify Static /etc/hosts & Install Proxmox Kernel on Debian 12**: Deploy Debian 12 via Netcup SCP, map your public IPv4 to your FQDN in /etc/hosts, add the official Bookworm pve-no-subscription repo, install proxmox-default-kernel, and reboot via the SCP HTML5 KVM console.
2. **Install Proxmox VE 8 & Remove Stock Debian Kernel**: Run apt install proxmox-ve postfix open-iscsi chrony, then purge linux-image-amd64 and os-prober so GRUB always boots the PVE kernel.
3. **Configure vmbr1 IPv4 NAT + Routed /64 IPv6 Bridge**: Keep ens3 on your public IPs and define vmbr1 in /etc/network/interfaces with 10.10.10.1/24 MASQUERADE plus routed /64 IPv6 forwarding.
4. **Block Port 8006 in SCP Firewall & Schedule PBS Backups**: Drop public TCP 8006 in SCP Firewall (reach Web UI over WireGuard/Tailscale) and push nightly zstd vzdump backups to an off-site Proxmox Backup Server.

---

Netcup's Server Control Panel (SCP) provides free custom `.iso` mounting (for **Talos Linux**, **NixOS**, **FreeBSD**, or **Proxmox Backup Server**) alongside an out-of-band HTML5 KVM console. Before installing **Proxmox VE 8** on [Netcup RS 2000 G12.5](/models/rs-2000-g12-5/) (`€31.35/mo` net Year-1 with `#rs2`, 8 dedicated AMD EPYC™ 9645 or 9655 Zen 5 threads, `16 GB` DDR5 ECC, `256 GB` NVMe) or [RS 1000 G12.5](/models/rs-1000-g12-5/) (`€15.22/mo` net with `#rs1`), note one non-negotiable architectural boundary: **nested hardware virtualization (`SVM` / `VM-x`) is disabled across Netcup KVM guests** (`grep -cwE 'svm|vmx' /proc/cpuinfo` returns `0`).

Use Proxmox VE 8 on Netcup strictly for **Linux LXC system containers, TurnKey Linux appliances, unprivileged Docker-in-LXC (`nesting=1,keyctl=1`), and Proxmox Backup Server (PBS)** — all of which share the host Linux kernel at 100% native Zen 5 speed — **not** for nested Windows Server or QEMU VMs, which fall back to slow TCG software emulation (review our [0% Non-EU VAT guide](/guides/vat-free-registration-guide/) and [1-month CCP contract & cancellation rules](/guides/contract-and-cancellation-guide/) before ordering).

## 1. Storage Architecture: `ext4` / `LVM-Thin` vs. `ZFS` Inside a KVM Guest

Formatting `/dev/vda` as `ZFS (RAID0)` from the bare Proxmox ISO wastes up to half your DDR5 memory inside a virtualized guest because Netcup already runs enterprise NVMe hardware RAID (`6.87 GB/s` mixed sequential, `115.87 µs` 4K Q1T1 write) and Multi-bit ECC DDR5 on the physical hypervisor:

| Storage Metric | `ext4` + `LVM-Thin` (Recommended) | `ZFS (RAID0)` Inside KVM Guest |
| :--- | :--- | :--- |
| **Guest RAM Overhead** | **`~120–180 MB`** (keeps `15.5+ GB` free on `RS 2000`) | **`4–8 GB`** consumed by ZFS ARC (`zfs_arc_max` double-caching) |
| **Write Amplification** | **`~1.0x`** direct VirtIO pass-through to host NVMe RAID | **`2.5x–4.0x`** CoW + ZIL/checksum overhead atop virtual block device |
| **Snapshot Mechanism** | Instant `pct snapshot` (LVM-Thin) + **`€0` SCP CoW full-VM rollback** | `zfs snapshot` (duplicates hypervisor CoW at high RAM cost) |
| **Bit-Rot & Disk Redundancy** | Handled by Netcup datacenter NVMe RAID + host DDR5 ECC | Redundant guest checksums with zero physical SMART visibility |

## 2. Converting Clean Netcup Debian 12 (Bookworm) to Proxmox VE 8

Provisioning Netcup's official **Debian 12** image via SCP first and layering the Proxmox VE 8 packages on top keeps Netcup's VirtIO drivers and partition layout intact. Open an SSH session (with the **SCP HTML5 KVM console** open in a browser tab to watch the kernel reboot) and run:

```bash
# 1. Configure static FQDN & map your public IPv4 in /etc/hosts (replace IP and FQDN)
hostnamectl set-hostname pve01.example.com
cat <<'EOF' > /etc/hosts
127.0.0.1       localhost
203.0.113.42    pve01.example.com pve01
::1             localhost ip6-localhost ip6-loopback
EOF

# Verify: MUST print only 203.0.113.42 (never 127.0.1.1)
hostname --ip-address

# 2. Add official Proxmox VE Bookworm GPG key & pve-no-subscription repository
wget https://enterprise.proxmox.com/debian/proxmox-release-bookworm.gpg \
  -O /etc/apt/trusted.gpg.d/proxmox-release-bookworm.gpg
echo "deb [arch=amd64] http://download.proxmox.com/debian/pve bookworm pve-no-subscription" \
  > /etc/apt/sources.list.d/pve-install-repo.list

# 3. Upgrade Debian 12 & boot into the Proxmox kernel first
apt update && apt full-upgrade -y
apt install -y proxmox-default-kernel
systemctl reboot
```

Once the server comes back up on `6.8.x-pve` (check with `uname -r`), complete the PVE installation and clean up the stock Debian kernel so GRUB never scans LXC container filesystems:

```bash
# 4. Install Proxmox VE 8 stack (select 'Local only' when Postfix prompts)
apt install -y proxmox-ve postfix open-iscsi chrony

# 5. Remove stock Debian kernel meta-package & os-prober
apt remove -y linux-image-amd64 'linux-image-6.1*' os-prober
update-grub

# 6. Comment out paid enterprise repos to keep apt update clean on community nodes
sed -i 's/^deb/#deb/' /etc/apt/sources.list.d/pve-enterprise.list 2>/dev/null || true
sed -i 's/^deb/#deb/' /etc/apt/sources.list.d/ceph.list 2>/dev/null || true
apt update

# 7. Example: enable unprivileged Docker-in-LXC on container ID 101
# pct set 101 -features nesting=1,keyctl=1
```

## 3. Complete `/etc/network/interfaces`: `vmbr1` IPv4 NAT + Routed `/64` IPv6

Netcup enforces MAC filtering on your primary `ens3` switchport, so bridging LXC containers with random MACs directly onto `ens3` drops IPv4 packets. Leave `ens3` on the host, create an internal `vmbr1` bridge (`10.10.10.1/24`) using `iptables` (or `nftables`) `MASQUERADE` for IPv4 plus port `80/443` DNAT to a reverse-proxy LXC (`10.10.10.2`), and route your assigned `/64` IPv6 subnet natively to every container:

```ini
source /etc/network/interfaces.d/*

auto lo
iface lo inet loopback

# Primary Netcup VirtIO interface (replace IPv4, gateway, and /64 prefix with your SCP values)
auto ens3
iface ens3 inet static
    address 203.0.113.42/22
    gateway 203.0.112.1
    dns-nameservers 46.38.225.230 46.38.252.230 1.1.1.1

iface ens3 inet6 static
    address 2a03:4000:60:1234::1/128
    gateway fe80::1

# Internal LXC Bridge: Private IPv4 NAT + Globally Routable /64 IPv6
auto vmbr1
iface vmbr1 inet static
    address 10.10.10.1/24
    bridge-ports none
    bridge-stp off
    bridge-fd 0
    post-up   sysctl -w net.ipv4.ip_forward=1
    post-up   iptables -t nat -A POSTROUTING -s '10.10.10.0/24' -o ens3 -j MASQUERADE
    post-up   iptables -t nat -A PREROUTING -i ens3 -p tcp -m multiport --dports 80,443 -j DNAT --to-destination 10.10.10.2
    post-up   iptables -t raw -I PREROUTING -i fwbr+ -j CT --zone 1
    post-down iptables -t nat -D POSTROUTING -s '10.10.10.0/24' -o ens3 -j MASQUERADE
    post-down iptables -t nat -D PREROUTING -i ens3 -p tcp -m multiport --dports 80,443 -j DNAT --to-destination 10.10.10.2
    post-down iptables -t raw -D PREROUTING -i fwbr+ -j CT --zone 1

iface vmbr1 inet6 static
    address 2a03:4000:60:1234::2/64
    post-up   sysctl -w net.ipv6.conf.all.forwarding=1
    post-up   sysctl -w net.ipv6.conf.ens3.accept_ra=2
```

Inside each Proxmox LXC container attached to `vmbr1`, set IPv4 to `10.10.10.X/24` (gateway `10.10.10.1`) and IPv6 to `2a03:4000:60:1234::X/64` (gateway `2a03:4000:60:1234::2`), then apply changes live on the host with `ifreload -a`.

## 4. SCP Firewall Lockdown for Port `8006` & Off-Site `vzdump` / PBS Backups

Never expose Proxmox's `pveproxy` management API (`TCP 8006`) or `spiceproxy` (`TCP 3128`) to the public internet. Install WireGuard or Tailscale on the Proxmox host, verify you can load `https://10.10.10.1:8006` (or `https://100.x.y.z:8006`) over the encrypted tunnel, and lock down **Netcup SCP → Firewall**:

| SCP Firewall Rule | Protocol & Port | Source | Action | Purpose |
| :--- | :--- | :--- | :--- | :--- |
| Public Web Ingress | `TCP 80`, `TCP/UDP 443` | `0.0.0.0/0`, `::/0` | `ACCEPT` | DNAT to Caddy/Nginx reverse-proxy LXC (`10.10.10.2`) |
| Admin VPN Tunnel | `UDP 51820` / `UDP 41641` | `0.0.0.0/0`, `::/0` | `ACCEPT` | WireGuard or Tailscale peer ingress |
| Proxmox Web UI & SSH | `TCP 8006, 3128, 22, 111` | `0.0.0.0/0`, `::/0` | **`DROP`** | Blocks all public scans against PVE API, RPC, and SSH |

Pair local `€0` SCP snapshots with encrypted off-site container backups using **Proxmox Backup Server (PBS)** or `vzdump` over Netcup's EU/US `2.5 Gbps` fair-use link (throttled to `300 Mbps` only if rolling 24h traffic exceeds `3 TB` on Root-Servers, while Singapore `SIN` runs at `1 Gbps` with `2–4 TB/mo` monthly quotas — for example, pushing from Nuremberg to a secondary PBS node in Vienna):

```bash
# Attach an off-site Proxmox Backup Server with client-side AES-256-GCM encryption
pvesm add pbs pbs-vienna \
  --server pbs.vpn.example.com \
  --datastore rs2000-lxc \
  --username 'backup@pbs!rs2000' \
  --password 'REPLACE_WITH_PBS_API_TOKEN' \
  --fingerprint 'AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33:44:55:66:77:88:99' \
  --encryption-key autogen

# Export /etc/pve/priv/storage/pbs-vienna.enc to your password vault immediately!
# Run an on-demand zstd snapshot backup across all LXC guests (schedule nightly in Datacenter -> Backup)
vzdump --all 1 --storage pbs-vienna --mode snapshot --compress zstd
```

Compare memory tiers across [RS 1000 G12.5](/guides/rs-1000-g12-5-review/), [RS 2000 G12.5](/guides/rs-2000-g12-5-review/), and [RS 4000 G12.5](/models/rs-4000-g12-5/) in our [Workload Sizer](/tools/server-sizer/), then claim a verified `#rs2` or `#rs1` voucher below.

## Frequently Asked Questions

### Does Netcup support nested KVM virtualization (SVM/VM-x) for Windows VMs inside Proxmox?

No. Both Netcup shared VPS and dedicated Root-Server KVM guests keep hardware virtualization extensions (SVM/VM-x) disabled so hypervisors can maintain live host migration. Inside Proxmox on Netcup, Linux LXC containers share the host kernel and execute at 100% native Zen 5 speed, whereas nested QEMU/Windows VMs fall back to slow TCG software emulation.

### Should I mount the Proxmox ISO or convert Netcup's Debian 12 image to Proxmox VE 8?

For Proxmox VE 8, converting Netcup's clean Debian 12 Bookworm image is faster and safer because VirtIO block/net drivers, partitioning, and IPv6 routing work out of the box. Reserve SCP Media custom ISO uploads for Talos Linux, NixOS, FreeBSD, or standalone Proxmox Backup Server appliances.

### Why use ext4 / LVM-Thin instead of ZFS on a Netcup Root-Server?

Netcup already backs /dev/vda with datacenter hardware NVMe RAID (6.87 GB/s mixed throughput) and host Multi-bit ECC DDR5 RAM. Running ZFS inside the guest consumes 4 to 8 GB of RAM for a duplicate ARC cache and multiplies write amplification, whereas ext4 / LVM-Thin plus €0 SCP Copy-on-Write snapshots give instant rollbacks with minimal overhead.

### How do I expose web services on LXC containers with a single public IPv4 address?

Attach LXC containers to an internal bridge vmbr1 (10.10.10.0/24) with iptables or nftables MASQUERADE for outbound IPv4, run Caddy or Nginx at 10.10.10.2 (with DNAT on TCP 80/443) for inbound domains, and route native public IPv6 addresses directly from your assigned /64 subnet.

---
Source: EUServerLab (https://euserverlab.com/guides/proxmox-ve-custom-iso-netcup-root-server/) | Open Telemetry Dataset: https://euserverlab.com/benchmarks/vps-500-g12-5.json
