Docker Rippled

https://github.com/wietsewind/docker-rippled
Admin
A Docker container for easily running a Rippled node, pre-configured with default settings and...
Tokens:4,104
Snippets:26
Trust Score:9.7
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Up Script to Start Rippled Container (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Starts a new rippled container using the './go/up' script. This script handles cleanup of existing containers and sets up the new container with automatic configuration mounting.

```bash
# Start on default port 80
./go/up

# Start on custom port
./go/up 8080

# Script operations:
# 1. Runs ./go/down to clean up existing containers
# 2. Creates new container named 'xrpld'
```

--------------------------------

### Start Rippled Container from Source

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Script to start a new Docker container named 'rippled' using the locally built image. It sets up port mappings and persistent configuration. An optional port number can be provided to map the websocket to a different host port.

```bash
# Default port mapping (80:80)
go/up

# Custom port mapping (e.g., 8080:80)
go/up 8080
```

--------------------------------

### Start rippled with Configuration and Arguments

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Executes the rippled daemon using the specified configuration file (/etc/opt/ripple/rippled.cfg) and forwards any additional command-line arguments and environment variables. This command is typically the final step in starting the XRP Ledger node within the container.

```bash
exec /opt/ripple/bin/rippled --conf /etc/opt/ripple/rippled.cfg $@$ENV_ARGS
```

--------------------------------

### Pass Arguments and Environment Variables to Rippled

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Example of how to pass environment variables and command-line arguments to the rippled container during runtime. Arguments can be passed directly or via the ENV_ARGS environment variable.

```bash
# Passing arguments directly
docker run \
  -e TESTVAR=123123 \
  -it --name rippled -p $PORT:80 \
  -v $(pwd)/../config:/config/ \
  xrpllabsofficial/xrpld:latest \
  -a \
  --start

# Passing arguments via ENV_ARGS environment variable
docker run \
  -e ENV_ARGS="-a --start" \
  -it --name rippled -p $PORT:80 \
  -v $(pwd)/../config:/config/ \
  xrpllabsofficial/xrpld:latest
```

--------------------------------

### Test WebSocket Connectivity to rippled with curl and wscat

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

This section provides bash commands to test WebSocket connectivity to a rippled node. It includes using 'curl' for HTTP POST requests and 'wscat' for interactive WebSocket testing, along with example requests and responses.

```bash
# Test HTTP connectivity
curl -X POST http://localhost:80 \
  -H 'Content-Type: application/json' \
  -d '{"method":"server_info","params":[{}]}'

# Using wscat for WebSocket testing
npm install -g wscat
wscat -c ws://localhost:80

# After connection, send:
{"command":"server_info"}

# Expected response:
{
  "result": {
    "info": {
      "complete_ledgers": "32570-91287",
      "server_state": "full"
    },
    "status": "success"
  }
}
```

--------------------------------

### Upgrade rippled Docker Image and Recreate Container

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

A step-by-step guide in bash to upgrade a running rippled Docker container to a new version. It covers stopping, removing the old container, pulling the new image, and recreating the container while preserving existing data volumes and configurations.

```bash
# 1. Stop the running container
docker stop rippled

# 2. Remove the container (data volumes preserved if mounted)
docker rm rippled

# 3. Remove old image
docker rmi xrpllabsofficial/xrpld:latest

# 4a. If using Docker Hub, pull new version
docker pull xrpllabsofficial/xrpld:latest

# 4b. If using Git repository, rebuild
git pull
./go/build

# 5. Recreate container with SAME volume paths to keep config
docker run -dit \
    --name rippled \
    -p 80:80 \
    -v /my/local/disk/xrpld-config/:/config/ \
    xrpllabsofficial/xrpld:latest

# IMPORTANT: Use the same -v path to preserve configuration
# If you change the volume path, your custom config will be lost
```

--------------------------------

### rippled Docker Entrypoint Configuration Loading Logic

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

This bash script snippet illustrates the configuration loading logic within the rippled Docker container's entrypoint script. It checks for a custom 'rippled.cfg' in the mounted '/config/' directory and copies it to '/etc/opt/ripple/rippled.cfg' if found.

```bash
# Entrypoint script logic (entrypoint.sh):

# 1. Print all arguments and environment variables for debugging
echo "Args: [$@]"
echo "Env Args: [$ENV_ARGS]"
printenv

# 2. Check for custom rippled.cfg
rippledconfig=`/bin/cat /config/rippled.cfg 2>/dev/null | wc -l`
if [[ "$rippledconfig" -gt "0" ]]; then
    echo "Existing rippled config at host /config/, using."
    /bin/cat /config/rippled.cfg > /etc/opt/ripple/rippled.cfg
fi

```

--------------------------------

### Build Docker Image for Rippled

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Command to build the Docker image for the rippled node. This is typically done locally after cloning the repository. It creates an image tagged as 'rippled'.

```bash
docker build --tag rippled:latest .
```

--------------------------------

### View Rippled Container Logs

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Command to follow the logs of the running 'rippled' container in real-time. Press CTRL+C to stop watching the logs.

```bash
docker logs -f rippled
```

--------------------------------

### Run Rippled on Apple M1/M2 Chips

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Command to run the rippled container on Apple M1/M2 chips, specifying the platform to ensure compatibility. This is a variation of the standard 'docker run' command.

```bash
docker run -dit \
    --name rippled \
    --platform linux/amd64 \
    -p 80:80 \
    -v /my/local/disk/xrpld-config/:/config/ \
    xrpllabsofficial/xrpld:latest
```

--------------------------------

### Initialize validators.txt from Host Configuration

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

This script checks for a custom validators.txt file on the host machine at /config/. If found, it copies the content to the container's /etc/opt/ripple/validators.txt to apply custom validator configurations. It uses wc -l to count lines, ensuring a non-empty file.

```bash
validatorstxt=`/bin/cat /config/validators.txt 2>/dev/null | wc -l`
if [[ "$validatorstxt" -gt "0" ]]; then
    echo "Existing validator config at host /config/, using."
    /bin/cat /config/validators.txt > /etc/opt/ripple/validators.txt
fi
```

--------------------------------

### Run Rippled Container from Docker Hub

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Command to run a rippled container using the official Docker Hub image 'xrpllabsofficial/xrpld'. This command maps port 80 from the host to the container and mounts a local configuration directory. Ensure the local path for the volume is valid.

```bash
docker run -dit \
    --name rippled \
    -p 80:80 \
    -v /my/local/disk/xrpld-config/:/config/ \
    xrpllabsofficial/xrpld:latest
```

--------------------------------

### Custom validators.txt Configuration (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Defines a custom `validators.txt` file using a bash heredoc. This configuration includes a list of validator list sites and their corresponding public keys.

```bash
# Example validators.txt structure
cat > config/validators.txt << 'EOF'
[validator_list_sites]
    https://vl.ripple.com

[validator_list_keys]
    ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734
EOF
```

--------------------------------

### Run Rippled Node Container (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Runs a rippled node container using a Docker image. It supports custom configuration volume mounting and specifies port mappings. An alternative command is provided for Apple M1/M2 chips.

```bash
# Create a config directory on your host
mkdir -p /my/local/disk/xrpld-config

# Run the container with volume mounting
docker run -dit \
    --name rippled \
    -p 80:80 \
    -v /my/local/disk/xrpld-config/:/config/ \
    xrpllabsofficial/xrpld:latest

# For Apple M1/M2 chips, add platform flag
docker run -dit \
    --name rippled \
    --platform linux/amd64 \
    -p 80:80 \
    -v /my/local/disk/xrpld-config/:/config/ \
    xrpllabsofficial/xrpld:latest

# View logs (Ctrl+C to detach, container continues running)
docker logs -f rippled

# Check server status
docker exec rippled rippled server_info
```

--------------------------------

### Build Docker Image for Rippled Node (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Builds the Docker image for the rippled node with a specified version and platform. It then pushes the image to Docker Hub and tags it as 'latest'.

```bash
# Set the version you want to build
version=2.6.1

# Build for AMD64 architecture with no cache
docker build --platform linux/amd64 --no-cache --tag xrpllabsofficial/xrpld:$version .

# Push to Docker Hub
docker push xrpllabsofficial/xrpld:$version

# Tag as latest
docker tag xrpllabsofficial/xrpld:$version xrpllabsofficial/xrpld:latest
docker push xrpllabsofficial/xrpld:latest
```

--------------------------------

### Custom rippled.cfg Configuration (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Defines a custom `rippled.cfg` file using a bash heredoc. This configuration includes settings for RPC admin, public WebSocket, node size, database path, ledger history, and more.

```bash
cat > config/rippled.cfg << 'EOF'
[server]
port_rpc_admin_local
port_ws_public

[port_rpc_admin_local]
port = 5005
ip = 127.0.0.1
admin = 127.0.0.1
protocol = http

[port_ws_public]
port = 80
ip = 0.0.0.0
protocol = ws

[node_size]
small

[node_db]
type=NuDB
path=/var/lib/rippled/db/nudb
advisory_delete=0
online_delete=256

[ledger_history]
256

[database_path]
/var/lib/rippled/db

[debug_logfile]
/var/log/rippled/debug.log

[sntp_servers]
time.windows.com
time.apple.com
time.nist.gov
pool.ntp.org

[ips]
r.ripple.com 51235

[validators_file]
validators.txt

[rpc_startup]
{ "command": "log_level", "severity": "info" }

[ssl_verify]
1
EOF
```

--------------------------------

### Run Rippled with Custom Config Files (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Runs a rippled node container using custom `rippled.cfg` and `validators.txt` files that have been mounted via a volume. This allows for persistent and customized node configurations.

```bash
# Run with these configs
docker run -dit \
    --name rippled \
    -p 80:80 \
    -v $(pwd)/config:/config/ \
    xrpllabsofficial/xrpld:latest
```

--------------------------------

### Build Script for Docker Rippled (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Executes a local build script for the Docker Rippled image. This script stops existing containers, removes the old image, and builds a new one with the --no-cache flag.

```bash
# From the repository root
./go/build

# Script operations:
# 1. Stops all running xrpllabsofficial/xrpld:latest containers
# 2. Removes existing xrpllabsofficial/xrpld:latest image
# 3. Builds new image with --no-cache flag
# 4. Tags as xrpllabsofficial/xrpld:latest

# After build completes, run:
./go/up
```

--------------------------------

### Pass Arguments and Env Vars to Rippled Container (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Demonstrates two methods for passing rippled command-line arguments and environment variables to the container. Method 1 uses direct arguments, while Method 2 uses the `ENV_ARGS` environment variable.

```bash
# Method 1: Direct arguments
docker run \
  -e TESTVAR=123123 \
  -it --name rippled -p 80:80 \
  -v $(pwd)/config:/config/ \
  xrpllabsofficial/xrpld:latest \
  -a \
  --start

# Method 2: Using ENV_ARGS environment variable
docker run \
  -e ENV_ARGS="-a --start" \
  -it --name rippled -p 80:80 \
  -v $(pwd)/config:/config/ \
  xrpllabsofficial/xrpld:latest

# The entrypoint script will print all arguments and environment
# Output example:
# Args:
#     >> [-a --start]
# Env Args:
#     >> [-a --start]
```

--------------------------------

### Monitor rippled Node Logs and Server Status with Docker

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Provides Docker commands to monitor the logs and server status of a rippled node. It includes options for following logs in real-time, viewing the last N lines, and executing the 'server_info' RPC command to check sync status.

```bash
# Follow logs in real-time
docker logs -f rippled

# View last 100 lines
docker logs --tail 100 rippled

# Check server info including sync status
docker exec rippled rippled server_info

# Example output (check complete_ledgers field):
{
  "result": {
    "info": {
      "complete_ledgers": "32570-91287",
      "hostid": "CRANE",
      "server_state": "full",
      "validated_ledger": {
        "hash": "...",
        "seq": 91287
      }
    },
    "status": "success"
  }
}

# When complete_ledgers shows range, node is synced
# Empty complete_ledgers means still syncing (wait a few minutes)
```

--------------------------------

### Connect to rippled WebSocket with xrpl.js

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

This JavaScript code snippet shows how to connect to a Dockerized rippled node using the xrpl.js library. It demonstrates establishing a connection, fetching server and account information, and subscribing to ledger updates.

```javascript
const xrpl = require('xrpl');

// Connect to your dockerized rippled node
const client = new xrpl.Client('ws://localhost:80');

async function main() {
  try {
    // Connect to the node
    await client.connect();
    console.log('Connected to rippled node');

    // Get server info
    const serverInfo = await client.request({
      command: 'server_info'
    });
    console.log('Server state:', serverInfo.result.info.server_state);
    console.log('Complete ledgers:', serverInfo.result.info.complete_ledgers);

    // Get account info
    const accountInfo = await client.request({
      command: 'account_info',
      account: 'rN7n7otQDd6FczFgLdlqtyMVrn3HMfXqN',
      ledger_index: 'validated'
    });
    console.log('Account balance:', accountInfo.result.account_data.Balance);

    // Subscribe to ledger stream
    await client.request({
      command: 'subscribe',
      streams: ['ledger']
    });

    // Listen for ledger events
    client.on('ledgerClosed', (ledger) => {
      console.log('Ledger closed:', ledger.ledger_index);
    });

  } catch (error) {
    console.error('Error:', error);
  }
}

main();
```

--------------------------------

### Execute rippled RPC Commands within a Docker Container

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Demonstrates how to execute various rippled Remote Procedure Call (RPC) commands directly inside a running Docker container. This allows for detailed inspection of the node's state, accounts, ledgers, and peers.

```bash
# Server info
docker exec rippled rippled server_info

# Account info
docker exec rippled rippled account_info rN7n7otQDd6FczFgLdlqtyMVrn3HMfXqN

# Ledger info
docker exec rippled rippled ledger current

# Peer info
docker exec rippled rippled peers

# Transaction history
docker exec rippled rippled tx <transaction_hash>

# Account transactions
docker exec rippled rippled account_tx rN7n7otQDd6FczFgLdlqtyMVrn3HMfXqN
```

--------------------------------

### Check Rippled Server Status

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Command to execute within the running 'rippled' container to retrieve its server information. This is useful for checking synchronization status, such as the 'complete_ledgers' value.

```bash
docker exec rippled rippled server_info
```

--------------------------------

### Run Rippled Node on Custom Port (Bash)

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

Runs a rippled node container and exposes the WebSocket service on a custom host port (e.g., 8080) instead of the default port 80. The container still serves WebSocket on its internal port 80.

```bash
# Run on port 8080
docker run -dit \
    --name rippled \
    -p 8080:80 \
    -v $(pwd)/config:/config/ \
    xrpllabsofficial/xrpld:latest

# Container serves WebSocket on internal port 80, exposed on host port 8080
```

--------------------------------

### Stop and Remove Rippled Container

Source: https://github.com/wietsewind/docker-rippled/blob/master/README.md

Script to stop and remove the Docker container named 'rippled'. This is used to clean up resources after use.

```bash
go/down
```

--------------------------------

### Stop and Remove rippled Containers with Docker

Source: https://context7.com/wietsewind/docker-rippled/llms.txt

This bash script stops and removes all Docker containers running the xrplabsofficial/xrpld:latest image. It's designed to be safe to run even if no such containers are active.

```bash
# Stop and remove all xrpllabsofficial/xrpld:latest containers
./go/down

# Script finds containers by image name and removes them
# Safe to run even if no containers exist
```
Tokens:
Raw