🚀 Deploying the Complete MyZubster Ecosystem on a VPS: Gateway, Marketplace, Frontend, and AI-Powered Security

🚀 Deploying the Complete MyZubster Ecosystem on a VPS: Gateway, Marketplace, Frontend, and AI-Powered Security

How I built a full decentralized marketplace with Monero payments, Docker, Nginx, and an AI security bot—all on a single VPS.
🌱 The Vision

MyZubster is an open-source ecosystem for a decentralized marketplace that uses Monero (XMR) as its primary currency to guarantee privacy and security. The architecture consists of four core components:

Gateway: Monero payment engine (Node.js + MongoDB)

Marketplace: RESTful API backend (Node.js + SQLite)

Frontend: React/Vite web interface served via Nginx

Security Bot: Automated vulnerability scanning with Kali Linux tools and DeepSeek AI (Ollama)

This post documents my journey deploying the entire system on a VPS, from initial configuration to final validation, including the integration of an AI-powered security bot.
🗺️ Roadmap and Priorities
Priority Task Status
🔴 High Deploy Gateway with Docker in production ✅ Completed
🔴 High Connect Marketplace to Gateway ✅ Completed
🟡 Medium Deploy Frontend with Nginx ✅ Completed
🟡 Medium Integrate Security Bot with DeepSeek AI ✅ Completed
🟢 Low Deploy NFT template on Tari In Progress
🛠️ Technology Stack
Layer Technology Purpose
Languages JavaScript (Node.js), Python (Security Bot), Rust (NFTs) Backend, automation, blockchain
Databases MongoDB (gateway), SQLite (marketplace) Transactional data, user data
Containerization Docker & Docker Compose Reproducible deployments
Blockchain Monero (mainnet), Tari Private payments, NFT assets
Security Kali Linux, nmap, nikto, sqlmap, gobuster, DeepSeek (Ollama) Vulnerability scanning, AI analysis
Frontend React + Vite Modern web interface
Web Server Nginx with Let's Encrypt SSL Reverse proxy and HTTPS
🔧 Step 1: Gateway Configuration
1.1 Dockerfile
dockerfile

FROM node:20-slim AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
COPY . .

FROM node:20-slim
RUN groupadd -r myzubster && useradd -r -g myzubster myzubster
WORKDIR /app
COPY --from=builder --chown=myzubster:myzubster /app/node_modules ./node_modules
COPY --from=builder --chown=myzubster:myzubster /app ./
EXPOSE 3000
USER myzubster
CMD ["node", "server.js"]

1.2 docker-compose.yml
yaml

services:
mongodb:
image: mongo:7-jammy
container_name: myzubster-mongodb
restart: unless-stopped
environment:
MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-admin}
MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-securepassword}
volumes:
- mongodb_data:/data/db
ports:
- "27018:27017"
networks:
- myzubster-network
healthcheck:
test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
interval: 30s
timeout: 10s
retries: 5

gateway:
build:
context: .
dockerfile: Dockerfile
container_name: myzubster-gateway
restart: unless-stopped
environment:
- NODE_ENV=${NODE_ENV:-production}
- PORT=${PORT:-3000}
- MONGO_URI=mongodb://${MONGO_USER:-admin}:${MONGO_PASSWORD:-securepassword}@mongodb:27017/myzubster?authSource=admin
- MONERO_RPC_URL=${MONERO_RPC_URL:-http://node.moneroworld.com:18081}
- MONERO_NETWORK=${MONERO_NETWORK:-mainnet}
- JWT_SECRET=${JWT_SECRET}
- API_KEY=${API_KEY}
ports:
- "3001:3000"
depends_on:
mongodb:
condition: service_healthy
networks:
- myzubster-network
volumes:
- ./public:/app/public
- gateway_logs:/app/logs

volumes:
mongodb_data:
driver: local
gateway_logs:
driver: local

networks:
myzubster-network:
driver: bridge

Why port 3001? I mapped internal port 3000 to external port 3001 to avoid conflicts with other services.
🔗 Step 2: Connecting the Marketplace

The marketplace is a separate Node.js application that connects to the gateway for payment processing and order management.
2.1 Marketplace .env Configuration
env

PORT=4000
NODE_ENV=production
DB_DIALECT=sqlite
DB_STORAGE=./data/marketplace.sqlite
MYZUBSTER_API_URL=http://localhost:3001/api
MYZUBSTER_API_TOKEN=your_api_token
MONERO_NETWORK=mainnet
MONERO_RPC_URL=http://node.moneroworld.com:18081
MONERO_WALLET_ADDRESS=your_wallet_address
MONERO_WALLET_PASSWORD=your_wallet_password
MONERO_MIN_CONFIRMATIONS=10
JWT_SECRET=your_jwt_secret
JWT_EXPIRES_IN=7d

2.2 Launch and Verify
bash

cd ~/MyZubster-Marketplace
npm install
node server.js &

curl http://localhost:4000/api/health

{"status":"ok","service":"MyZubster-Marketplace","database":"sqlite"}

curl http://localhost:4000/api/gateway/status

{"gateway":{"status":"ok"},"status":"connected"}

🌐 Step 3: Deploying the Frontend with Nginx
3.1 Nginx Configuration
nginx

/etc/nginx/sites-available/myzubster-ip

server {
listen 80;
server_name your-vps-ip;

root /var/www/myzubster-frontend;
index index.html;

location / {
    try_files $uri $uri/ /index.html;
}

location /api/ {
    proxy_pass http://localhost:3001/api/;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection 'upgrade';
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
}

}

3.2 HTTPS with Let's Encrypt
bash

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d myzubster.com -d www.myzubster.com

🛡️ Step 4: AI-Powered Security Bot

I integrated a security bot that performs automated vulnerability scanning using Kali Linux tools and analyzes results with DeepSeek AI running locally via Ollama.
4.1 Security Bot Architecture
python

!/usr/bin/env python3

import subprocess
import json
import logging
import datetime
import requests

LOG_FILE = "/var/log/security_bot.log"
DEEPSEEK_URL = "http://localhost:11434/api/generate"
DEEPSEEK_MODEL = "deepseek-r1:1.5b"

def run_nmap():
return subprocess.run("nmap -sV --script=default localhost",
shell=True, capture_output=True, text=True).stdout

def run_nikto():
return subprocess.run("nikto -h https://myzubster.com -ssl -Format json",
shell=True, capture_output=True, text=True).stdout

def run_sqlmap():
return subprocess.run("sqlmap -u localhost --batch --level=1 --risk=1",
shell=True, capture_output=True, text=True).stdout

def run_gobuster():
return subprocess.run("gobuster dir -u localhost -w /usr/share/wordlists/dirb/common.txt -t 50",
shell=True, capture_output=True, text=True).stdout

def analyze_with_deepseek(results):
response = requests.post(DEEPSEEK_URL, json={
"model": DEEPSEEK_MODEL,
"prompt": f"Analyze these security scan results and identify vulnerabilities:\n{results}",
"stream": False
})
return response.json().get("response", "No response")

4.2 Install DeepSeek with Ollama
bash

Install Ollama

curl -fsSL https://ollama.com/install.sh | sh

Download DeepSeek model

ollama pull deepseek-r1:1.5b

Run the security bot

cd ~/MyZubsterGateway/security
nohup python3 security_bot.py > /var/log/security_bot.log 2>&1 &

4.3 Sample Security Report

The bot generates comprehensive JSON reports:
json

{
"timestamp": "2026-07-25T19:29:49.080367",
"target": "localhost",
"scans": {
"nmap": "22/tcp open ssh OpenSSH 9.6p1...",
"nikto": "No vulnerabilities found...",
"sqlmap": "All tested parameters are not injectable...",
"gobuster": "/api (Status: 301)..."
},
"deepseek_analysis": "Security analysis complete. No critical vulnerabilities found."
}

✅ Final Results

After completing the deployment, all services were operational:
Service Endpoint Status
Gateway /api/health {"status":"ok"}
Marketplace /api/health {"status":"ok"}
Integration /api/gateway/status "connected"
Frontend / HTTPS 200 OK
Security Bot Cron job ✅ Running hourly
DeepSeek AI Ollama ✅ Active
System Overview
text

┌──────────────────────────────────────────────────────────────────────────────┐
│ MyZubster VPS Infrastructure │
├──────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌──────────────┐ ┌──────────────────┐ │
│ │ Frontend │ │ Gateway │ │ Marketplace │ │ Security Bot │ │
│ │ (Nginx) │──▶ (Port 3001) │◄─┤ (Port 4000) │ │ - nmap │ │
│ │ Port 443 │ │ - MongoDB │ │ - SQLite │ │ - nikto │ │
│ └─────────────┘ └─────────────┘ └──────────────┘ │ - sqlmap │ │
│ │ │ │ - gobuster │ │
│ ▼ ▼ │ - DeepSeek AI │ │
│ ┌─────────────────────────────────┐ └──────────────────┘ │
│ │ Monero Node (node.moneroworld) │ │ │
│ └─────────────────────────────────┘ ▼ │
│ ┌──────────────┐ │
│ │ Ollama │ │
│ │ DeepSeek │ │
│ └──────────────┘ │
└──────────────────────────────────────────────────────────────────────────────┘

💡 Lessons Learned

Docker simplifies deployment – Containerizing the gateway made the process reproducible, scalable, and easier to manage.

Environment variables are critical – Separating configuration from code is essential for security and flexibility.

Monero payment monitoring requires a reliable node – Using node.moneroworld.com as a public node worked well for testing; consider self-hosting for production.

Integration is seamless – The REST API communication between gateway and marketplace works without issues.

Nginx with Let's Encrypt – Adding HTTPS with Certbot was straightforward and essential for production.

AI-powered security is a game changer – DeepSeek running locally via Ollama provides intelligent vulnerability analysis without sending data to third parties.

Security automation saves time – The security bot runs hourly and produces detailed reports, reducing manual monitoring.

🔮 Next Steps

Deploy the Mobile App to Google Play Store

Integrate NFC payments for physical interactions

Implement DAO Governance for community decisions

Complete Security Audit with third-party tools

Add more NFT functionality for real-world asset tokenization

📚 Repository & Documentation

All code is available on GitHub:

Gateway: DanielIoni-creator/MyZubsterGateway

Marketplace: DanielIoni-creator/MyZubster-Marketplace

Frontend: DanielIoni-creator/myzubster-frontend

Mobile App: DanielIoni-creator/MyZubster-App

NFT Template: DanielIoni-creator/tari-nft-template

🤝 Contribute

If you're interested in blockchain, privacy-first payments, or decentralized markets, contribute to the repositories on GitHub or open an issue to discuss new features.

Key areas for contribution:

Frontend: Improve the admin dashboard

Testing: Add webhook integration tests

Documentation: Write tutorials for new users

Security: Conduct penetration testing

🌐 Connect with Me

Follow the development of MyZubster and connect with me on social media:

Blog & Articles: DEV.to - Daniel Ioni

X (Twitter): @myzubster

LinkedIn: Daniel Ioni

GitHub: DanielIoni-creator

TikTok: @h4x0r_23

Built with ❤️ for Monero, Tari, and the open-source community. 🌱

Originally published on DEV.to
📋 Quick Reference: All Commands Used
bash

Deploy Gateway

cd ~/MyZubsterGateway
docker compose up -d --build

Deploy Marketplace

cd ~/MyZubster-Marketplace
npm install
node server.js &

Deploy Frontend

cd ~/myzubster-frontend
npm run build
sudo cp -r dist/* /var/www/myzubster-frontend/
sudo systemctl restart nginx

Install DeepSeek AI

curl -fsSL https://ollama.com/install.sh | sh
ollama pull deepseek-r1:1.5b

Run Security Bot

cd ~/MyZubsterGateway/security
nohup python3 security_bot.py > /var/log/security_bot.log 2>&1 &

Verify Integration

curl http://localhost:4000/api/gateway/status