Overview
When debugging code inside a container, developers often need to build a new image and deploy a new pod, which can be slow and cumbersome. HotPod eliminates this hassle by allowing developers to copy updated files into a running container and restart the process with the new code—without redeploying the container. This makes debugging and development faster and more efficient.
HotPod is an open-source, lightweight process manager built in Go, designed to dynamically start, stop, and restart processes inside running containers. It provides an easy way to manage processes while keeping the pod alive.
Why HotPod?
HotPod is designed to solve common challenges faced when debugging and managing processes inside containers:
Fast Debugging and Development: Modify code in a running container and restart the process instantly without redeploying.
Keep-Alive Functionality: Ensures the container stays up by restarting critical processes automatically if they exit unexpectedly.
Lightweight and Efficient: Written in Go with minimal resource overhead, making it ideal for cloud-native applications.
Graceful Shutdown: Supports SIGTERM handling with fallback to SIGKILL for robust process control.
Thread-Safe Execution: Utilizes Go's synchronization mechanisms to prevent multiple instances of the same process from running simultaneously.
Getting Started with HotPod
Installation
Download the latest HotPod release from the GitHub releases page:
wget https://github.com/niradler/hotpod/releases/latest/download/hotpod-linux-amd64 -O hotpod
chmod +x hotpod
./hotpod -help
Running a Process with HotPod
You can use HotPod to run and manage a simple HTTP server inside a container:
./hotpod -command "python -m http.server 8000" -shell "sh" -keepalive=true -host localhost -port 8080
Deploying HotPod in a Container
To demonstrate HotPod in action, let’s set up a Python-based container that uses HotPod to manage its processes.
Example: Running a Python Server with HotPod
Create a Dockerfile:
FROM python:3.9-alpine
WORKDIR /app
ARG HOTPOD_VERSION=latest
RUN wget https://github.com/niradler/hotpod/releases/latest/download/hotpod-linux-amd64 -O /app/hotpod && \
chmod +x /app/hotpod
CMD ["./hotpod", "-command", "python ./app.py", "-port", "8080", "-keepalive", "-host", ""]
Running the Container
docker build -t my-python-app .
docker run -d --name my-app-container my-python-app
Hot-Reloading Code Without Restarting the Container
Instead of rebuilding and redeploying an image to apply code changes, use HotPod to dynamically update your running process.
Copy the updated script into the running container:
docker cp new_app.py my-app-container:/app/new_app.py
Use HotPod’s API to restart the process with the new code:
curl -X POST http://localhost:8080/start -d '{"command": "python /app/new_app.py", "replace": true}'
HotPod ensures the previous process is gracefully stopped before launching the new one, preventing conflicts and ensuring smooth transitions.
Use Cases
HotPod significantly improves debugging and process management in multiple scenarios:
Fast Debugging Inside Containers: Update code and restart processes without redeploying the container.
Local Development: Hot-reload applications inside containers while preserving state.
Microservices in Kubernetes: Manage background jobs within pods without restarting them.
CI/CD Pipelines: Execute test suites and manage ephemeral workloads without disrupting container execution.
API & Configuration
HotPod exposes an API for process management, allowing developers to integrate it seamlessly into their workflows.
Full API docs can be found in: https://github.com/niradler/hotpod/blob/master/swagger.yaml
CLI Configuration Options
| Option | Description | Default |
-command | The command to run | "" |
-shell | The shell to execute the command (e.g., sh) | sh |
-keepalive | Keep the process running persistently | false |
-host | The host to listen on | localhost |
-port | The API server port | 8080 |
https://github.com/niradler/hotpod
