.. SO! That’s the hardware. Next, you’ll probably want to know where to get it all, right? Here’s links to everything you need. Some of these are affiliate links, which I may earn a small commission in exchange for using them. It doesn’t cost you anything extra, but helps support these projects. What could be easier?!

There it is! This should get you everything you need to get your RockARM built out and on to the next step! A couple notes: the RockPi4A units are sometimes harder to get on Amazon due to supply, but can usually be cheaper when factoring in the alternative of ordering them from China or Europe with International shipping costs.

Also, it’s worth mentioning that you can use the RockPi4B or C models if you wanted to. The reason I selected the model A for this project is the main difference is, the model A does not have WiFi or Bluetooth, which we do not need for this project; may as well save some money! But, if you are only able to find the model B or C variations, they will work exactly the same!

Finally, check out the final assembly with wiring instructions.. video right here!

Click the link below to download the complete package, zipped and compressed. Please take a moment to read through the contained README file, for special instructions to successfully print the parts, especially the main housing and its’ fine-mesh top. Don’t just grab it an hit Print, it won’t work!

Also, here is the video introduction, where I take you through the parts and how to assemble them properly

Also, if you’re looking for a great machine to run your fleet of FreqTrade bots on, I highly recommend this small form-factor Intel NUC – this is an amazing price on a rock-solid piece of hardware, in a compact, silent, power-efficient format! Please note this is an affiliate link and I may receive a commission from your purchase. Clicking this link and completing your regular Amazon purchases is an easy no-cost way to support the channel!

Here’s your sample code for your docker-compose.yml file:

version: '3.3'

networks:
  proxy:
    external: true

services:
  freqtrade:
    image: freqtradeorg/freqtrade:develop
    volumes:
      - ./user_data:/freqtrade/user_data
      - /etc/timezone:/etc/timezone:ro
    command: >
      trade
      --logfile /freqtrade/user_data/logs/freqtrade.log
      --config /freqtrade/user_data/config.json
      --strategy ${STRATEGY}
      --db-url sqlite:///user_data/${DATABASE_FILE}
    networks:
      - proxy
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      restart_policy:
        condition: on-failure
        delay: 5s
      labels:
        - 'traefik.http.routers.${BOTNAME}.tls=true'
        - 'traefik.http.routers.${BOTNAME}.rule=Host(`${BOTNAME}.bots.yourdomain.com`)'
        - 'traefik.http.services.${BOTNAME}.loadbalancer.server.port=8080'

In the above sample code, it’s important that you are using a wildcard subdomain in the bots.yourdomain.com placeholder. If you are not familiar, this means you want everything (*) under that namespace to resolve to the IP of your docker host. If you need a refresher on this, check out my Traefik proxy video, I cover this in-depth!

Next, you need the .env file that contains the variables referenced in the sample docker-compose.yml, so, here you go!

BOTNAME=bot001
STRATEGY=BinHV45
DATABASE_FILE=trades.sqlite

The above file should be saved as a hidden “dot file” in the same path with your docker-compose.yml file, as .env

The BOTNAME variable dictates what the fully-qualified name of the deployed bot will be, ie: https://bot001.bots.yourdomain.com

The STRATEGY variable needs to be the exact (case-sensitive) name of your strategy file, which is stored in user_data/strategies folder

Also remember when you’re copying your base FreqTrade folder (this was bot001 in the video, for example), that you want to go in and remove the existing trades.sqlite database, and clear the logs by removing the logs/freqtrade.log file if it exists, after copying, and before deploying

Lastly, you’re probably looking for that command that lets you use .env variables with a docker stack deploy deployed container! Here you go:

docker stack deploy -c <(docker-compose config) stackName

This looks similar to the standard deploy command, however we can see that in place of where we normally reference the docker-compose.yml file, we’re telling it to evaluate that configuration with docker-compose instead! When this runs, it builds the config, evaluating the variables, and then passes that all back to docker stack deploy to complete the deployment.

I hope this is helpful to you! Please give me a thumbs up on the video if you found it useful, subscribe if you’re not already, and leave me a comment if you have questions or thoughts! Thank you!

Also, if you’re looking for a great machine to run your fleet of FreqTrade bots on, I highly recommend this small form-factor Intel NUC – this is an amazing price on a rock-solid piece of hardware, in a compact, silent, power-efficient format! Please note this is an affiliate link and I may receive a commission from your purchase. Clicking this link and completing your regular Amazon purchases is an easy no-cost way to support the channel!

If you haven’t already seen the video, do check it out:

https://youtu.be/09NeF22yrkQ?t=1

I’m guessing you came here for the example code. Here’s what you need in your user_data/config.json file

"api_server": {
        "enabled": true,
        "enable_openapi": true,
        "listen_ip_address": "0.0.0.0",
        "listen_port": 8080,
        "verbosity": "info",
        "jwt_secret_key": "somethingrandom",
        "CORS_origins": ["https://freqtrade.dmz.bunnitrade.com"],
        "username": "api",
        "password": "api"
    },

The key there is the CORS entry: This should be the fully-qualified URL of your primary “dashboard” FreqTrade instance. You’ll use this same entry on all your bots.

Do let me know if you have questions! Comment on the YouTube video, or hit me up on Twitter @OMGTheCloud

Thanks!

Also, if you’re looking for a great machine to run your fleet of FreqTrade bots on, I highly recommend this small form-factor Intel NUC – this is an amazing price on a rock-solid piece of hardware, in a compact, silent, power-efficient format! Please note this is an affiliate link and I may receive a commission from your purchase. Clicking this link and completing your regular Amazon purchases is an easy no-cost way to support the channel!

Install Docker

https://get.docker.com is the source for your one-line (okay technically two; you download it, then you execute it) Docker installation script

curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

Install Docker Compose

Next, we need Docker Compose. This is also very simple:

sudo apt update && sudo apt install docker-compose -y

Add your user to the “docker” group

To save you from constantly having to prefix your docker commands with sudo, and more importantly to ensure your containers have the correct permissions to local configuration files you configure, let’s add your running user (whatever user you’re logged in to your new Ubuntu server right now) to the docker security group. In order for this to take effect, you have to log out and back in to the server afterward.

sudo usermod -a -G docker [username]

Don’t forget to log out and back in at this point, so that change takes effect.

Install FreqTrade

Now that we’ve got Docker installed and running, it’s time to get FreqTrade installed, as a Docker container of course! You’re going to make a directory called freqtrade, change directory (cd) in to it, then pull the latest docker-compose.yml from the FreqTrade Git repository. Last, you will issue the docker-compose pull command, which tells Docker to pull down the container images specified in the docker-compose.yml file. Let’s go!

mkdir freqtrade
cd freqtrade
curl https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml -o docker-compose.yml
docker-compose pull

Configure FreqTrade

Now that we have all the needed pieces of FreqTrade downloaded, we need to do some initial configuration. The developers of FreqTrade built in a way to set up the file and folder structure, and build out a baseline config.json, by issuing commands to the FreqTrade Docker image, and invoke it to ask you some basic questions. Neat! The first one here creates the file and folder structure:

docker-compose run --rm freqtrade create-userdir --userdir user_data

Next, we’ll run a similar command, which will start up an interactive series of questions, to get your FreqTrade config off to a good start:

docker-compose run --rm freqtrade new-config --config user_data/config.json

This will ask you some questions, and generally the defaults are all fine, except a couple things for the API, so you can use the WebUI in a browser to control and monitor FreqTrade!
Enable API: YES
API Listen: 0.0.0.0

Next, we need to pull out some invalid trade pairs from the basic config.json (if you are using Binance US specifically, and maybe others too), otherwise FreqTrade will not start up properly.

nano user_data/config.json

Find the Whitelist section, and remove:
ALGO/BTC, 
ATOM/BTC, 
BAT/BTC, 
BRD/BTC, 
EOS/BTC, 
IOTA/BTC, 
NEO/BTC, 
NXS/BTC, 
XMR/BTC

Save and exit (ctrl+o and ctrl+x)

Lastly, we need to edit the docker-compose.yml and enable our commented-out network ports, so we can see the WebUI when we start the container

nano docker-compose.yml

find the ports: section and delete the leading # comment symbol
delete the # comment symbol from the next line, where 8080 ports are
ensure line spacing is correct! “ports:” should be the same level of indentation as the other directives above it, such as “volumes:”
Remove the "127.0.0.1:" from the port mapping. Your final ports: section should look like this:

ports:
  - "8080:8080"

Start FreqTrade

Time to start it up! The below command will launch the FreqTrade instance. You can also monitor its’ realtime logs with the command docker logs -f freqtrade (with “freqtrade” being the name of the container, and -f means “follow”; similar to “tail” if you’re familiar with other CLI logging)

docker-compose up -d

That should do it! Now you can point your web browser at http://IPofYourServer:8080 and you should be presented with the FreqTrade WebUI. Click the login button in the top right, and enter the username and password you provided during the config questions earlier. Then you can click the Trade or Dashboard buttons in the upper left, to see what’s going on with your shiny new trading bot!

Bonus: Change to a dynamically generated Pairlist

As a bonus configuration point, I talked about this in the closing part of the video, let’s change your list of trading pairs to something dynamic, rather than just a static-defined set of whitelisted pairs. Go edit your config.json once more, and find the "pairlists": [ section. You can change from the default “StaticPairList” to “VolumePairList” as described here, with a couple methods for how it will evaluate and decide which pairs are good to use. You’ll see I have commented out the StaticPairlists with the leading // so you know where it should go, and can switch back if you want.

    "pairlists": [
       {
//            "method": "StaticPairList"
            "method": "VolumePairList",
            "number_assets": 70,
            "sort_key": "quoteVolume",
            "refresh_period": 1800
       },
       {
            "method": "AgeFilter",
            "min_days_listed": 10
       },
       {
            "method": "RangeStabilityFilter",
            "lookback_days": 5,
            "min_rate_of_change": 0.02,
            "refresh_period": 1440
       }
   ],

Also, if you’re looking for a great machine to run your fleet of FreqTrade bots on, I highly recommend this small form-factor Intel NUC – this is an amazing price on a rock-solid piece of hardware, in a compact, silent, power-efficient format! Please note this is an affiliate link and I may receive a commission from your purchase. Clicking this link and completing your regular Amazon purchases is an easy no-cost way to support the channel!

If you find this info valuable, consider supporting me on Patreon! You can also sign up for direct access to my Discord server, where I can help you with any questions you may have. Thanks!

Let’s start with a basic docker-compose.yml for your FreqTrade instance:

version: '3.6'

networks:
  proxy:
    external: true

services:
  freqtrade:
    image: freqtradeorg/freqtrade:develop
    networks:
      - proxy
    volumes:
      - "./user_data:/freqtrade/user_data"
      - /etc/timezone:/etc/timezone:ro
    # Default command used when running `docker compose up`
    command: >
      trade
      --logfile /freqtrade/user_data/logs/freqtrade.log
      --config /freqtrade/user_data/config.json
      --strategy BinHV45
      --db-url sqlite:///user_data/tradesv3.sqlite
    deploy:
      mode: replicated
      replicas: 1
      placement:
        constraints:
          - node.role == manager
      restart_policy:
        condition: on-failure
        delay: 5s
      labels:
         - 'traefik.enable=true'
         - 'traefik.http.routers.binhv45.tls=true'
         - 'traefik.http.routers.binhv45.rule=Host(`binhv45.dmz.yourdomain.com`)'
         - 'traefik.http.services.binhv45.loadbalancer.server.port=8080'

If you don’t already have a Traefik proxy set up, you’ll want to refer to my video and example code for that. It’ll make your life so much easier!

Next, let’s take a look as a sample config.json file for FreqTrade. This will vary based on your config, but this is a good starting point:

{
    "max_open_trades": 25,
    "stake_currency": "USDT",
    "stake_amount": 50,
    "tradable_balance_ratio": 0.99,
    "fiat_display_currency": "USD",
    "timeframe": "1m",
    "dry_run": true,
    "cancel_open_orders_on_exit": false,
    "unfilledtimeout": {
        "buy": 10,
        "sell": 30
    },
    "bid_strategy": {
        "price_side": "bid",
        "ask_last_balance": 0.0,
        "use_order_book": false,
        "order_book_top": 1,
        "check_depth_of_market": {
            "enabled": false,
            "bids_to_ask_delta": 1
        }
    },
    "ask_strategy": {
        "price_side": "ask",
        "use_order_book": false,
        "order_book_min": 1,
        "order_book_max": 1,
        "use_sell_signal": true,
        "ignore_roi_if_buy_signal": true
    },
    "download_trades": true,
    "exchange": {
        "name": "binanceus",
        "key": "",
        "secret": "",
        "ccxt_config": {"enableRateLimit": true},
        "ccxt_async_config": {
            "enableRateLimit": true,
            "rateLimit": 200
        },
        "pair_whitelist": [
          "BTC/USDT",
          "ETH/USDT",
          "ETC/USDT",
          "LTC/USDT",
          "XLM/USDT",
          "ADA/USDT"
        ],
        "pair_blacklist": [
          "XRP/USD",
          "USDT/USD",
          "USDC/USD",
          "EUR/USD"
        ]
    },
    "pairlists": [
      {
//          "method": "StaticPairList"}
          "method": "VolumePairList",
          "number_assets": 50,
          "sort_key": "quoteVolume",
          "refresh_period": 1800
      },
      {"method": "AgeFilter", "min_days_listed": 10},
      {
        "method": "RangeStabilityFilter",
        "lookback_days": 5,
        "min_rate_of_change": 0.01,
        "refresh_period": 1440
      }
     ],

    "edge": {
        "enabled": false,
        "process_throttle_secs": 3600,
        "calculate_since_number_of_days": 7,
        "allowed_risk": 0.01,
        "minimum_winrate": 0.60,
        "minimum_expectancy": 0.20,
        "min_trade_number": 10,
        "max_trade_duration_minute": 1440,
        "remove_pumps": false
    },
    "telegram": {
        "enabled": false,
        "token": "",
        "chat_id": ""
    },
    "api_server": {
        "enabled": true,
        "enable_openapi": true,
        "listen_ip_address": "0.0.0.0",
        "listen_port": 8080,
        "verbosity": "info",
        "jwt_secret_key": "somethingrandom",
        "CORS_origins": [],
        "username": "api",
        "password": "api"
    },
    "initial_state": "running",
    "forcebuy_enable": false,
    "internals": {
        "process_throttle_secs": 5
    }
}

Next, you’ll need a strategy file. This is the example we’re using in the video, but I also recommend you check out the examples on FreqTrade’s own GitHub page. The below is BinHV45.py stored in /user_data/strategies/ folder:

# --- Do not remove these libs ---
from freqtrade.strategy.interface import IStrategy
from typing import Dict, List
from functools import reduce
from pandas import DataFrame
import numpy as np
# --------------------------------

import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib


def bollinger_bands(stock_price, window_size, num_of_std):
    rolling_mean = stock_price.rolling(window=window_size).mean()
    rolling_std = stock_price.rolling(window=window_size).std()
    lower_band = rolling_mean - (rolling_std * num_of_std)

    return rolling_mean, lower_band


class BinHV45(IStrategy):
    minimal_roi = {
    #    "0": 0.0125
      "0": 0.99
    }

    stoploss = -0.05
    timeframe = '1m'
    trailing_stop = True
    trailing_only_offset_is_reached = True
    trailing_stop_positive_offset = 0.00375  # Trigger positive stoploss once crosses above this percentage
    trailing_stop_positive = 0.00175 # Sell asset if it dips down this much


    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        mid, lower = bollinger_bands(dataframe['close'], window_size=40, num_of_std=2)
        dataframe['mid'] = np.nan_to_num(mid)
        dataframe['lower'] = np.nan_to_num(lower)
        dataframe['bbdelta'] = (dataframe['mid'] - dataframe['lower']).abs()
        dataframe['pricedelta'] = (dataframe['open'] - dataframe['close']).abs()
        dataframe['closedelta'] = (dataframe['close'] - dataframe['close'].shift()).abs()
        dataframe['tail'] = (dataframe['close'] - dataframe['low']).abs()
        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                dataframe['lower'].shift().gt(0) &
                dataframe['bbdelta'].gt(dataframe['close'] * 0.008) &
                dataframe['closedelta'].gt(dataframe['close'] * 0.0175) &
                dataframe['tail'].lt(dataframe['bbdelta'] * 0.25) &
                dataframe['close'].lt(dataframe['lower'].shift()) &
                dataframe['close'].le(dataframe['close'].shift())
            ),
            'buy'] = 1
        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        no sell signal
        """
        dataframe.loc[:, 'sell'] = 0
        return dataframe