If you’ve just started running OpenClaw on a Hetzner VPS, or any other cloud provider, and you’re seeing unexpected resource spikes or even crashes, especially during off-peak hours, you’re not alone. I encountered this frequently in my first month, leading to a lot of head-scratching. The problem often isn’t the OpenClaw core itself, but how underlying dependencies and resource management interact with the burstable nature of most cloud VMs. Specifically, I found that the default log rotation and temporary file cleanup mechanisms on my Ubuntu 22.04 LTS Hetzner instance were clashing with OpenClaw’s internal state management, leading to temporary file system exhaustion and subsequent application failure.
Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.
Understanding the “Phantom” Resource Spikes
My initial deployment was a standard OpenClaw setup: a small Python script invoking the OpenClaw API for daily summarization tasks, running within a Docker container on a CX21 (2 vCPU, 4GB RAM) Hetzner VPS. For the first few days, everything seemed fine. Then, I started noticing that my monitoring alerts for disk I/O and CPU utilization would spike erratically, usually between 2 AM and 4 AM UTC, often coinciding with OpenClaw failing to complete its tasks or, worse, the entire Docker daemon restarting. The docker logs openclaw-container command would often show truncated output or outright connection errors to the LLM provider, followed by messages like OSError: [Errno 28] No space left on device, even though df -h / showed plenty of free space.
The non-obvious insight here was the interaction between logrotate and OpenClaw’s default logging level. By default, OpenClaw can be quite verbose, especially during model inference or when encountering API errors. This verbosity, when combined with Docker’s default logging driver (usually json-file) and the host system’s logrotate, created a specific scenario. When logrotate would compress or move large Docker log files, it would briefly consume significant I/O and CPU, sometimes bottlenecking the already busy OpenClaw container trying to write its own logs or temporary inference data. The “no space left” error wasn’t about persistent disk space, but rather about temporary inode exhaustion or transient buffer space within the kernel during high I/O operations.
The Fix: Taming Logs and Temporary Files
To mitigate this, I made two critical adjustments. First, I configured Docker’s logging to be more conservative for the OpenClaw container. This prevents Docker itself from generating massive log files that need frequent rotation and compression. Add this to your docker-compose.yml for the OpenClaw service:
services:
openclaw:
image: openclaw/openclaw:latest
# ... other configurations ...
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
This limits the Docker logs for the openclaw service to a maximum of 10MB per file, keeping only the three most recent files. This dramatically reduced the strain on the host system during log rotation.
Second, and more importantly, I realized OpenClaw’s default tmp_dir was often pointing to the system’s default /tmp. While fine for short-lived data, some LLM providers (especially local ones or those with complex streaming responses) can buffer significant data there. If /tmp is on a small, fast filesystem or a memory-backed filesystem (like tmpfs on some distributions), it can hit its limits quickly. The solution was to explicitly define a dedicated temporary directory within OpenClaw’s configuration and ensure it was mounted as a volume in Docker, pointing to a persistent disk location.
Add this to your .openclaw/config.json:
{
"api_key": "your-api-key",
"default_model": "claude-haiku-4-5",
"tmp_dir": "/app/openclaw_tmp",
"logging": {
"level": "INFO",
"filename": "/var/log/openclaw.log",
"max_bytes": 10485760,
"backup_count": 5
}
}
Then, ensure this directory is mounted as a volume in your docker-compose.yml:
services:
openclaw:
image: openclaw/openclaw:latest
volumes:
- ./data/openclaw_tmp:/app/openclaw_tmp
- ./data/logs:/var/log
- ./config.json:/app/.openclaw/config.json:ro # Assuming config.json is in your project root
# ... rest of the service config ...
This ensures /app/openclaw_tmp inside the container maps to ./data/openclaw_tmp on your host, preventing temporary data from exhausting critical system partitions. Similarly, the /var/log mount ensures OpenClaw’s own logs are also managed externally.
Model Choice and Cost Efficiency
Another significant surprise was the default model recommendation. While the documentation often suggests the latest frontier models for maximum capability, I quickly found that for 90% of my production tasks – summarizing articles, extracting key entities, or generating short, factual responses – a cheaper, faster model was perfectly adequate. My initial setup used claude-opus-20240229. While incredibly powerful, its latency and cost quickly became prohibitive for high-volume tasks. Switching to claude-haiku-4-5 reduced my API costs by approximately 10x for the same workload and significantly decreased overall inference time without any noticeable degradation in result quality for my specific use cases. Always benchmark with your actual data and desired output quality before committing to the most expensive model.
Limitations and Resource Requirements
It’s crucial to be honest about the limitations. These optimizations primarily address I/O and temporary file management issues. They assume your VPS has sufficient base resources for OpenClaw to operate. This setup, for instance, works well on a Hetzner CX21 (2 vCPU, 4GB RAM) for moderate workloads (e.g., 50-100 summarization tasks per hour). If you’re attempting to run OpenClaw on something like a Raspberry Pi 4 with only 1GB or 2GB of RAM, especially if you’re pulling in larger models or running other services, you will still struggle. The overhead of the Docker daemon itself, the Python runtime, and the memory footprint of even smaller LLM interactions means that a minimum of 2GB RAM is generally required for a stable OpenClaw deployment, with 4GB being much more comfortable for any bursty usage. Attempting to run local LLMs on such low-spec hardware is a non-starter.
The insights here are specifically for cloud VPS environments where you have root access and can configure Docker and OpenClaw’s underlying file system interactions. If you’re running OpenClaw in a more restricted environment, like a shared hosting platform or a serverless function, some of these solutions might not be directly applicable, and you’d need to consult your provider’s specific guidelines for temporary file handling and resource limits.
Your next concrete step: modify your docker-compose.yml to include the logging options and the volume mounts for openclaw_tmp and logs as specified, then run docker-compose up -d --build to apply the changes.
Leave a Reply