Anwendungsbereitstellung

Produktionsreife Docker- und Compose-Architektur in der Praxis: Container-Orchestrierung, Speicher und Sicherheit auf optimiertem VPS-Hosting im Ausland

VPSMap-Redaktion · Aktualisiert 2026-09-26 · 32 Min. Lesezeit · Nur-Text-Version

Für Workloads im Ausland und grenzüberschreitende Workloads sind containerisierte Architekturen auf leistungsstarken Cloud-Servern mit optimierten Routen wie CN2 GIA, CMIN2 und AS9929, einschließlich BandwagonHost und DMIT, zur Standardpraxis für moderne Webdienste geworden. Diese VPS-Tarife bieten oft sehr geringen Netzwerk-Jitter und NVMe-Speicher mit hohem Durchsatz, aber auf typischen schlanken Produktionsknoten (in der Regel 14 vCPU CPU, 14GB Arbeitsspeicher und 20~80GB Speicher) kann das Kopieren von Standardeinstellungen aus der lokalen Entwicklung bei der Docker-Bereitstellung kaskadierende Systemausfälle verursachen: Unkontrollierte Container-Protokolle füllen die Systemfestplatte, Docker ändert stillschweigend iptables-Regeln und gibt unautorisierte Ports öffentlich frei, und fehlende Ressourcenbegrenzungen lösen Kernel-OOM (Out Of Memory) aus, wodurch die Instanz nicht mehr erreichbar ist.

Dieser Artikel behandelt systematisch den gesamten Prozess des Aufbaus einer robusten, selbstheilenden Docker- und Compose-Umgebung, die Sicherheits- und Compliance-Anforderungen auf VPS-Instanzen mit optimiertem Routing im Ausland erfüllt. Er umfasst die systemnahe Host-Initialisierung, das Tuning des Kern-Daemons, die Isolierung des Netzwerkverkehrs, die Orchestrierung von Microservice-Topologien für die Produktion sowie Notfall-Disaster-Recovery-Strategien über die Control Panels der Anbieter.


Erstens. Baseline-Host-Tuning und Anpassung an Funktionen von Cloud-Anbietern#

Container teilen sich den Linux-Kernel des Hosts, sodass die zugrunde liegende OS-Baseline die Laufzeitstabilität direkt bestimmt. Verwenden Sie eine stabile Distribution mit Langzeitunterstützung wie Debian 12 Bookworm oder Ubuntu 24.04 LTS.

1. Cloud-Plattform-Initialisierung und Anpassung der Zugriffskontrolle#

Cloud-Anbieter unterscheiden sich erheblich bei den Initialisierungs- und Authentifizierungsmechanismen. Verstehen Sie deren Netzwerk- und Terminalzugriffseigenschaften, bevor Sie die Container-Engine bereitstellen:

  • DMIT-Instanzeigenschaften:
    • Nach der Bereitstellung deaktivieren DMIT-Instanzen standardmäßig in der Regel die direkte Remote-Root-Anmeldung mit einem Passwort und erfordern eine SSH-Schlüsselauthentifizierung.
    • In Access der Verwaltungskonsole unterstützt das Panel das Einspielen oder Zurücksetzen von SSH-Schlüsseln und des root-Passworts. Beachten Sie Folgendes besonders: Nach dem Aktualisieren von Schlüsseln oder Passwörtern im DMIT-Panel müssen Sie die Instanz über das Kontrollpanel hart neu starten (Reboot), woraufhin der zugrunde liegende Metadaten-Push und cloud-init wirksam werden.
    • Wenn ein Fehler bei der Container-Orchestrierung den SSH-Port blockiert oder das System einfriert, nutzen Sie die von der DMIT-Konsole bereitgestellte Web-Oberfläche: Console (ein VNC-basiertes Notfallterminal), um das öffentliche SSH-Netzwerk für eine Out-of-Band-Fehlerbehebung zu umgehen.
  • Merkmale von BandwagonHost-Instanzen:
    • Im KiwiVM-Kontrollpanel-System von BandwagonHost sind das KiwiVM-Verwaltungspasswort, das Abrechnungspasswort des Kundenbereichs und das root-Passwort des Systems jeweils unabhängig voneinander.
    • Wenn Container-Netzwerke, die docker0-Bridge oder Anpassungen der Host-Firewall versehentlich die Verbindung trennen, setzen Sie das System nicht sofort zurück. Melden Sie sich bei KiwiVM an und nutzen Sie die integrierte Interactive Console (Interactive Console), die direkten Zugriff auf die Host-Shell bietet, sodass Sie fehlerhafte Container stoppen oder Netzwerkrouten zurücksetzen können.

2. Swap-Speicher und Steuerung des Kernel-Drucks auf den virtuellen Speicher#

Das Ausführen mehrerer Container-Dienste auf einem kleinen VPS mit 1GB~2GB RAM kann leicht zu plötzlichen Speicherspitzen führen. Ohne konfigurierten Swap kann der OOM-Killer des Kernels den Prozess mit dem größten Speicherverbrauch sofort beenden, typischerweise einen Datenbank-Container oder dockerd.

Führen Sie die folgenden Befehle aus, um eine 2GB große Swap-Datei zu erstellen und die Tendenz des Kernels zur Swap-Nutzung zu verringern, wodurch die NVMe-Lebensdauer und -Leistung geschont werden:

bash
# 检查现有 Swap
swapon --show

# 创建 2GB Swap 文件(若已有合理 Swap 可跳过)
fallocate -l 2G /swapfile || dd if=/dev/zero of=/swapfile bs=1M count=2048
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# 持久化挂载
echo '/swapfile none swap sw 0 0' >> /etc/fstab

# 优化内存置换倾向(仅在物理内存剩余不足 10% 时才使用 Swap)
sysctl vm.swappiness=10
sysctl vm.vfs_cache_pressure=50
echo 'vm.swappiness=10' >> /etc/sysctl.d/99-docker-system.conf
echo 'vm.vfs_cache_pressure=50' >> /etc/sysctl.d/99-docker-system.conf

Zwei. Offizielle Docker Engine und das Compose-Plugin bereitstellen#

Verwenden Sie nicht das im Distributions-Repository gebündelte apt install docker.io oder die veraltete eigenständige Binärdatei docker-compose (die von Python gepflegte Version). Produktionsumgebungen müssen das offizielle Upstream-Repository von Docker und das eng integrierte docker-compose-plugin (V2-Befehlssatz: docker compose) verwenden.

bash
# 1. 彻底清理可能残留的历史冲突软件包
apt-get remove -y docker docker-engine docker.io containerd runc 2>/dev/null

# 2. 安装基础通信与安全认证组件
apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 3. 规范配置官方 GPG 密钥环目录
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

# 4. 写入稳定版仓库配置(以 Debian 系统为例)
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5. 安装核心引擎与 Compose V2 插件
apt-get update
apt-get install -y --no-install-recommends \
    docker-ce \
    docker-ce-cli \
    containerd.io \
    docker-buildx-plugin \
    docker-compose-plugin

# 6. 验证核心组件版本
docker --version
docker compose version

Drei. Daemon-Konfiguration für Produktionsumgebungen (wesentliche /etc/docker/daemon.json-Optimierung)#

Dies ist der risikoreichste und am häufigsten übersehene Aspekt beim Betrieb eines kleinen VPS. Das standardmäßig unbegrenzte Logging von Docker ist die größte Bedrohung für kleine Speichervolumina. Erstellen und konfigurieren Sie /etc/docker/daemon.json:

json
{
  "storage-driver": "overlay2",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "20m",
    "max-file": "3"
  },
  "live-restore": true,
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 65535,
      "Soft": 65535
    }
  },
  "dns": [
    "1.1.1.1",
    "8.8.8.8"
  ],
  "default-address-pools": [
    {
      "base": "172.24.0.0/16",
      "size": 24
    }
  ]
}

Eingehende Analyse der wichtigsten Produktionsparameter:#

  1. Protokollrotation und -kürzung (max-size: 20m & max-file: 3): Die stdout/stderr-Protokolle jedes Containers werden bei 20MB automatisch rotiert, wobei höchstens 3 archivierte Kopien aufbewahrt werden. Der gesamte Protokollspeicher pro Container ist auf 60MB begrenzt. Ohne diese Einstellung können wiederholte Redis-Fehler oder fortlaufendes Webanwendungs-Logging eine Systemfestplatte von 20GB~40GB innerhalb weniger Tage füllen, was dazu führt, dass das System aufgrund von No space left on device Remote-Anmeldungen vollständig ablehnt oder Ausfälle bei der Datenbankpersistenz und Datenbeschädigungen verursacht.
  2. Schutz vor abrupten Unterbrechungen bei Updates (live-restore: true): Beim Anwenden von Kernel-Patches oder Durchführen von apt-Upgrades, docker-ce oder Ausführen von systemctl restart docker, wenn der dockerd-Daemon des Hosts neu startet, werden laufende Anwendungscontainer nicht beendet. Dadurch können Microservices während Wartungsarbeiten auf einem einzelnen Knoten ohne Unterbrechung weiterhin Benutzer bedienen.
  3. Verhinderung von Konflikten bei privaten Subnetzen (default-address-pools): Die standardmäßige Bridge-Zuweisung von Docker verwendet das mit 172.17.0.0/16 beginnende Subnetz, das sich leicht mit einigen VPC-Routen von Rechenzentren oder reservierten Adressen in selbstverwalteten WireGuard/Tailscale-Mesh-Netzwerken überschneiden kann. Beschränken Sie den Zuweisungspool explizit auf 172.24.0.0/16 und unterteilen Sie die Subnetze mit /24, um Routing-Blackholes zwischen ihnen zu beseitigen.
  4. Upstream-DNS-Überschreibung (dns): Einige Cloud-Server-Vorlagen konfigurieren standardmäßig Folgendes: /etc/resolv.conf verweist auf den lokalen Loopback-Stub-Resolver. Wenn der rekursive Upstream-DNS im Überseenetzwerk instabil wird, kann es bei Containern während API-Aufrufen, der Kommunikation mit externen CAPTCHA-Diensten oder beim Datenabruf häufig zu DNS-Timeouts kommen. Die explizite Angabe des öffentlichen Anycast-DNS von Cloudflare und Google kann die Auflösungsstabilität erheblich verbessern.

Laden Sie die Konfiguration und starten Sie den Dienst:

bash
systemctl daemon-reload
systemctl restart docker
systemctl enable docker

Vier. Sicherheit von Container-Netzwerken: Die Falle der iptables-Umgehung vermeiden#

In der Linux-Administration verwenden viele Website-Betreiber routinemäßig UFW oder die integrierte Firewall des Systems, um ufw default deny incoming auszuführen. Allerdings hat Docker ein bekanntes sicherheitsrelevantes Verhalten: Standardmäßig schreibt dockerd direkt in die zugrunde liegenden iptables-PREROUTING und fügt in die Chain FORWARD DOCKER-Regeln ein, wodurch exponierte Container-Ports die UFW-Filterung vollständig umgehen!

Deklarieren Sie beispielsweise Folgendes in Compose:

yaml
ports:
  - "3306:3306"

Selbst wenn Sie auf dem Host ufw deny 3306 ausgeführt haben, können Scanner aus dem öffentlichen Netzwerk weiterhin eine direkte Verbindung zu Ihrem Datenbank-Port herstellen und diesen per Brute-Force angreifen.

Die goldene Regel der Netzwerksicherheit in Produktionsumgebungen:#

  1. Öffentliche Internet-Exposition vollständig minimieren: Mit Ausnahme von Reverse-Proxies, die für die Traffic-Verteilung und SSL-Terminierung verantwortlich sind (wie Nginx und Caddy) und die Ports 80 sowie 443 offenlegen, sollten alle Backend-Komponenten (Node.js, Go, Python, PostgreSQL, Redis) niemals externe Port-Mappings für das öffentliche Internet freigeben.
  2. Bindung an das lokale Loopback erzwingen: Wenn das Debugging den Zugriff auf einen Container-Port vom Host aus zwingend erfordert, binden Sie ihn explizit an 127.0.0.1:
    yaml
    ports:
      - "127.0.0.1:8080:8080" # 仅宿主机内部或通过 SSH 隧道可达
  3. Mehrschichtige Netzwerkisolierung: Trennen Sie mindestens zwei Bridge-Netzwerke in Compose:
    • public_net: gemeinsam von Reverse-Proxy- und Anwendungszugriffsschicht-Containern genutzt;
    • secure_net: Gemeinsam von der Anwendungszugriffsschicht, der persistenten Datenbank und dem Cache genutzt; der Reverse-Proxy ist in diesem Netzwerk nicht zugelassen.

Fünf. Deklarative Microservice-Orchestrierung für die Produktion: Best Practices für Docker Compose#

Die folgende Topologie zeigt eine typische Produktionsarchitektur: einen hochzuverlässigen Reverse-Proxy (Caddy ruft Let's Encrypt-Zertifikate automatisch ab und erneuert sie), einen Anwendungsdienst (Node.js-API), eine persistente Datenbank (PostgreSQL 16) und einen separaten Cache (Redis 7 Alpine).

1. Standards für die Verzeichnisstruktur#

Trennen Sie in Produktionsumgebungen Konfigurations-, Daten- und Orchestrierungsdateien logisch voneinander. Empfohlene Verzeichnisstruktur:

Text
/opt/production-stack/
├── .env                  # 敏感环境变量(严禁提交至公共代码库)
├── docker-compose.yml    # 编排定义
├── caddy/
│   └── Caddyfile         # 边缘反向代理配置
└── backups/              # 本地冷备份输出目录

2. Definitionen von Umgebungsvariablen (/opt/production-stack/.env)#

bash
# 系统环境参数
COMPOSE_PROJECT_NAME=core_prod
DOMAIN_NAME=api.yourdomain.com

# 数据库机密参数
DB_USER=prod_pguser
DB_PASSWORD=Super_Secret_Postgres_Password_2026
DB_NAME=core_db

# 缓存机密参数
REDIS_PASSWORD=Strong_Redis_Auth_Token_9981

3. Konfiguration der Produktionsorchestrierung (/opt/production-stack/docker-compose.yml)#

yaml
services:
  # ----------------------------------------------------
  # 1. 边缘反向代理与 TLS 终结(仅此服务监听公网端口)
  # ----------------------------------------------------
  proxy:
    image: caddy:2.8-alpine
    container_name: prod_proxy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp" # HTTP/3 支持
    volumes:
      - ./caddy/Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - public_net
    deploy:
      resources:
        limits:
          memory: 128M

  # ----------------------------------------------------
  # 2. 核心业务应用层(桥接双网络)
  # ----------------------------------------------------
  app:
    image: node:20-alpine
    container_name: prod_app
    restart: unless-stopped
    working_dir: /usr/src/app
    command: sh -c "node server.js"
    environment:
      NODE_ENV: production
      DATABASE_URL: postgres://${DB_USER}:${DB_PASSWORD}@db:5432/${DB_NAME}
      REDIS_URL: redis://:${REDIS_PASSWORD}@cache:6379/0
    networks:
      - public_net
      - secure_net
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_healthy
    deploy:
      resources:
        limits:
          cpus: '1.5'
          memory: 512M

  # ----------------------------------------------------
  # 3. 持久化数据层(严格隔离于内部安全网)
  # ----------------------------------------------------
  db:
    image: postgres:16-alpine
    container_name: prod_postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: ${DB_NAME}
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - secure_net
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 768M

  # ----------------------------------------------------
  # 4. 高速缓存层(密码保护与无公网暴露)
  # ----------------------------------------------------
  cache:
    image: redis:7-alpine
    container_name: prod_redis
    restart: unless-stopped
    command: >
      redis-server 
      --requirepass ${REDIS_PASSWORD}
      --maxmemory 128mb
      --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data
    networks:
      - secure_net
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    deploy:
      resources:
        limits:
          memory: 192M

# ----------------------------------------------------
# 存储卷定义(与宿主机文件系统物理隔离)
# ----------------------------------------------------
volumes:
  caddy_data:
  caddy_config:
  pg_data:
  redis_data:

# ----------------------------------------------------
# 内部网络隔离方案
# ----------------------------------------------------
networks:
  public_net:
    driver: bridge
  secure_net:
    driver: bridge
    internal: true # 强化标志:禁止该网段内容器直接出站访问外网,断绝数据外泄途径

Erläuterung der wichtigsten Entwurfspunkte:#

  • internal: true Maximale Netzwerksicherheit: Wenn in secure_net internal: true deklariert wird, erstellt Docker kein standardmäßiges ausgehendes SNAT-Gateway für diese Bridge. Die PostgreSQL- und Redis-Container sind logisch vom externen Netzwerk getrennt und können nur auf lokale Netzwerkanfragen des app-Containers antworten. Dies schließt die Möglichkeit aus, dass böswillige Abhängigkeiten Reverse-Shells aus dem internen Netzwerk öffnen oder Daten abfließen lassen.
  • Health-Checks und Erkennung der Startreihenfolge (service_healthy): In einer Microservices-Architektur stellt die ausschließliche Verwendung von depends_on: [db] nur sicher, dass der Datenbankcontainer erstellt wurde; es garantiert nicht, dass die Initialisierung abgeschlossen ist und die Datenbank Anfragen annimmt. Kombinieren Sie dies mit healthcheck und condition: service_healthy, um sicherzustellen, dass app der Datenbank-Verbindungspool beim Start garantiert verfügbar ist, und verhindern Sie so Initialisierungs-Absturzschleifen.

Sechs. Automatische Bereinigung des Lebenszyklus und Speicherwartung#

Auf Docker-Hosts mit langen Laufzeiten können sich veraltete BuildKit-Caches, Dangling-Images und nicht verknüpfte anonyme Volumes leicht ansammeln.

1. Standard-Bereinigungsbefehle#

bash
# 安全清理所有无标签的“悬挂”虚悬镜像(不影响运行中服务)
docker image prune -f

# 清除超过 7 天未被任何容器引用的旧构建缓存
docker builder prune -a --filter "until=168h" -f

# 检查当前 Docker 对物理磁盘的真实占用情况
docker system df

2. Bereitstellung eines automatisierten Bereinigungs-Cronjobs#

Erstellen Sie /etc/cron.weekly/docker-maintenance und vergeben Sie die Ausführungsberechtigung:

bash
cat << 'EOF' > /etc/cron.weekly/docker-maintenance
#!/bin/sh
# 每周自动回收超过 14 天未使用的无用镜像与构建缓存,保持系统盘平稳
docker system prune -a --volumes=false --filter "until=336h" -f > /var/log/docker-prune.log 2>&1
EOF

chmod +x /etc/cron.weekly/docker-maintenance

Sieben. Fehlerbehebung im Betrieb, Abstimmung der Notfallwiederherstellung und Provider-Lebenszyklusrichtlinien#

Eine hochverfügbare Containerarchitektur erfordert mehr als nur Orchestrierung auf Codeebene; sie muss nahtlos mit dem Infrastruktur-Lebenszyklus und den Betriebswerkzeugen des Cloud-Providers zusammenarbeiten.

1. Out-of-Band-Fehlerbehebung und Notfall-Konsolenwiederherstellung#

Wenn eine Docker-Speichererschöpfung, Fehlkonfigurationen oder Netzwerkkonflikte den SSH-Zugang vollständig unterbrechen, ist das Control Panel des Providers die letzte Rettungsmöglichkeit:

  • BandwagonHost KiwiVM-Notfallwiederherstellungspfad:
    • Melden Sie sich bei KiwiVM an und suchen Sie in der Seitenleiste nach: Interactive Console. Diese Konsole emuliert eine physische Tastatur sowie einen Bildschirm, sodass Sie sich selbst dann normal anmelden können, wenn die Netzwerkschnittstelle (eth0) ausfällt oder iptables-Regeln beschädigt sind.
    • Führen Sie in der Konsole systemctl stop docker aus, um Systemspeicher und Netzwerksperren freizugeben, und verwenden Sie dann docker stats oder journalctl -u docker -n 100, um die Ursache des Absturzes zu analysieren.
    • Einschränkungen bei Snapshots und Rechenzentrumsmigrationen: KiwiVM unterstützt vollständige Festplatten-Snapshots des Systems. Erstellen Sie vor einem größeren Umbau der Compose-Architektur stets einen Snapshot. Wenn die IP des Servers zudem durch ein externes Netzwerk blockiert wird (Blacklisting), ist die uneingeschränkte Migration zwischen mehreren Rechenzentren in KiwiVM eingeschränkt. Kontrollieren Sie die Netzwerkaktivitäten innerhalb der Container streng, um Missbrauch zu verhindern.
  • Notfallzugriff und Konsolenverfahren für DMIT-Instanzen:
    • Wenn Sie keine Verbindung herstellen können, weil ein Container den SSH-Port geändert hat oder ein öffentlicher Schlüssel verloren gegangen ist, öffnen Sie das DMIT-Instanz-Control-Panel und wählen Sie den Reiter Access, um das root-Passwort zurückzusetzen oder den öffentlichen Schlüssel erneut bereitzustellen.Denken Sie daran: Nach dem Speichern der Änderungen im DMIT-Panel müssen Sie in der Konsole auf Hard Reboot klicken, damit sie wirksam werden.
    • Wenn die Instanz jeglichen Netzwerkzugriff verliert, klicken Sie oben rechts im Control Panel auf Console, öffnen Sie das Web-VNC-Fenster und geben Sie die Zugangsdaten direkt ein, um sich für Wartungsarbeiten anzumelden.

2. Hinweise zur Netzwerkabrechnung und Datennutzung#

Für Hosts wie BandwagonHost und DMIT mit erstklassiger direkter internationaler Backbone-Anbindung sind die Datenvolumen-Kontingente ein zentraler Vermögenswert:

  • Traffic-Verbrauch durch Image-Pulls berücksichtigen: Große Entwicklungs-Images (wie unbereinigte node:latest, Anwendungen mit CUDA oder umfangreiche Python-Umgebungen) können bei einem einzigen Pull 1GB~3GB an Datenverkehr verbrauchen. Das häufige Abrufen externer Images in CI/CD kann das monatliche Traffic-Kontingent eines VPS schnell aufbrauchen.
  • Provider-Regeln und Rückerstattungsgrenzen während des Testens:
    • DMIT-Regeln: Neu erworbene Instanzen qualifizieren sich in der Regel innerhalb von 3 Tagen und bei einer Netzwerknutzung von nicht mehr als 30GB für eine vollständige Rückerstattung; innerhalb von 30 Tagen werden Teilrückerstattungen aus dem verbleibenden Wert nach anfallenden Abzügen berechnet, vorbehaltlich der Nutzungsbedingungen und sofern keine Verstöße vorliegen. Vermeiden Sie es bei der Evaluierung der Docker-Leistung oder beim Benchmarking einer neu bereitgestellten Instanz, innerhalb kurzer Zeit riesige Images gleichzeitig herunterzuladen, da dies den Schwellenwert von 30GB sofort überschreiten und die Rückerstattungsberechtigung zunichtemachen könnte. Beachten Sie außerdem, dass monatliche Verlängerungsrechnungen bei DMIT 7 Tage vor Ablauf erstellt werden. Wenn eine Instanz wegen Nichtzahlung gesperrt wird, werden ihre Daten in der Regel nur für etwa 3 Tage aufbewahrt, bevor sie automatisch dauerhaft gelöscht werden.
    • BandwagonHost-Regeln: BandwagonHost bucht nicht automatisch von Kreditkarten oder PayPal ab. Nachdem die Rechnung 7 Tage vor Ablauf erstellt wurde, zahlen Sie diese manuell oder sorgen Sie für ausreichendes Kontoguthaben. Gemäß den Nutzungsbedingungen ist eine der Voraussetzungen für die Beantragung einer Rückerstattung innerhalb von 30 Tagen nach einem Neukauf: Der monatliche Datenverbrauch muss unter 10% des Kontingents liegen. Wenn Sie eine große Anzahl von Docker-Images herunterladen oder Netzwerk-Stresstests durchführen, überwachen Sie das Bandwidth-Dashboard im Control Panel, um das Nutzungslimit für Rückerstattungen nicht zu überschreiten.

3. Skript für persistenten Daten-Hot-Dump (Kaltes Backup)#

Daten auf Cloud-Servern können nach Abschaltungen wegen Nichtzahlung oder schwerwiegenden Hardwareausfällen unwiederbringlich gelöscht werden; daher müssen in Docker-Volumes gespeicherte Daten regelmäßig offline oder an einem externen Standort gesichert werden.

Erstellen Sie ein routinemäßiges Hot-Dump-Skript auf dem Host /opt/production-stack/backup.sh:

bash
#!/bin/bash
set -eo pipefail

BACKUP_DIR="/opt/production-stack/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
PROJECT="core_prod"

mkdir -p "${BACKUP_DIR}"

echo "[*] 开始导出 PostgreSQL 数据库转储..."
docker compose -f /opt/production-stack/docker-compose.yml exec -T db \
    pg_dump -U prod_pguser -d core_db | gzip > "${BACKUP_DIR}/db_${TIMESTAMP}.sql.gz"

echo "[*] 开始备份持久化应用数据卷..."
# 利用临时容器打包命名数据卷
docker run --rm \
    -v core_prod_caddy_data:/volume_data:ro \
    -v "${BACKUP_DIR}":/backup \
    alpine tar czf "/backup/caddy_data_${TIMESTAMP}.tar.gz" -C /volume_data .

# 自动清理 14 天前的历史冷备份文件
find "${BACKUP_DIR}" -type f -name "*.tar.gz" -mtime +14 -delete
find "${BACKUP_DIR}" -type f -name "*.sql.gz" -mtime +14 -delete

echo "[✓] 备份完成:${TIMESTAMP}"

kombiniert mit crontab -e für die tägliche unbemerkte Ausführung um 3 Uhr morgens planen:

cron
0 3 * * * /bin/bash /opt/production-stack/backup.sh > /dev/null 2>&1

Acht. Prüfliste zur Validierung der Kernkonfiguration#

Überprüfen Sie jeden der folgenden Punkte, bevor Sie Produktionsdienste in einen Container-Cluster migrieren:

ValidierungskriterienÜberprüfungsbefehl / AktionErwartete Standardausgabe / Verhalten
Speichertreiberdocker info | grep 'Storage Driver'muss sein overlay2
Protokollkürzungdocker inspect <容器ID> | grep -A 5 "LogConfig"den Treiber auf json-file, einschließlich max-size und max-file Einschränkungen
Nahtlose Live-Updatesdocker info | grep 'Live Restore Enabled'wird angezeigt als true
Port-Konformitätnetstat -tlpn | grep -E 'docker|dockerd'Der Host gibt nur Folgendes frei: 80、443 oder 127.0.0.1 Loopback-Schnittstelle, ohne direkten öffentlichen Zugriff auf die Datenbank
Speicherobergrenzedocker stats --no-streamAlle Anwendungscontainer zeigen explizite MEM USAGE / LIMIT Schwellenwerte, ohne unbegrenzte Container
NotfallzugriffAuthentifizierung in der Provider-Konsole vorab testenWissen, wie man sich über die Web-Konsole / interaktive Konsole anmeldet, damit die Kontrolle auch ohne SSH erhalten bleibt

Diese umfassenden Baseline-Optimierungen, strengeren Richtlinien zur Netzwerkexposition und Orchestrierungspraktiken nutzen die starke Single-Core-Leistung sowie die Hochgeschwindigkeits-Vernetzung von VPS-Instanzen mit optimiertem Routing im Ausland, während Ressourcenlecks, exponierte Ports und Systemausfälle grundlegend vermieden werden, um ein robustes Container-Hosting auf Produktionsniveau zu gewährleisten.