# Multi Node

Following this page, you can run a localnet setup with docker that consists of a 4-node local chain. This setup can be useful for developers to test their applications and protocol features on a multi-node setup.

A similar setup is used by the LagomChain team to get insights about the impact of new features and testing different user flows. This testing setup can be found on the LagomChain testing repository.

#### Build & Start[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#build--start" id="build--start"></a>

To build start a 4 node testnet using [docker](https://docs.docker.com/engine/installation/), run:

This command creates a 4-node network using the `lagomdnode` Docker image. The ports for each node are found in this table:

| Node ID      | P2P Port | Tendermint RPC Port | REST/ Ethereum JSON-RPC Port | WebSocket Port |
| ------------ | -------- | ------------------- | ---------------------------- | -------------- |
| lagom`node0` | `26656`  | `26657`             | `8545`                       | `8546`         |
| lagom`node1` | `26659`  | `26660`             | `8547`                       | `8548`         |
| lagom`node2` | `26661`  | `26662`             | `8549`                       | `8550`         |
| lagom`node3` | `26663`  | `26664`             | `8551`                       | `8552`         |

To update the binary, just rebuild it and restart the nodes

The command above command will run containers in the background using Docker compose. You will see the network being created:

```
...
Creating network "lagom_localnet" with driver "bridge"
Creating lagomdnode0 ... done
Creating lagomdnode2 ... done
Creating lagomdnode1 ... done
Creating lagomdnode3 ... done
```

#### Stop Localnet[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#stop-localnet" id="stop-localnet"></a>

Once you are done, execute:

#### Configuration[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#configuration" id="configuration"></a>

The `make localnet-start` creates files for a 4-node testnet in `./build` by calling the `lagomd testnet` command. This outputs a handful of files in the `./build` directory:

```
tree -L 3 build/

build/
├── lagomd
├── lagomd
├── gentxs
│   ├── node0.json
│   ├── node1.json
│   ├── node2.json
│   └── node3.json
├── node0
│   ├── lagomd
│   │   ├── key_seed.json
│   │   └── keyring-test-cosmos
│   └── lagomd
│       ├── config
│       ├── data
│       └── lagomd.log
├── node1
│   ├── lagomd
│   │   ├── key_seed.json
│   │   └── keyring-test-cosmos
│   └── lagomd
│       ├── config
│       ├── data
│       └── lagomd.log
├── node2
│   ├── lagomd
│   │   ├── key_seed.json
│   │   └── keyring-test-cosmos
│   └── lagomd
│       ├── config
│       ├── data
│       └── lagomd.log
└── node3
├── lagomd
│   ├── key_seed.json
│   └── keyring-test-cosmos
└── lagomd
    ├── config
    ├── data
    └── lagomd.log
```

Each `./build/nodeN` directory is mounted to the `/`lagom`d` directory in each container.

#### Logging[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#logging" id="logging"></a>

In order to see the logs of a particular node you can use the following command:

```
# node 0: daemon logs
docker exec lagomdnode0 tail lagomd.log

# node 0: REST & RPC logs
docker exec lagomdnode0 tail lagomd.log
```

The logs for the daemon will look like:

```
I[2020-07-29|17:33:52.452] starting ABCI with Tendermint                module=main
E[2020-07-29|17:33:53.394] Can't add peer's address to addrbook         module=p2p err="Cannot add non-routable address [email protected]:26656"
E[2020-07-29|17:33:53.394] Can't add peer's address to addrbook         module=p2p err="Cannot add non-routable address [email protected]:26656"
E[2020-07-29|17:33:53.394] Can't add peer's address to addrbook         module=p2p err="Cannot add non-routable address [email protected]:26656"
I[2020-07-29|17:33:58.828] Executed block                               module=state height=88 validTxs=0 invalidTxs=0
I[2020-07-29|17:33:58.830] Committed state                              module=state height=88 txs=0 appHash=90CC5FA53CF8B5EC49653A14DA20888AD81C92FCF646F04D501453FD89FCC791
I[2020-07-29|17:34:04.032] Executed block                               module=state height=89 validTxs=0 invalidTxs=0
I[2020-07-29|17:34:04.034] Committed state                              module=state height=89 txs=0 appHash=0B54C4DB1A0DACB1EEDCD662B221C048C826D309FD2A2F31FF26BAE8D2D7D8D7
I[2020-07-29|17:34:09.381] Executed block                               module=state height=90 validTxs=0 invalidTxs=0
I[2020-07-29|17:34:09.383] Committed state                              module=state height=90 txs=0 appHash=75FD1EE834F0669D5E717C812F36B21D5F20B3CCBB45E8B8D415CB9C4513DE51
I[2020-07-29|17:34:14.700] Executed block                               module=state height=91 validTxs=0 invalidTxs=0
```

tip

You can disregard the `Can't add peer's address to addrbook` warning. As long as the blocks are being produced and the app hashes are the same for each node, there should not be any issues.

Whereas the logs for the REST & RPC server would look like:

```
I[2020-07-30|09:39:17.488] Starting application REST service (chain-id: "7305661614933169792")... module=rest-server
I[2020-07-30|09:39:17.488] Starting RPC HTTP server on 127.0.0.1:8545   module=rest-server
...
```

**Follow Logs**[**​**](broken://pages/EWknQlTHCCgKUGULC74Z)

You can also watch logs as they are produced via Docker with the `--follow` (`-f`) flag, for example:

```
docker logs -f lagomdnode0
```

#### Interact with the Localnet[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#interact-with-the-localnet" id="interact-with-the-localnet"></a>

**Ethereum JSON-RPC & Websocket Ports**[**​**](broken://pages/EWknQlTHCCgKUGULC74Z)

To interact with the testnet via WebSockets or RPC/API, you will send your request to the corresponding ports:

| EVM JSON-RPC | Eth Websocket |
| ------------ | ------------- |
| `8545`       | `8546`        |

You can send a curl command such as:

```
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}' -H "Content-Type: application/json" 192.162.10.1:8545
```

tip

The IP address will be the public IP of the docker container.

Additional instructions on how to interact with the WebSocket can be found on the events documentation.

#### Keys & Accounts[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#keys--accounts" id="keys--accounts"></a>

To interact with lagom`d` and start querying state or creating txs, you use the lagom`d` directory of any given node as your `home`, for example:

```
lagomd keys list --home ./build/node0/lagomd
```

Now that accounts exists, you may create new accounts and send those accounts funds!

tip

**Note**: Each node's seed is located at `./build/nodeN/lagomd/key_seed.json` and can be restored to the CLI using the `lagomd keys add --restore` command

#### Special Binaries[​](broken://pages/EWknQlTHCCgKUGULC74Z) <a href="#special-binaries" id="special-binaries"></a>

If you have multiple binaries with different names, you can specify which one to run with the BINARY environment variable. The path of the binary is relative to the attached volume. For example:

```
# Run with custom binary
BINARY=lagom make localnet-start
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.lagomchain.com/lagomchain-cli/multi-node.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.