runlike
Given an existing docker container, prints the command line necessary to run a copy of it.
Top Related Projects
The lazier way to manage everything docker
Top-like interface for container metrics
A tool for exploring each layer in a docker image
a Docker + Kubernetes network trouble-shooting swiss-army container
Analyzes resource usage and performance characteristics of running containers.
Making Docker and Kubernetes management easy.
Quick Overview
runlike is a command-line tool that generates Docker run commands from running containers. It can be used to quickly recreate a container with the same configuration as an existing one, making it easier to manage and deploy applications in a containerized environment.
Pros
- Simplifies Container Replication:
runlikeallows you to easily recreate a container with the same configuration, saving time and reducing the risk of manual errors. - Supports a Wide Range of Options: The tool can handle a variety of Docker run options, including environment variables, volumes, network settings, and more.
- Cross-Platform Compatibility:
runlikeworks on Linux, macOS, and Windows, making it a versatile tool for developers and DevOps teams. - Open-Source and Actively Maintained: The project is open-source and has an active community, with regular updates and bug fixes.
Cons
- Limited to Docker Containers:
runlikeis specifically designed for Docker containers and may not work with other container runtimes. - Potential for Incomplete Configuration: While
runliketries to capture the full container configuration, it may miss some less common options or settings. - Requires Docker Installation: To use
runlike, you need to have Docker installed on your system, which may not be the case in all environments. - Lack of Advanced Features: The tool is relatively simple and may not provide the level of customization or integration that some users might require.
Getting Started
To get started with runlike, follow these steps:
- Install the
runliketool using your preferred method (e.g.,pip install runlikefor Python, or download the binary for your platform). - Run the
runlikecommand on a running container to generate the corresponding Docker run command:
runlike <container_name_or_id>
This will output the complete Docker run command that can be used to recreate the container.
- (Optional) Customize the generated command as needed, for example, to change the container name, update environment variables, or modify volume mounts.
- Run the modified command to create a new container with the desired configuration.
docker run [customized_options] <image>
That's it! You can now use runlike to quickly recreate containers and manage your Docker-based applications more efficiently.
Competitor Comparisons
The lazier way to manage everything docker
Pros of lazydocker
- Offers a comprehensive terminal UI for managing Docker containers, images, and volumes
- Provides real-time monitoring and logging capabilities
- Supports keyboard shortcuts for quick navigation and actions
Cons of lazydocker
- Requires installation and setup, unlike runlike which is a simple script
- May have a steeper learning curve for users new to terminal-based interfaces
- Consumes more system resources due to its interactive nature
Code comparison
runlike:
def get_docker_cli(container):
inspection = docker_client.inspect_container(container)
return DockerCli(inspection).get_cli()
lazydocker:
func (gui *Gui) renderMain() error {
return gui.renderPanel(gui.getMainView(), gui.State.MainContext)
}
Summary
runlike is a lightweight Python script that generates Docker run commands for existing containers, while lazydocker is a full-featured terminal UI for Docker management. runlike is simpler and more focused, while lazydocker offers a broader range of features and interactivity at the cost of increased complexity and resource usage.
Top-like interface for container metrics
Pros of ctop
- Real-time monitoring of multiple containers simultaneously
- Interactive terminal UI with color-coded metrics
- Supports filtering and sorting containers
Cons of ctop
- More complex to use for quick, one-off container inspections
- Requires installation and may not be available on all systems
Code Comparison
ctop:
func (cm *ContainerMetrics) CPUUtil() float64 {
return round((cm.cur.CPU.Usage - cm.prev.CPU.Usage) / float64(cm.cur.CPU.System-cm.prev.CPU.System) * 100)
}
runlike:
def get_docker_client():
return docker.from_env()
def get_container(container_id):
return get_docker_client().containers.get(container_id)
Summary
ctop is a more comprehensive tool for monitoring multiple containers in real-time, offering an interactive UI and advanced features. runlike, on the other hand, is simpler and focuses on generating Docker run commands for existing containers. ctop is better suited for ongoing monitoring and management, while runlike excels at quickly reproducing container configurations. The code snippets highlight the different approaches: ctop's Go code calculates CPU utilization, while runlike's Python code interacts with the Docker API to retrieve container information.
A tool for exploring each layer in a docker image
Pros of dive
- Provides a visual interface for exploring Docker image layers
- Offers detailed analysis of image size and efficiency
- Allows interactive exploration of image contents
Cons of dive
- More complex to use for simple image inspection tasks
- Requires terminal with UI capabilities
Code comparison
dive:
dive <image>
runlike:
runlike <container>
Key differences
- dive focuses on image analysis, while runlike recreates container run commands
- dive provides a more comprehensive view of image structure
- runlike is simpler to use for quick container inspection
Use cases
dive:
- Optimizing Docker images for size and efficiency
- Debugging image build issues
- Exploring image contents in detail
runlike:
- Quickly reproducing container run commands
- Inspecting container configurations
- Simplifying container management tasks
Community and maintenance
Both projects are open-source and actively maintained, with dive having a larger community and more frequent updates.
Integration
- dive integrates well with CI/CD pipelines for image optimization
- runlike can be easily incorporated into shell scripts and automation tools
a Docker + Kubernetes network trouble-shooting swiss-army container
Pros of netshoot
- Comprehensive networking and troubleshooting tools for containers
- Regularly updated with new tools and features
- Designed for Kubernetes and Docker environments
Cons of netshoot
- Larger image size due to numerous included tools
- May include unnecessary tools for specific use cases
- Steeper learning curve for users unfamiliar with networking tools
Code comparison
netshoot:
docker run -it --net container:<container_name> nicolaka/netshoot
runlike:
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
assaflavie/runlike <container_name>
Key differences
- Purpose: netshoot focuses on network troubleshooting, while runlike recreates Docker run commands
- Scope: netshoot provides a full toolkit, runlike serves a single specific function
- Usage: netshoot is interactive, runlike generates output for further use
Use cases
netshoot:
- Debugging network issues in containerized environments
- Analyzing container network traffic
- Troubleshooting Kubernetes networking problems
runlike:
- Recreating Docker run commands for existing containers
- Migrating containers between environments
- Documenting container configurations
Analyzes resource usage and performance characteristics of running containers.
Pros of cAdvisor
- Provides detailed resource usage and performance characteristics for containers
- Offers a web UI and REST API for easy access to container metrics
- Supports multiple container runtimes and orchestration platforms
Cons of cAdvisor
- More complex setup and configuration compared to runlike
- Requires additional resources to run as a separate container
- May be overkill for simple container inspection tasks
Code Comparison
cAdvisor (Go):
func NewContainerHandler(name string, inHostNamespace bool, metadataEnvs []string, includedMetrics container.MetricSet, collectorManager collector.CollectorManager) (container.ContainerHandler, error) {
return &dockerContainerHandler{
name: name,
machineInfoFactory: machineInfoFactory,
cgroupManager: cgroupManager,
}, nil
}
runlike (Python):
def get_docker_cli():
return docker.from_env(version='auto')
def get_container(container_id):
cli = get_docker_cli()
return cli.containers.get(container_id)
Summary
cAdvisor is a comprehensive container monitoring solution, offering detailed metrics and a user-friendly interface. It's ideal for complex container environments but may be excessive for simple tasks. runlike, on the other hand, is a lightweight tool focused on reproducing Docker run commands, making it more suitable for quick container inspection and replication.
Making Docker and Kubernetes management easy.
Pros of Portainer
- Comprehensive web-based UI for managing Docker environments
- Supports multiple Docker hosts and orchestration platforms
- Offers user management and access control features
Cons of Portainer
- More complex setup and resource-intensive compared to Runlike
- Requires a separate service to run alongside Docker
- May be overkill for simple Docker management tasks
Code Comparison
Runlike:
def get_docker_client():
return docker.from_env()
def get_container(name):
return get_docker_client().containers.get(name)
Portainer:
async function getDockerInfo() {
const response = await axios.get('/api/endpoints/1/docker/info');
return response.data;
}
Summary
Portainer is a feature-rich Docker management solution with a web interface, suitable for complex environments and team collaboration. Runlike is a lightweight command-line tool focused on recreating Docker run commands.
Portainer offers more comprehensive management capabilities but requires additional setup and resources. Runlike is simpler and more focused but lacks advanced features and a graphical interface.
The code snippets illustrate the different approaches: Runlike uses Python to interact directly with Docker, while Portainer employs a web API for communication.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
"See this docker container? I wish I could run another one just like it,
but I'll be damned if I'm going to type all those command-line switches manually!"
This is what runlike does. You give it a docker container, it outputs the command line necessary to run another one just like it, along with all those pesky options (ports, links, volumes, ...). It's a real time saver for those that normally deploy their docker containers via some CM tool like Ansible/Chef and then find themselves needing to manually re-run some container.
Usage
runlike <container-name>
This prints out what you need to run to get a similar container. You can do $(runlike container-name) to simply execute its output in one step.
-p breaks the command line down to nice, pretty lines. For example:
$ runlike -p redis
docker run \
--name=redis \
-e "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" \
-e "REDIS_VERSION=2.8.9" \
-e "REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-2.8.9.tar.gz" \
-e "REDIS_DOWNLOAD_SHA1=003ccdc175816e0a751919cf508f1318e54aac1e" \
-p 0.0.0.0:6379:6379/tcp \
--detach=true \
myrepo/redis:7860c450dbee9878d5215595b390b9be8fa94c89 \
redis-server --slaveof 172.31.17.84 6379
Feeding it the output of docker inspect also works:
docker inspect <container-name> | runlike --stdin
--no-name will omit the container name from the output (to avoid collisions).
Run without installing
runlike is packaged as a Docker image: assaflavie/runlike.
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
assaflavie/runlike YOUR-CONTAINER
You can also run it with an alias by adding the following to your ~/.profile or ~/.bashrc:
alias runlike="docker run --rm -v /var/run/docker.sock:/var/run/docker.sock assaflavie/runlike"
Now runlike should be available as a local command:
runlike YOUR-CONTAINER
Install
$ pip install runlike
Status
This is very much a work in progress. Many docker run options aren't yet supported, but the most commonly used ones are. Feel free to send pull requests if you add any or if you happen to fix any (of the many) bugs this package undoubtedly has.
Probably shouldn't use this in production yet. If you do, double check that it's actually running what you want it to run.
Supported Run Options
--add-host list Add a custom host-to-IP mapping
(host:ip)
--cap-add list Add Linux capabilities
--cap-drop list Drop Linux capabilities
(0-3, 0,1)
--cpuset-cpus string CPUs in which to allow execution
(0-3, 0,1)
--cpuset-mems string MEMs in which to allow execution
-d, --detach Run container in background and
print container ID
--device list Add a host device to the container
--dns list Set custom DNS servers
-e, --env list Set environment variables
--expose list Expose a port or a range of ports
-h, --hostname string Container host name
--mac-address string Container MAC address (e.g.,
92:d0:c6:0a:29:33)
-l, --label list Set meta data on a container
--log-driver string Logging driver for the container
--log-opt list Log driver options
--link list Add link to another container
-m, --memory bytes Memory limit
--memory-reservation bytes Memory soft limit
--name string Assign a name to the container
--network string Connect a container to a network
(default "default")
--pid string PID namespace to use
--privileged Give extended privileges to this
container
-p, --publish list Publish a container's port(s) to
the host
--restart string Restart policy to apply when a
container exits (default "no")
--rm Automatically remove the container
when it exits
--runtime string Runtime to use for this container
-t, --tty Allocate a pseudo-TTY
-u, --user string Username or UID (format:
<name|uid>[:<group|gid>])
-v, --volume list Bind mount a volume
--volumes-from list Mount volumes from the specified
container(s)
-w, --workdir string Working directory inside the container
Not Yet Supported Run Options (PRs are most welcome!)
-a, --attach list Attach to STDIN, STDOUT or STDERR
--blkio-weight uint16 Block IO (relative weight),
between 10 and 1000, or 0 to
disable (default 0)
--blkio-weight-device list Block IO weight (relative device
weight) (default [])
--cgroup-parent string Optional parent cgroup for the
container
--cidfile string Write the container ID to the file
--cpu-count int CPU count (Windows only)
--cpu-percent int CPU percent (Windows only)
--cpu-period int Limit CPU CFS (Completely Fair
Scheduler) period
--cpu-quota int Limit CPU CFS (Completely Fair
Scheduler) quota
--cpu-rt-period int Limit CPU real-time period in
microseconds
--cpu-rt-runtime int Limit CPU real-time runtime in
microseconds
-c, --cpu-shares int CPU shares (relative weight)
--cpus decimal Number of CPUs
--detach-keys string Override the key sequence for
detaching a container
--device-cgroup-rule list Add a rule to the cgroup allowed
devices list
--device-read-bps list Limit read rate (bytes per second)
from a device (default [])
--device-read-iops list Limit read rate (IO per second)
from a device (default [])
--device-write-bps list Limit write rate (bytes per
second) to a device (default [])
--device-write-iops list Limit write rate (IO per second)
to a device (default [])
--disable-content-trust Skip image verification (default true)
--dns-option list Set DNS options
--dns-search list Set custom DNS search domains
--entrypoint string Overwrite the default ENTRYPOINT
of the image
--env-file list Read in a file of environment variables
--group-add list Add additional groups to join
--health-cmd string Command to run to check health
--health-interval duration Time between running the check
(ms|s|m|h) (default 0s)
--health-retries int Consecutive failures needed to
report unhealthy
--health-start-period duration Start period for the container to
initialize before starting
health-retries countdown
(ms|s|m|h) (default 0s)
--health-timeout duration Maximum time to allow one check to
run (ms|s|m|h) (default 0s)
--help Print usage
--init Run an init inside the container
that forwards signals and reaps
processes
-i, --interactive Keep STDIN open even if not attached
--io-maxbandwidth bytes Maximum IO bandwidth limit for the
system drive (Windows only)
--io-maxiops uint Maximum IOps limit for the system
drive (Windows only)
--ip string IPv4 address (e.g., 172.30.100.104)
--ip6 string IPv6 address (e.g., 2001:db8::33)
--ipc string IPC mode to use
--isolation string Container isolation technology
--kernel-memory bytes Kernel memory limit
--label-file list Read in a line delimited file of labels
--link-local-ip list Container IPv4/IPv6 link-local
addresses
--memory-swap bytes Swap limit equal to memory plus
swap: '-1' to enable unlimited swap
--memory-swappiness int Tune container memory swappiness
(0 to 100) (default -1)
--mount mount Attach a filesystem mount to the
container
--network-alias list Add network-scoped alias for the
container
--no-healthcheck Disable any container-specified
HEALTHCHECK
--oom-kill-disable Disable OOM Killer
--oom-score-adj int Tune host's OOM preferences (-1000
to 1000)
--pids-limit int Tune container pids limit (set -1
for unlimited)
--platform string Set platform if server is
multi-platform capable
-P, --publish-all Publish all exposed ports to
random ports
--read-only Mount the container's root
filesystem as read only
--security-opt list Security Options
--shm-size bytes Size of /dev/shm
--sig-proxy Proxy received signals to the
process (default true)
--stop-signal string Signal to stop a container
(default "SIGTERM")
--stop-timeout int Timeout (in seconds) to stop a
container
--storage-opt list Storage driver options for the
container
--sysctl map Sysctl options (default map[])
--tmpfs list Mount a tmpfs directory
--ulimit ulimit Ulimit options (default [])
--userns string User namespace to use
--uts string UTS namespace to use
--volume-driver string Optional volume driver for the
container
Top Related Projects
The lazier way to manage everything docker
Top-like interface for container metrics
A tool for exploring each layer in a docker image
a Docker + Kubernetes network trouble-shooting swiss-army container
Analyzes resource usage and performance characteristics of running containers.
Making Docker and Kubernetes management easy.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot