How to Deploy an Acala Node?

According to a recent ResearchGate study, Financial Services is the leading industry to take advantage of the benefits offered by Blockchain technology. DeFi, DEX, Lending, Asset management, and many more Financial services use cases for blockchain have emerged in recent years, and blockchain networks and enterprises are ready for the challenge. 

One such network that has a laser focus on Decentralised Finance (DeFi) is Acala. 

What is Acala?

Acala is an L1 smart contract platform that is Ethereum-compatible, scalable, and optimized for DeFi. With “Acala EVM+,” Acala helps developers leverage the best of Ethereum and aUSD Ecosystem while unlocking the full potential of Substrate. 

This means that Acala is designed both as an L1 application layer catered to DeFi services and as a parachain on the Polkadot L0, where developers can build their projects easily. 

That said, running a parachain node is fairly similar to running a typical Substrate node with some inherent differences. A Substrate parachain node is a bigger build because it consists of code that runs the parachain itself, as well as the code to sync the relay chain and facilitate communication between the two. 

System Requirements

Before embarking on deploying an Acala node, here are some basic system requirements to keep the node up & running. Acala being a parachain, this build is quite large and may take more than 30 minutes and require 32 GB of memory. 

Here are the minimum specifications recommended to run a node: 

OS: Linux

RAM: 16 GB (minimum), and recommended 32 GB. 

Storage: 1 TB SSD (minimum)

CPU: 8 Cores (fastest per core speed)

Firewall: P2P port must be open to incoming traffic: Source-Any, Destination: 30333, 30334 TCP

Running Ports

P2P: 30333 (TCP)

RPC: 9933

WS: 9944

Prometheus: 9615

Ethereum API: 8545

Note: Experience working on Linux is a must to deploy an Acala full node, and experience with Rust programming language is not required. 

Let us consider that your system runs on minimum system specs of 16GB RAM and 1TB storage and begin to install the setup packages. 

Getting Started

Install Rust and Linux Packages

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

sudo apt-get install -y git clang curl libssl-dev llvm libudev-dev protobuf-compiler cmake

Build the Binary 

git clone https://github.com/AcalaNetwork/Acala.git

cd Acala && git config --global submodule.recurse true

make init && cargo build ---release ---features with-acala-runtime

Setting Up the Service

Before setting up the service, remember to rename the values/names specified under the tag <>. For example, if you’ve created a user named “acala” as a Linux user, and I’ve asked you to change <username>, your value will be “acala” instead of <username>. 

In step 3 “Setup the Service,” run the command sudo chown -R acala /var/lib/acala-data instead of sudo chown -R <username> /var/lib/acala-data

Create a directory to store the binary and data: sudo mkdir /var/lib/acala-data

Move the downloaded binary we made using wget to /var/lib/acala-data: sudo mv ./acala /var/lib/acala-data

Make sure to set the ownership and permissions accordingly for the local directory that stores the chain data: sudo chown -R <username> /var/lib/acala-data

Create the Configuration File

The next step is to create the systemd configuration file. And make sure to name the file /etc/systemd/system/acala.service

[Unit]
Description="Acala systemd service"
After=network.target
StartLimitIntervalSec=0
[Service]

Type=simple

Restart=on-failure

RestartSec=10

User=<username>

SyslogIdentifier=acala

SyslogFacility=local7

KillSignal=SIGHUP

ExecStart=<path-to-binary>/acala 

--base-path=<path-to-acala-data>/data 

--chain=acala 

--name="<nodename>" 

--pruning=archive 

--ws-external 

--rpc-external 

--rpc-cors=all 

--ws-port=9944 

--rpc-port=9933 

--ws-max-connections=2000 

--execution=wasm 

-- 

--chain=kusama 

--name="<nodename> (Relay chain)"
[Install]

WantedBy=multi-user.target
Note: replace <path-to-acala-data>, <path-to-binary>
Note: If you want to run an RPC endpoint, to connect Polkadot.js Apps, or to run your own application, use the flags --unsafe-rpc-external and/or --unsafe-ws-external to run the full node with external access to the RPC ports. More details are available by running acala --help. 
Create the Configuration file.
Now, you need to register and start the service by running: 
sudo systemctl enable acala.service
sudo systemctl start acala.service
Lastly, verify if the service is running by using: 
sudo systemctl status acala.service
You can also check the logs by executing:
journalctl -f -u acala.service
And if you need to stop the service from running for whatever reason, you can run: 
sudo systemctl stop acala.service
Building the ETH-RPC Adapter from Source
Requirements for bodhi.js
Node.js >= 16
Python
Rush: npm install -g @microsoft/rush
git clone https://github.com/AcalaNetwork/bodhi.js.git
cd bodhi.js && git submodule update --init --recursive
rush update && rush build -t @acala-network/eth-rpc-adapter
npx @acala-network/eth-rpc-adapter -l -e ws://localhost:9944
Wrapping Up
There you have it. You have now successfully deployed an Acala node. 
Stay tuned to Zeeve, as you’ll soon be able to skip the manual (code-based) deployment of Acala nodes and do so on a seamless automated platform. 
Zeeve is a Blockchain infrastructure service platform, and we have strategically located nodes across the globe. Other than Acala, you can deploy nodes for Moonbeam, Tezos, and all the other major protocols. 
We are the only node provider in the world to offer Bring Your Own Cloud service (besides our proprietary cloud platform - ZDFS) as an offering for all developers and enterprises. 
So, what are you waiting for? Book a free demo with our expert today, and follow Zeeve on Twitter, LinkedIn, and Telegram.