How wackydawg/vps_rdp works
Summary / project type and purpose
• This is a single-container, containerized Ubuntu desktop environment with remote-access (RustDesk) plus a small Node.js "status" HTTP server. The project is effectively a monolithic container image that bundles an OS desktop (XFCE), virtual display (Xvfb), applications (Chrome), a RustDesk agent for RDP-like remote access, and a Node.js process (server.js) exposing system information on port 7860.
• Key indicators: Dockerfile + start.sh (container orchestration), server.js + package.json (Node server), README describing XFCE/Xvfb/RustDesk, port 7860, and desktop user/password.
File-structure → architecture mapping
• Dockerfile: builds the monolithic container image (Ubuntu 22.04 base + all installed pieces).
• start.sh: entrypoint that starts all runtime processes inside the container (Xvfb, XFCE session, RustDesk agent, possibly Chrome, and server.js).
• server.js + package.json/package-lock.json: Node.js status server that exposes system information at http://localhost:7860/.
• README.md: documents runtime behavior, credentials, ports, and features.
• Host / Docker Engine (outer context)
• Docker Container (the vps-rdp image)
• Process orchestration / entrypoint: start.sh (or supervisor) — shows that multiple processes are launched from a single script
• Virtual display server: Xvfb (:99, 1280x720)
• Desktop environment: XFCE desktop session (the GUI user session that runs on the virtual display)
• Applications running in the desktop: Chrome (and any other GUI apps)
• Remote-access agent: RustDesk (the component that accepts remote connections and exposes an ID/password)
• Node.js status server: server.js (HTTP API on port 7860)
• Logging stdout/stderr (container logs) — where the RustDesk ID is printed
• External actors / clients (outside the container)
• RustDesk client (external user connecting with ID/password)
• HTTP client (user/browser, monitoring system) calling GET http://host:7860/
• Docker host admin (build/run commands; e.g., docker build/run)
Important architectural patterns and design principles to highlight
• Single-container "monolithic" multi-process approach: One Docker image contains multiple cooperating processes rather than microservices. The entrypoint script (start.sh) acts as a simple process orchestrator.
• Process separation: GUI session vs. remote access agent vs. monitoring API — conceptual separation of concerns, but all colocated.
• Headless GUI strategy: Use Xvfb virtual display to run a GUI in a headless container — illustrates the “virtual framebuffer” pattern.
• External-facing interfaces:
• RustDesk (remote desktop protocol/agent) — interactive remote control channel.
• Node.js HTTP API — monitoring/automation channel (non-interactive status endpoint).
Relevant technologies / frameworks
• Docker (image & runtime)
• Ubuntu 22.04 base image
• XFCE desktop environment
• Xvfb (virtual display :99)
• RustDesk (remote access agent)
• Chrome (preinstalled browser)
• start.sh (entrypoint) and Dockerfile (image build)
• If converting to production or multi-container architecture, recommend decoupling: move Node.js API to its own container, use a dedicated remote-access gateway or VPN, and add monitoring and persistent volumes.
• Components (all labeled): Host/Docker engine, Container (vps-rdp), Ubuntu base, start.sh, Xvfb (:99), XFCE, Chrome, RustDesk agent, Node.js server (server.js) with port 7860, container logs
• External actors: RustDesk client (internet), HTTP client/browser, Administrator
• Port mappings and protocols: Host:7860 → Container:7860 (HTTP), RustDesk remote access channel (internet)
• Notes/annotations: credential values (mark as secrets), display resolution (:99 1280x720), desktop user/pass, mention that start.sh orchestrates processes
Tooling suggestions
• Inside the container, map the runtime processes (start.sh -> processes) and annotate interactions (RustDesk ↔ XFCE; Node.js → OS; port mapping).