docker-compose.yaml.template

#######################################################################
# File name : docker-compose.yaml
# Author : Notch
# This Docker-compose file use data from .env file
#######################################################################


services:
### APPS ###

# EARNAPP CONTAINER
#ENABLE_EARNAPP  earnapp:
#ENABLE_EARNAPP    container_name: ${DEVICE_NAME}_earnapp
#ENABLE_EARNAPP    hostname: ${DEVICE_NAME}_earnapp
#ENABLE_EARNAPP    image: fazalfarhan01/earnapp:lite
#ENABLE_EARNAPP    environment:
#ENABLE_EARNAPP      - EARNAPP_UUID=$EARNAPP_DEVICE_UUID
#ENABLE_EARNAPP      - EARNAPP_TERM="yes"
#ENABLE_EARNAPP    volumes:
#ENABLE_EARNAPP      - earnapp-data:/etc/earnapp
#ENABLE_EARNAPP    # network_mode: service:tun2socks
#ENABLE_EARNAPP    restart: always
#ENABLE_EARNAPP    cpus: ${APP_CPU_LIMIT_MEDIUM}
#ENABLE_EARNAPP    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
#ENABLE_EARNAPP    mem_limit: ${APP_MEM_LIMIT_MEDIUM}

# HONEYGAIN CONTAINER
#ENABLE_HONEYGAIN  honeygain:
#ENABLE_HONEYGAIN    container_name: ${DEVICE_NAME}_honeygain
#ENABLE_HONEYGAIN    hostname: ${DEVICE_NAME}_honeygain
#ENABLE_HONEYGAIN    image: honeygain/honeygain:latest
#ENABLE_HONEYGAIN    environment:
#ENABLE_HONEYGAIN      - HONEYGAIN_DUMMY=''
#ENABLE_HONEYGAIN    command: -tou-accept -email $HONEYGAIN_EMAIL -pass $HONEYGAIN_PASSWD -device $DEVICE_NAME
#ENABLE_HONEYGAIN    # network_mode: service:tun2socks
#ENABLE_HONEYGAIN    restart: always
#ENABLE_HONEYGAIN    cpus: ${APP_CPU_LIMIT_MEDIUM}
#ENABLE_HONEYGAIN    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
#ENABLE_HONEYGAIN    mem_limit: ${APP_MEM_LIMIT_MEDIUM}

# IPROYALPAWNS CONTAINER
#ENABLE_IPROYALPAWNS  iproyalpawns:
#ENABLE_IPROYALPAWNS    container_name: ${DEVICE_NAME}_iproyalpawns
#ENABLE_IPROYALPAWNS    hostname: ${DEVICE_NAME}_iproyalpawns
#ENABLE_IPROYALPAWNS    image: iproyal/pawns-cli:latest
#ENABLE_IPROYALPAWNS    environment:
#ENABLE_IPROYALPAWNS      - IPROYALPAWNS_DUMMY=''
#ENABLE_IPROYALPAWNS    command: -accept-tos -email=$IPROYALPAWNS_EMAIL -password=$IPROYALPAWNS_PASSWD -device-name=$DEVICE_NAME -device-id=id_$DEVICE_NAME
#ENABLE_IPROYALPAWNS    # network_mode: service:tun2socks
#ENABLE_IPROYALPAWNS    restart: always
#ENABLE_IPROYALPAWNS    cpus: ${APP_CPU_LIMIT_LITTLE}
#ENABLE_IPROYALPAWNS    mem_reservation: ${APP_MEM_RESERV_LITTLE}
#ENABLE_IPROYALPAWNS    mem_limit: ${APP_MEM_LIMIT_LITTLE}

# PACKETSTREAM CONTAINER
#ENABLE_PACKETSTREAM  packetstream:
#ENABLE_PACKETSTREAM    container_name: ${DEVICE_NAME}_packetstream
#ENABLE_PACKETSTREAM    hostname: ${DEVICE_NAME}_packetstream
#ENABLE_PACKETSTREAM    image: packetstream/psclient:latest
#ENABLE_PACKETSTREAM    environment:
#ENABLE_PACKETSTREAM      - CID=$PACKETSTREAM_CID
#ENABLE_PACKETSTREAM    # network_mode: service:tun2socks
#ENABLE_PACKETSTREAM    restart: always
#ENABLE_PACKETSTREAM    cpus: ${APP_CPU_LIMIT_MEDIUM}
#ENABLE_PACKETSTREAM    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
#ENABLE_PACKETSTREAM    mem_limit: ${APP_MEM_LIMIT_MEDIUM}

# TRAFFMONETIZER CONTAINER
#ENABLE_TRAFFMONETIZER  traffMonetizer:
#ENABLE_TRAFFMONETIZER    container_name: ${DEVICE_NAME}_traffmonetizer
#ENABLE_TRAFFMONETIZER    hostname: ${DEVICE_NAME}_traffmonetizer
#ENABLE_TRAFFMONETIZER    image: traffmonetizer/cli_v2:latest
#ENABLE_TRAFFMONETIZER    environment:
#ENABLE_TRAFFMONETIZER      - TRAFFMONETIZER_DUMMY=''
#ENABLE_TRAFFMONETIZER    command: start accept status --token $TRAFFMONETIZER_TOKEN --device-name $DEVICE_NAME
#ENABLE_TRAFFMONETIZER    # network_mode: service:tun2socks
#ENABLE_TRAFFMONETIZER    restart: always
#ENABLE_TRAFFMONETIZER    cpus: ${APP_CPU_LIMIT_LITTLE}
#ENABLE_TRAFFMONETIZER    mem_reservation: ${APP_MEM_RESERV_LITTLE}
#ENABLE_TRAFFMONETIZER    mem_limit: ${APP_MEM_LIMIT_LITTLE}

# REPOCKET CONTAINER
#ENABLE_REPOCKET  repocket:
#ENABLE_REPOCKET    container_name: ${DEVICE_NAME}_repocket
#ENABLE_REPOCKET    hostname: ${DEVICE_NAME}_repocket
#ENABLE_REPOCKET    image: repocket/repocket:latest
#ENABLE_REPOCKET    environment:
#ENABLE_REPOCKET        - RP_EMAIL=$REPOCKET_EMAIL
#ENABLE_REPOCKET        - RP_API_KEY=$REPOCKET_APIKEY
#ENABLE_REPOCKET    # network_mode: service:tun2socks
#ENABLE_REPOCKET    restart: always
#ENABLE_REPOCKET    cpus: ${APP_CPU_LIMIT_MEDIUM}
#ENABLE_REPOCKET    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
#ENABLE_REPOCKET    mem_limit: ${APP_MEM_LIMIT_MEDIUM}

# EARNFM CONTAINER
#ENABLE_EARNFM  earnfm:
#ENABLE_EARNFM    container_name: ${DEVICE_NAME}_earnfm
#ENABLE_EARNFM    hostname: ${DEVICE_NAME}_earnfm
#ENABLE_EARNFM    image: earnfm/earnfm-client:latest
#ENABLE_EARNFM    environment:
#ENABLE_EARNFM        - EARNFM_TOKEN=$EARNFM_APIKEY
#ENABLE_EARNFM    # network_mode: service:tun2socks
#ENABLE_EARNFM    restart: always
#ENABLE_EARNFM    cpus: ${APP_CPU_LIMIT_MEDIUM}
#ENABLE_EARNFM    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
#ENABLE_EARNFM    mem_limit: ${APP_MEM_LIMIT_MEDIUM}

# PROXYRACK CONTAINER
#ENABLE_PROXYRACK  proxyrack:
#ENABLE_PROXYRACK    container_name: ${DEVICE_NAME}_proxyrack
#ENABLE_PROXYRACK    hostname: ${DEVICE_NAME}_proxyrack
#ENABLE_PROXYRACK    image: proxyrack/pop:latest
#ENABLE_PROXYRACK    environment:
#ENABLE_PROXYRACK        - api_key=$PROXYRACK_APIKEY
#ENABLE_PROXYRACK        - device_name=$DEVICE_NAME
#ENABLE_PROXYRACK        - UUID=$PROXYRACK_DEVICE_UUID
#ENABLE_PROXYRACK    # network_mode: service:tun2socks
#ENABLE_PROXYRACK    restart: always
#ENABLE_PROXYRACK    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_PROXYRACK    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_PROXYRACK    mem_limit: ${APP_MEM_LIMIT_BIG}

# PROXYLITE CONTAINER
#ENABLE_PROXYLITE  proxylite:
#ENABLE_PROXYLITE    container_name: ${DEVICE_NAME}_proxylite
#ENABLE_PROXYLITE    hostname: ${DEVICE_NAME}_proxylite
#ENABLE_PROXYLITE    image: proxylite/proxyservice:latest
#ENABLE_PROXYLITE    environment:
#ENABLE_PROXYLITE      - USER_ID=$PROXYLITE_USER_ID
#ENABLE_PROXYLITE    # network_mode: service:tun2socks
#ENABLE_PROXYLITE    restart: always
#ENABLE_PROXYLITE    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_PROXYLITE    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_PROXYLITE    mem_limit: ${APP_MEM_LIMIT_BIG}

# BITPING CONTAINER 
#ENABLE_BITPING  bitping:
#ENABLE_BITPING    container_name: ${DEVICE_NAME}_bitping
#ENABLE_BITPING    hostname: ${DEVICE_NAME}_bitping
#ENABLE_BITPING    image: mrcolorrain/bitping:latest
#ENABLE_BITPING    environment:
#ENABLE_BITPING      - BITPING_EMAIL=$BITPING_EMAIL
#ENABLE_BITPING      - BITPING_PASSWD=$BITPING_PASSWD
#ENABLE_BITPING    volumes:
#ENABLE_BITPING      # You have 2 options
#ENABLE_BITPING      - ./.data/.bitpingd:/root/.bitpingd # Bind an host folder to the container (more insecure but simplier to port and backup) this option mount a new identity or a backed up one from the host file system
#ENABLE_BITPING      # OR
#ENABLE_BITPING      #- bitping-data:/root/.bitpingd # if you use this also uncomment the relative volume in volumes section, this  Use docker volumes (more secure harder to access, backup and restore) you'll need to do backups using 'docker cp
#ENABLE_BITPING    # network_mode: service:tun2socks
#ENABLE_BITPING    restart: always
#ENABLE_BITPING    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_BITPING    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_BITPING    mem_limit: ${APP_MEM_LIMIT_BIG}

# SPEEDSHARE CONTAINER
#ENABLE_SPEEDSHARE  speedshare:
#ENABLE_SPEEDSHARE    container_name: ${DEVICE_NAME}_speedshare
#ENABLE_SPEEDSHARE    hostname: ${DEVICE_NAME}_speedshare
#ENABLE_SPEEDSHARE    image: mrcolorrain/speedshare:latest
#ENABLE_SPEEDSHARE    environment:
#ENABLE_SPEEDSHARE      - CODE=$SPEEDSHARE_CODE
#ENABLE_SPEEDSHARE      - SPEEDSHARE_UUID=$SPEEDSHARE_DEVICE_UUID
#ENABLE_SPEEDSHARE    # network_mode: service:tun2socks
#ENABLE_SPEEDSHARE    restart: always
#ENABLE_SPEEDSHARE    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_SPEEDSHARE    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_SPEEDSHARE    mem_limit: ${APP_MEM_LIMIT_BIG}

# GRASS CONTAINER
#ENABLE_GRASS  grass:
#ENABLE_GRASS    container_name: ${DEVICE_NAME}_grass
#ENABLE_GRASS    hostname: ${DEVICE_NAME}_grass
#ENABLE_GRASS    image: mrcolorrain/grass:latest
#ENABLE_GRASS    environment:
#ENABLE_GRASS      - GRASS_USER=$GRASS_EMAIL
#ENABLE_GRASS      - GRASS_PASS=$GRASS_PASSWD
#ENABLE_GRASS    # network_mode: service:tun2socks
#ENABLE_GRASS    restart: always
#ENABLE_GRASS    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_GRASS    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_GRASS    mem_limit: ${APP_MEM_LIMIT_BIG}


### EXTRA APPS ###

# MYSTERIUM MYSTNODE CONTAINER
#ENABLE_MYSTNODE  mystnode:
#ENABLE_MYSTNODE    container_name: ${DEVICE_NAME}_mystnode
#ENABLE_MYSTNODE    hostname: ${DEVICE_NAME}_mystnode
#ENABLE_MYSTNODE    image: mysteriumnetwork/myst:latest
#ENABLE_MYSTNODE    environment:
#ENABLE_MYSTNODE      - MYSTNODE_DUMMY=''
#ENABLE_MYSTNODE    command: service --agreed-terms-and-conditions
#ENABLE_MYSTNODE    cap_add:
#ENABLE_MYSTNODE          - NET_ADMIN
#ENABLE_MYSTNODE    ports: #RMLINE_IF_ENABLE_PROXY
#ENABLE_MYSTNODE          - ${MYSTNODE_DASHBOARD_PORT}:4449 #RMLINE_IF_ENABLE_PROXY
#ENABLE_MYSTNODE    volumes:
#ENABLE_MYSTNODE          # You have 2 options
#ENABLE_MYSTNODE          - ./.data/mysterium-node:/var/lib/mysterium-node # Bind an host folder to the container (more insecure but simplier to port and backup) this option mount a new identity or a backed up one from the host file system
#ENABLE_MYSTNODE          # OR
#ENABLE_MYSTNODE          #- myst-data:/var/lib/mysterium-node # if you use this also uncomment the relative volume in volumes section, this  Use docker volumes (more secure harder to access, backup and restore) you'll need to do backups using 'docker cp myst:/var/lib/mysterium-node .' and then when you need to restore the identity first delete the automatically created and not needed identities using 'sudo docker exec -it myst sh' and then in the container shell use 'sudo rm -rf /var/lib/mysterium-node/*' then stop the container and use docker cp to copy the backed-up identity in the container, ther restart the container.
#ENABLE_MYSTNODE    # network_mode: host
#ENABLE_MYSTNODE    restart: always
#ENABLE_MYSTNODE    cpus: ${APP_CPU_LIMIT_HUGE}
#ENABLE_MYSTNODE    mem_reservation: ${APP_MEM_RESERV_HUGE}
#ENABLE_MYSTNODE    mem_limit: ${APP_MEM_LIMIT_HUGE}

# PEER2PROFIT CONTAINER
#ENABLE_PEER2PROFIT  peer2profit:
#ENABLE_PEER2PROFIT    container_name: ${DEVICE_NAME}_peer2profit
#ENABLE_PEER2PROFIT    hostname: ${DEVICE_NAME}_peer2profit
#ENABLE_PEER2PROFIT    image: mrcolorrain/peer2profit:latest
#ENABLE_PEER2PROFIT    environment:
#ENABLE_PEER2PROFIT      - P2P_EMAIL=$PEER2PROFIT_EMAIL
#ENABLE_PEER2PROFIT    ports: #RMLINE_IF_ENABLE_PROXY
#ENABLE_PEER2PROFIT      - 5901:5900 #RMLINE_IF_ENABLE_PROXY
#ENABLE_PEER2PROFIT    # network_mode: service:tun2socks
#ENABLE_PEER2PROFIT    restart: always
#ENABLE_PEER2PROFIT    cpus: ${APP_CPU_LIMIT_HUGE}
#ENABLE_PEER2PROFIT    mem_reservation: ${APP_MEM_RESERV_HUGE}
#ENABLE_PEER2PROFIT    mem_limit: ${APP_MEM_LIMIT_HUGE}

### TOOLS AND SERVICES ###

# TUN2SOCKS CONTAINER
#ENABLE_PROXY  tun2socks:
#ENABLE_PROXY    container_name: ${DEVICE_NAME}_tun2socks
#ENABLE_PROXY    hostname: ${DEVICE_NAME}_tun2socks
#ENABLE_PROXY    image: xjasonlyu/tun2socks
#ENABLE_PROXY    environment:
#ENABLE_PROXY      - LOGLEVEL=info
#ENABLE_PROXY      - PROXY=$STACK_PROXY
#ENABLE_PROXY      - EXTRA_COMMANDS=ip rule add iif lo ipproto udp dport 53 lookup main;
#ENABLE_PROXY    cap_add:
#ENABLE_PROXY      - NET_ADMIN
#ENABLE_PROXY    network_mode: "bridge"
#ENABLE_PROXY    dns:
#ENABLE_PROXY    - 1.1.1.1
#ENABLE_PROXY    - 8.8.8.8
#ENABLE_PROXY    - 1.0.0.1
#ENABLE_PROXY    - 8.8.4.4
#ENABLE_PROXY    ports:
#ENABLE_PROXY      - ${WCB_DASHBOARD_PORT}:80
#ENABLE_PROXY      - ${MYSTNODE_DASHBOARD_PORT}:4449
#ENABLE_PROXY    volumes:
#ENABLE_PROXY      - '/dev/net/tun:/dev/net/tun'
#ENABLE_PROXY    restart: always
#ENABLE_PROXY    cpus: ${APP_CPU_LIMIT_BIG}
#ENABLE_PROXY    mem_reservation: ${APP_MEM_RESERV_BIG}
#ENABLE_PROXY    mem_limit: ${APP_MEM_LIMIT_BIG}


# WATCHTOWER AUTO-UPDATER AND NOTIFICATIONS
  watchtower:
    container_name: ${DEVICE_NAME}_watchtower
    hostname: ${DEVICE_NAME}_watchtower
    image: containrrr/watchtower:latest
    environment:
      - WATCHTOWER_POLL_INTERVAL=14400
      # - WATCHTOWER_NOTIFICATIONS=shoutrrr
      # - WATCHTOWER_NOTIFICATION_URL=$SHOUTRRR_URL
      - WATCHTOWER_ROLLING_RESTART=true
      - WATCHTOWER_NO_STARTUP_MESSAGE=true
      - WATCHTOWER_CLEANUP=true
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    restart: always
    cpus: ${APP_CPU_LIMIT_MEDIUM}
    mem_reservation: ${APP_MEM_RESERV_MEDIUM}
    mem_limit: ${APP_MEM_LIMIT_MEDIUM}
        
# WEB DASBOARD
  WCBwebdashboard:
    container_name: ${DEVICE_NAME}_webdashboard
    hostname: ${DEVICE_NAME}_webdashboard
    image: nginx:alpine-slim
    ports: #RMLINE_IF_ENABLE_PROXY
      - ${WCB_DASHBOARD_PORT}:80 #RMLINE_IF_ENABLE_PROXY
    volumes:
      - ./.resources/.www:/usr/share/nginx/html:ro
    restart: always
    cpus: ${APP_CPU_LIMIT_LITTLE}
    mem_reservation: ${APP_MEM_RESERV_LITTLE}
    mem_limit: ${APP_MEM_LIMIT_LITTLE}
        
volumes:
  earnapp-data:
  #bitping-data: # uncomment this if in bitping volumes you choose to use docker volumes instead of binding an host folder
  #myst-data: # uncomment this if in myst volumes you choose to use docker volumes instead of binding an host folder