Docker Run a Compose · Docker

Convertir docker run a docker compose — y de vuelta.

Para convertir docker run a docker compose, pega un comando docker run y obtén al instante el servicio de docker-compose.yml equivalente, o pega un servicio de Compose para reconstruir la línea de comandos. En tu navegador, sin instalar nada y sin registro.

Se ejecuta en tu navegador: nada de lo que pegas sale de esta página. Cómo lo demostramos

Se ejecuta en tu navegador Sin registro Bidireccional Actualizado el 29 jul 2026

Example

⌘/Ctrl + Enter

docker run input

Runs entirely in your browser — nothing is uploaded.

Tip: press Esc to release keyboard focus from the editor.

Output

Pick a mode, load an example or paste your own, then convert to see the result here.

La brecha

Un contenedor, dos formas.

Un comando docker run es estupendo para arrancar rápido, pero en el momento en que lo quieres reproducible —en control de versiones, revisado en una PR, iniciado con un solo comando— necesitas un docker-compose.yml. Traducir un muro de flags -p, -v y -e a mano es tedioso y propenso a errores: es fácil dejarse un flag, anidar mal una lista o entrecomillar un puerto incorrectamente.

Este convertidor hace la parte mecánica por ti, en ambos sentidos. Al pasar de docker run a docker compose, tokeniza el comando exactamente como lo haría un shell —respetando las comillas, los flags cortos agrupados y las continuaciones de línea— mapea cada flag sobre la clave de Compose correspondiente, y emite YAML determinista. En el otro sentido, de docker compose a docker run, reconstruye un comando ejecutable a partir de un servicio y te informa de las claves (depends_on, build, deploy) que sencillamente no tienen equivalente en el comando.

Todo se ejecuta en tu navegador, así que puedes convertir comandos que nombren registros privados o variables de entorno con secretos sin que nada salga de la pestaña. Consulta la referencia de docker run y la referencia de servicios de Compose.

Consulta el mapeo completo de flag a clave, o prueba el playground en vivo de arriba.

El pipeline

Cómo funciona.

Cinco pasos deterministas se ejecutan de principio a fin en cada conversión — todos dentro de la pestaña de tu navegador, cada vez.

Tokeniza el comando.

Un tokenizador consciente de POSIX divide la línea, respetando las comillas simples y dobles y las continuaciones de barra invertida más salto de línea, de modo que los valores entrecomillados y los pegados multilínea quedan intactos.
Quita el prefijo.

Se elimina un docker run o docker container run inicial, y los flags cortos agrupados como -it o -itp se expanden en sus flags individuales.
Clasifica cada flag.

Cada flag se mapea sobre un objeto de servicio —ports, volumes, environment, networks, capacidades, límites, labels y healthcheck— y el primer posicional pasa a ser la imagen, el resto el comando.
Emite YAML determinista.

Un pequeño escritor hecho a mano imprime un bloque services: estable y amigable con los diffs, indexado por el nombre del contenedor (o app), entrecomillando solo los escalares que YAML exige.
O hazlo a la inversa.

En modo compose → run el mismo modelo se reconstruye a partir del YAML de Compose analizado en un comando docker run, con las claves exclusivas de Compose expuestas como advertencias.

Referencia

Cada flag, mapeado.

Los flags de docker run que el conversor reconoce y las claves de docker-compose a las que se mapean. Cualquier cosa no reconocida se reporta como una nota en lugar de descartarse de forma silenciosa.

flag de docker run	Clave de Compose
-p / --publish	ports Entrecomillado, p. ej. "8080:80".
-v / --volume, --mount	volumes Forma corta source:target[:ro].
-e / --env	environment Una lista KEY=value.
--env-file	env_file Uno o más ficheros.
--name	container_name También la clave del servicio.
--restart	restart no / always / unless-stopped …
--network / --net	networks host / none → network_mode.
-w / --workdir	working_dir
-u / --user	user
--entrypoint	entrypoint
--hostname	hostname
--add-host	extra_hosts
--cap-add / --cap-drop	cap_add / cap_drop
--privileged	privileged
-m / --memory	mem_limit
--cpus	cpus
-l / --label	labels
--health-*	healthcheck cmd / interval / timeout / retries.
-i / -t	stdin_open / tty
--rm, -d / --detach	— (advertencia) Sin equivalente en Compose.

Entrada

docker run

docker run -d -p 8080:80 --name web \
  -v /data:/usr/share/nginx/html:ro \
  --restart unless-stopped nginx:alpine

Salida

docker-compose.yml

services:
  web:
    image: nginx:alpine
    container_name: web
    ports:
      - "8080:80"
    volumes:
      - /data:/usr/share/nginx/html:ro
    restart: unless-stopped

Tras convertir, inicia el servicio con docker compose up -d — el equivalente en Compose del flag -d original.

Siguiente paso

¿Ya tienes el servicio? Valida el pipeline y dimensiona los pods.

Un servicio de Compose rara vez viaja solo. Revisa el CI que compila y publica la imagen con el GitLab CI Validator, y cuando lleves el contenedor a Kubernetes, convierte sus límites de memoria y CPU en requests/limits seguros con la Kubernetes Resource Calculator — ambos por completo en tu navegador.

Abrir el GitLab CI Validator Abrir la Resource Calculator

next.sh

# build, push, deploy
docker build -t app .
docker compose up -d        # ← from this converter
kubectl apply -f deploy.yml # ← size it first

FAQ

Tus preguntas, respondidas.

Toca una pregunta para desplegar la respuesta.

¿Cómo convierto un comando docker run a un docker-compose.yml?

Pega el comando docker run completo en el convertidor con el modo puesto en run → compose y pulsa Convertir. Quita el docker run inicial, clasifica cada flag sobre un objeto de servicio, trata el primer token que no es flag como la imagen y el resto como el comando, e imprime un bloque services: listo para soltar en tu proyecto — sin instalar nada, sin demonio de Docker, y sin enviar nada a ningún sitio. Es la forma más rápida de pasar de docker run a docker-compose.yml.

¿Puedo convertir un docker compose de vuelta a un comando docker run?

Sí. Cambia el selector de modo a compose → run, pega una definición de servicio (o un fichero de Compose completo — se usa el primer servicio), y reconstruye un comando docker run equivalente, incluyendo puertos, volúmenes, entorno, redes, capacidades, límites de recursos y un healthcheck. Ir de docker compose a docker run es útil para depurar o lanzar un único contenedor sin escribir un fichero. Las claves que no tienen equivalente en docker run —depends_on, build, deploy, profiles— se reportan como advertencias en lugar de traducirse.

¿Cómo se mapean los flags de docker run a los campos de docker-compose?

Los habituales: -p/--publish → ports, -v/--volume y --mount → volumes, -e/--env → environment, --env-file → env_file, --name → container_name, --restart → restart, --network/--net → networks (o network_mode para host/none), -w/--workdir → working_dir, -u/--user → user, --entrypoint → entrypoint, --hostname → hostname, --add-host → extra_hosts, --cap-add/--cap-drop → cap_add/cap_drop, --privileged → privileged, -m/--memory → mem_limit, --cpus → cpus, -l/--label → labels, y los flags --health-* → un bloque healthcheck. -i y -t se mapean a stdin_open y tty.

¿Cómo se mapea docker run -p a ports en docker compose?

Cada flag -p/--publish se convierte en una entrada de la lista ports, entrecomillada para que YAML no la malinterprete como un número de tipo sexagesimal: -p 8080:80 pasa a "8080:80". Las formas con IP de host y protocolo, como -p 127.0.0.1:8080:80/tcp, se conservan literalmente, y varios flags -p se acumulan en la misma lista ports en el orden en que aparecen.

¿Cómo convierto los volúmenes de docker run -v a un fichero de compose?

Cada -v/--volume y cada --mount se añade a la lista volumes del servicio. La forma corta source:target[:ro] se conserva tal cual —por ejemplo /data:/usr/share/nginx/html:ro o un volumen con nombre como dbdata:/var/lib/postgresql/data— así que los montajes de bind y los volúmenes con nombre cruzan al fichero de Compose sin que tengas que reescribirlos a mano.

¿Cómo se escriben las variables de entorno de docker run -e en docker-compose?

Cada -e/--env se convierte en una entrada KEY=value de la lista environment, y cada --env-file pasa a la clave env_file. Los valores se conservan exactamente como los pegaste, así que las variables con secretos o nombres de host internos quedan intactas — y como todo ocurre en tu navegador, esos valores nunca salen de la pestaña.

¿En qué se convierte --restart en un servicio de docker-compose?

El flag --restart se mapea directamente a la clave restart del servicio, conservando el valor: no, always, unless-stopped o on-failure. Es uno de los pocos flags de docker run que tiene un equivalente uno a uno en Compose, así que la política de reinicio se traduce sin cambios.

¿Es gratis este convertidor de docker run a compose y funciona sin conexión?

Sí. Es un convertidor de docker run a compose online y gratis, sin cuenta ni registro, y se ejecuta 100% del lado del cliente: una vez cargada la página puedes convertir incluso sin conexión, porque el comando o el YAML que pegas se tokeniza y se convierte por completo dentro de la pestaña de tu navegador, sin subir nada a ningún servidor.

More free, private DevOps tools.

El conversor de Docker Run a Compose es una herramienta dentro de OpsCanopy — una creciente cubierta de validadores, conversores y probadores basados en navegador que nunca tocan un servidor.

Leer más sobre esto

¿Empiezas con Docker? Lee la guía de Docker →

Browse All Tools Back to OpsCanopy

39 herramientas gratuitas, todas pueden funcionar sin conexión — opscanopy.com funciona sin registro y sin subir nada.

Herramientas relacionadas: el validador de GitLab CI y la calculadora de recursos de Kubernetes. Explora el directorio completo de herramientas.

No está afiliado, respaldado ni patrocinado por Docker, Inc. Docker, docker run y Docker Compose son marcas comerciales de Docker, Inc., usadas aquí solo de forma descriptiva para identificar el comando y los formatos de fichero entre los que convierte esta herramienta.