How to Set Up USDT Payment for DuJiaoka Using Docker – A Step-by-Step Guide

·

Accepting cryptocurrency payments has never been easier. With Docker, you can quickly deploy a secure and scalable USDT payment gateway for platforms like DuJiaoka, enabling seamless crypto transactions for your digital store. This guide walks you through the entire process—from setup to integration—with clear instructions, best practices, and pro tips.

Whether you're running an online shop or managing digital goods, integrating USDT (Tether) as a payment method boosts accessibility and global reach. Let’s dive in.

Why Accept USDT via Docker?

Stablecoins like USDT offer price stability compared to volatile cryptocurrencies such as Bitcoin or Ethereum. By using a lightweight Docker-based solution—epusdt—you can:

👉 Discover how OKX simplifies crypto transactions for merchants and users alike.

Prerequisites for Deployment

Before setting up the USDT payment system, ensure your environment meets these basic requirements:

✅ Server & System Requirements

🔧 Recommended Tools

💡 Tip: For low-cost domains, consider .xyz from registrars like Namesilo (~$7/year). Enable privacy protection to keep your info secure.

Step 1: Install Docker and Reverse Proxy

If Docker isn’t already installed, use this script:

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

Install Docker Compose:

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

👉 Learn how leading platforms streamline crypto onboarding.

Next, deploy Nginx Proxy Manager (NPM) for easy SSL and reverse proxy management:

mkdir -p /root/data/docker_data/npm && cd /root/data/docker_data/npm
docker run --name npm -p 80:80 -p 443:443 -p 81:81 \
  -v /root/data/docker_data/npm/data:/data \
  -v /root/data/docker_data/npm/letsencrypt:/etc/letsencrypt \
  --restart=always \
  jc21/nginx-proxy-manager:latest

Access NPM at http://your-server-ip:81.

Step 2: Create a Telegram Bot

The epusdt system uses Telegram for admin notifications.

  1. Open Telegram and search for BotFather
  2. Send /newbot and follow prompts
  3. Save the generated API token (e.g., 624711111:Asdajkdaksdhkajshi6aUa6pXH4Rxc)

Then, find your Telegram User ID:

Store both values securely.

Step 3: Deploy epusdt with Docker Compose

Create the project directory:

sudo -i
mkdir -p /root/data/docker_data/epusdt && cd /root/data/docker_data/epusdt

Create docker-compose.yml

version: "3"
services:
  db:
    image: mariadb:focal
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=strong_root_pass
      - MYSQL_DATABASE=epusdt
      - MYSQL_USER=epusdt
      - MYSQL_PASSWORD=strong_user_pass
    volumes:
      - ./mysql:/var/lib/mysql
  redis:
    image: redis:alpine
    restart: always
    volumes:
      - ./redis:/data
  epusdt:
    image: stilleshan/epusdt
    restart: always
    volumes:
      - ./epusdt.conf:/app/.env
    ports:
      - "8000:8000"
🔒 Remember: Change passwords! Avoid defaults in production.

Step 4: Configure epusdt Settings

Create .env file:

vim epusdt.conf

Paste and customize:

app_name=epusdt
app_uri=https://pay.yourdomain.com
app_debug=false
http_listen=:8000
static_path=/static
runtime_root_path=/runtime

# Database (use same password as in docker-compose)
mysql_host=db
mysql_port=3306
mysql_user=epusdt
mysql_passwd=strong_user_pass
mysql_database=epusdt

# Redis
redis_host=redis
redis_port=6379
redis_db=5

# Telegram Bot
tg_bot_token=YOUR_BOT_TOKEN_HERE
tg_manage=YOUR_TELEGRAM_USER_ID

# API Security Token (used in DuJiaoka)
api_auth_token=your_secure_api_key_here

order_expiration_time=10

Save and exit (Esc → :wq).

Now, import the database schema:

vim epusdt.sql

Paste the SQL structure (provided in original article) and save.

Step 5: Launch the Service

Start containers:

docker-compose up -d

Initialize database:

docker exec -i epusdt-db-1 sh -c 'exec mysql -uepusdt -pstrong_user_pass epusdt' < epusdt.sql

Restart to apply changes:

docker-compose restart

Check logs:

docker logs -f epusdt-epusdt-1

Look for: http server started on [::]:8000

Step 6: Set Up Reverse Proxy with HTTPS

Option A: Nginx Proxy Manager

  1. Log into NPM (https://your-server-ip:81)
  2. Create a new Proxy Host

  3. Set:

    • Domain: pay.yourdomain.com
    • Forward IP: Docker internal IP (ip addr show docker0) or localhost if same host
    • Forward Port: 8000
  4. Enable SSL with Let's Encrypt

Option B: aapanel /宝塔面板

Add a new site → No PHP/MySQL → Edit Nginx config:

location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

Wait for SSL issuance.

Test by visiting https://pay.yourdomain.com — should see:
hello epusdt, https://github.com/assimon/epusdt

Step 7: Connect to DuJiaoka

Log into your DuJiaoka admin panel.

Go to: Settings > Payment Methods > epusdt

Enable and configure:

Back in Telegram bot, send /create to generate your first USDT deposit address.

You're live!

FAQ Section

Q1: Is this method safe for handling real payments?

Yes. All transaction logic runs in isolated Docker containers. Data is stored locally, not shared with third parties. Use strong passwords and HTTPS to ensure security.

Q2: Can I accept other cryptocurrencies?

Currently, epusdt supports TRC20 and ERC20 USDT only. For broader coin support, consider integrating with gateways like OKX Merchant Services.

👉 Explore secure, multi-chain crypto payment solutions here.

Q3: What if my port 8000 is already in use?

Modify the port mapping in docker-compose.yml:
Change - "8000:8000" to - "8081:8000", then update reverse proxy settings accordingly.

Q4: How do I upgrade the epusdt service?

Run:

cd /root/data/docker_data/epusdt
docker-compose down
docker-compose pull
docker-compose up -d
docker image prune -f

No downtime, smooth updates.

Q5: Why use Docker instead of manual installation?

Docker ensures dependency isolation, version consistency, and easier backups. It simplifies deployment across environments—ideal for developers and non-experts alike.

Q6: Can I run multiple instances for different stores?

Absolutely. Deploy separate folders (e.g., /epusdt-store1, /epusdt-store2) with unique domains, ports, and configs.

Final Thoughts

Setting up a USDT payment gateway with Docker is fast, secure, and cost-effective. With epusdt, you gain full autonomy over your crypto payments—perfect for digital stores powered by DuJiaoka.

From initial setup to live transactions, every step is designed for simplicity and reliability. And with automation tools like Docker Compose, maintenance becomes effortless.

Got questions? Check the official GitHub repo or join community discussions.

Happy selling—and welcome to the future of decentralized commerce!