.
The next question is:
```bash
Indicate how your nodes should be connected with RTView: networking sockets or named pipes ."
Default way is sockets, so if you are not sure - choose :
```
Please choose the way how the nodes should be connected to RTView.
If you chose S, you will be asked about the base port:
```bash
Ok, sockets will be used. Indicate the base port to listen for connections (1024 - 65535, default is 3000):
```
The base port will be used for the first node that forwards its metrics to RTView. For example, if you will launch three cardano-node processes (node-1, node-2, and node-3) that will forward their metrics using network sockets, this is how they will be connected to RTView:
node-1 -> 0.0.0.0:3000 node-2 -> 0.0.0.0:3001 node-3 -> 0.0.0.0:3002 Bit if you selected P, you will be asked about the directory when pipes will be created:
```bash
Ok, pipes will be used. Indicate the directory for them, default is "/run/user/1000/rt-view-pipes":
```
Next question is:
```bash
Now, indicate a host of machine RTView will be launched on (default is 0.0.0.0):
```
If your nodes are launched on the same machine with RTView, you can choose the default address. But if RTView will be launched on another machine, please specify its reachable public IP address. It will allow your nodes to connect with RTView. In this case, it is assumed that a machine with RTView is accessible using that IP address.
The last question is:
```bash
Indicate the directory with static content for the web server, default is "static":
```
Since RTView displays nodes' metrics on the web-page, it uses static web content (CSS, JS, images). By default, it's static directory that is included in the archive you've downloaded. Then you will see this message:
```bash
Great, RTView is ready to run! Its configuration was saved at PATH_TO/rt-view.yaml. Press to continue...
```
where PATH\_TO is the full path to the default system configuration directory. After you pressed Enter, RTView will show all the changes you have to make in your node(s) configuration file(s). For example, if you chose all default values on Linux, you will see this:
```bash
Now you have to make the following changes in your node's configuration file:
1. Find TurnOnLogMetrics flag and make sure it is true:
"TurnOnLogMetrics": true
2. Since you have 3 nodes, add following traceForwardTo sections in the root of their configuration files:
"traceForwardTo": {
"tag": "RemoteSocket",
"contents": [
"0.0.0.0",
"3000"
]
}
"traceForwardTo": {
"tag": "RemoteSocket",
"contents": [
"0.0.0.0",
"3001"
]
}
"traceForwardTo": {
"tag": "RemoteSocket",
"contents": [
"0.0.0.0",
"3002"
]
}
After you are done, press to run RTView...
```
After you pressed Enter, RTView will be launched, and you can open (if you chose default web-port) and see the web-page.
help from:
# Cardano-Cli Basics
## Cardano-Cli Basics
## Set of Cardano-cli Sub Commands
**address:** Shelley payment address commands
**stake-address:** Shelley stake address commands
**transaction:** Shelley transaction commands
**node:** Shelley node operation commands
**stake-pool:** Shelley stake pool commands
**query:** Shelley node query commands. This queries the local node whose Unix domain socket is obtained from the CARDANO\_NODE\_SOCKET\_PATH environment variable.
**block:** Shelley block commands
**system:** Shelley system commands
**genesis:** Shelley genesis block commands
**text-view:** commands for dealing with Shelley text view files that are stored on disk such as transactions or addresses
**governance:** Shelley governance commands
## Cardano-cli Address Sub Commands
**key-gen:** creates a single address key pair
**key-hash:** prints the hash of an address to stdout
**build:** builds a Shelley payment address, with optional delegation to a stake address
**build-multisig:** builds a Shelley payment multi-sig address.
**info:** prints details about the address
## Cardano-clistake address Sub Commands
**key-gen:** creates a single address key pair
**build:** builds a stake address
**register:** registers a stake address
**delegate:** delegates from a stake address to a stake pool
**de-register:** de-registers a stake address
**registration-certificate:** creates a registration certificate
**delegation-certificate:** creates a stake address delegation certificate
**deregistration-certificate:** creates a de-registration certificate
## Cardano-cli Transaction Sub Commands
**build-raw:** builds a low-level transaction
**sign:** signs the transaction
**witness:** witnesses a transaction
**sign-witness:** signs and witnesses a transaction
**check:** checks the transaction
**submit:** submits the transaction to the local node whose Unix domain socket is obtained from the CARANO\_NODE\_SOCKET\_PATH environment variable.
**calculate-min-fee:** calculates the minimum fee for the transaction
**info:** prints information about the transaction
## Cardano-cli Node Sub Commands
**key-gen:** creates a key pair for a node operator’s offline key and a new certificate issue counter
**key-gen-KES:** creates a key pair for a node KES operational key
**key-gen-VRF:** creates a key pair for a node VRF operational key
**issue-op-cert:** issues a node operational certificate
## Cardano-cli Stakepool Sub Commands
**register:** registers a stake pool
**re-register:** re-registers a stake pool
**retire:** retires a stake pool
**registration-certificate:** creates a stake pool registration certificate
**de-registration-certificate:** creates a stake pool de-registration certificate
**id:** builds pool id from the offline key
## Cardano-cli Query Sub Commands
**pool-id:** retrieves the node’s pool ID
**protocol-parameters:** retrieves the node’s current pool parameters
**tip:** gets the node’s current tip (slot number, hash, and block number)
**utxo:** retrieves the node’s current UTxO, filtered by address
**version:** retrieves the node’s version details
**status:** retrieves the current status of the node
**ledger-state:** dumps the current state of the node
**stake-address-info:** get the current delegations and reward accounts filtered by stake address.
**stake-distribution:** get the node's current aggregated stake distribution
## Cardano-cli Block Sub Commands
**info:** retrieves the pool ID that produced a particular block.
### Cardano-cli System Sub Commands
**start:** starts the system
**stop:** stops the system
## Cardano-cli Governence
**create-mir-certificate:** creates an MIR (move instantaneous rewards) certificate
**create-update-proposal:** creates an update proposal
**protocol-update:** performs a protocol update
**cold-keys:** retrieves the cold keys
## Cardano-cli Genisis
**key-gen-genesis:** creates a Shelley genesis key pair
**key-gen-delegate:** creates a Shelley genesis delegate key pair
**key-gen-utxo:** creates a Shelley genesis UTxO key pair
**key-hash:** prints the identifier, or hash, of a public key
**get-ver-key:** derives verification key from a signing key
**initial-addr:** gets the address for an initial UTxO based on the verification key
**initial-txin:** gets the transaction ID for an initial UTxO based on the verification key.
**create:** creates a Shelley genesis file from a genesis template, as well as genesis keys, delegation keys, and spending keys.
# 3rd Party Monitoring Tools (gLiveview, etc.)
If you've used prereqs.sh, you can skip this part, as this is already set up for you. The tool relies on the common env configuration file. To get current epoch blocks, the logMonitor.sh script is needed (and can be combined with CNCLI). This is optional and Guild LiveView will function without it.
-Helpful websites-
# Chrony Configuration
To start go to and download the latest version of chrony.
Then edit the /etc/chrony/chrony.conf file to look like this:
```
# 3 sources per time servers.
pool ntp.ubuntu.com iburst maxsources 3
pool time.nist.gov iburst maxsources 3
pool us.pool.ntp.org iburst maxsources 3
keyfile /etc/chrony/chrony.keys
driftfile /var/lib/chrony/chrony.drift
logdir /var/log/chrony
maxupdateskew 10.0
rtcsync
# Make steps in 100ms.
makestep 0.1 3
```
Then restart chrony:
```
systemctl start chrony
```
Next edit /etc/sysctl.conf to look like this:
```
fs.file-max = 10000000
fs.nr_open = 10000000
net.core.netdev_max_backlog = 100000
net.core.somaxconn = 100000
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.ip_nonlocal_bind = 1
net.ipv4.tcp_fin_timeout = 10
net.ipv4.tcp_keepalive_time = 300
net.ipv4.tcp_max_orphans = 262144
net.ipv4.tcp_max_syn_backlog = 100000
net.ipv4.tcp_max_tw_buckets = 262144
net.ipv4.tcp_mem = 786432 1697152 1945728
net.ipv4.tcp_reordering = 3
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_sack = 0
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_syn_retries = 5
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_wmem = 4096 16384 16777216
net.netfilter.nf_conntrack_max = 10485760
net.netfilter.nf_conntrack_tcp_timeout_fin_wait = 30
net.netfilter.nf_conntrack_tcp_timeout_time_wait = 15
vm.swappiness = 10
```
Afterwards, edit /etc/security/limits.conf to this:
```
root soft nofile 32768
soft nofile 32768
hard nofile 1048576
```
If your service starts with systemctl then edit /etc/systemd/system/.service to something along the lines of:
```
[Unit]
Description=Shelley Staking Pool
After=multi-user.target
[Service]
Type=simple
ExecStart=
# 16K Or more
LimitNOFILE=16384
Restart=on-failure
RestartSec=5s
User=
Group=users
[Install]
WantedBy=multi-user.target
```
And run:
```
systemctl daemon-reload && systemctl enable shelley && systemctl start shelley
```
{% hint style="info" %}
Remove comment above LimitNOFILE
{% endhint %}
Finally, allow the bare minimum of firewall allowance with this:
```
ufw allow /tcp
ufw allow /tcp
```
This guide was heavily inspired by
# Firewall Configurations
The UFW firewall can be used to control the network access to your node With any new installation, UFW is disabled by default. You will have to enable it with the following steps:
Deny any incoming and outgoing traffit
```
sudo ufw default deny incoming
sudo ufw default allow outgoing
```
Allow ssh access
```
sudo ufw allow ssh (port 22 or your ssh port number) /tcp
```
Allow cardano-node p2p port
```
sudo ufw allow (your port #) /tcp
```
Allow chrony ntp
```
sudo ufw allow 123/udp
```
Enable Firewall
```
sudo ufw enable
```
Verify status
```
sudo ufw status numbered
```
Only open these following ports on nodes behind a network firewall Allow grafana web server port
```
sudo ufw allow 3000/tcp
```
Allow prometheus endpoint port
```
sudo ufw allow 9100/tcp
```
Allow prometheus cardano-node metric data port
```
sudo ufw allow 12798/tcp
```
This next step is optional but recomended to follow Permitting connections from a specific IP can be set up by following these next commands
```
sudo ufw allow (your laptop)
```
Example
* sudo ufw allow from (182.382.84.22)
# Configuration, Topology, Genesis
Starting the node and connecting it to the testnet requires three configuration files:
## config.json
This file defines what a node does, and includes the following four sub sections:
Basic node configuration, this declares the basic node configuration parameters. The basic configuration section might look like this:
```bash
{
"Protocol": "TPraos",
"GenesisFile": "ff-genesis.json",
"RequiresNetworkMagic": "RequiresMagic",
```
Update parameters, Block-producing nodes use a protocol version number as part of the system for the agreement and synchronization of protocol updates. When configuring this section, you need to be aware of the latest version of the protocol supported by the network The update parameters section might look like this:
```bash
"ApplicationName": "cardano-sl",
"ApplicationVersion": 0,
"LastKnownBlockVersion-Alt": 0,
"LastKnownBlockVersion-Major": 2,
"LastKnownBlockVersion-Minor": 0,
```
Tracing, Tracers tell the node what information you are interested in when logging. For example, switches that you can turn ON or OFF according to the type and quantity of information that you are interested in. This provides fairly coarse-grained control, but it is relatively efficient at filtering out unwanted trace output.
Logging control, It is possible to have more fine-grained control over filtering of trace output, and to match and route trace output to particular backends. This is less efficient than the coarse trace filters, but offers precise control options.
## topology.json
The information contained in this file tells the node which nodes in the network it should talk to.
A simple topology file might look like this:
```bash
{
"Producers": [
{
"addr": "x.x.x.x",
"port": 3001,
"valency": 1
}
]
}
```
## genesis.json
The genesis file is generated with the cardano-cli by reading a genesis.spec.json file.
The genesis file is very important, as it sets four key parameters:
genDelegs: maps from genesis keys to genesis delegates. initialFunds: maps from the initial addresses to the initial values at those addresses. MaxLovelaceSupply: the total amount of lovelaces in the blockchain. startTime: the time of slot zero.