{"id":33710,"date":"2026-11-06T07:27:59","date_gmt":"2026-11-06T10:27:59","guid":{"rendered":"https:\/\/www.neolo.com\/blog\/?p=33710"},"modified":"2026-11-06T07:27:59","modified_gmt":"2026-11-06T10:27:59","slug":"como-matar-un-proceso-en-linux-con-kill","status":"publish","type":"post","link":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php","title":{"rendered":"C\u00f3mo matar un proceso en Linux con kill"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Tiempo de lectura:<\/span> <span class=\"rt-time\"> 11<\/span> <span class=\"rt-label rt-postfix\">minutos<\/span><\/span><p><strong>TL;DR:<\/strong> Para matar un proceso en Linux, primero busca su PID con <code>ps aux | grep nombre<\/code>, <code>pgrep<\/code> o <code>top<\/code>. Luego ejecuta <code>kill PID<\/code>, que env\u00eda la se\u00f1al SIGTERM (15) y deja que el programa se cierre de forma ordenada. Si en unos segundos no responde, fu\u00e9rzalo con <code>kill -9 PID<\/code> (SIGKILL). Si no sabes el PID, <code>killall<\/code> mata por nombre exacto y <code>pkill<\/code> por patr\u00f3n.<\/p>\n<p>Casi siempre basta con dos comandos: uno para identificar el proceso y otro para enviarle una se\u00f1al. Lo que define si todo sale bien o si se rompe un servicio es elegir bien la se\u00f1al y asegurarte de que el proceso es el correcto. Esta gu\u00eda explica las dos cosas con ejemplos reales de un VPS con Ubuntu o Debian.<\/p>\n<ol>\n<li>Para qu\u00e9 sirve saber terminar procesos en un servidor<\/li>\n<li>\u00bfQu\u00e9 es un proceso y qu\u00e9 es el PID en Linux?<\/li>\n<li>\u00bfC\u00f3mo encontrar el PID de un proceso con ps, top y pgrep?<\/li>\n<li>Se\u00f1ales en Linux: SIGTERM, SIGKILL y las que casi nadie usa<\/li>\n<li>C\u00f3mo matar un proceso en Linux con kill, paso a paso<\/li>\n<li>kill, killall y pkill: diferencias y cu\u00e1ndo usar cada uno<\/li>\n<li>\u00bfPor qu\u00e9 el proceso vuelve a aparecer despu\u00e9s de matarlo?<\/li>\n<li>Errores comunes al matar un proceso en Linux en un VPS<\/li>\n<li>Preguntas frecuentes<\/li>\n<li>Lo que dicen los clientes de Neolo<\/li>\n<li>Conclusi\u00f3n<\/li>\n<\/ol>\n<h2>Para qu\u00e9 sirve saber terminar procesos en un servidor<\/h2>\n<p>Si tienes una tienda online, una API en Node.js, un flujo de automatizaci\u00f3n o un sitio en WordPress en tu propio servidor, tarde o temprano alg\u00fan proceso se va a colgar. Una tarea programada que no termina nunca, un script de importaci\u00f3n que ocupa el 100 % de la CPU o una aplicaci\u00f3n que deja el puerto 3000 bloqueado y no te deja volver a levantarla.<\/p>\n<p>En esos momentos no necesitas reiniciar todo el servidor. Si sabes terminar un proceso concreto, puedes:<\/p>\n<ul>\n<li>Recuperar la CPU y la memoria en segundos sin cortar el resto de los servicios.<\/li>\n<li>Liberar un puerto ocupado para volver a desplegar tu aplicaci\u00f3n.<\/li>\n<li>Recargar la configuraci\u00f3n de un servicio como Nginx sin cortar conexiones.<\/li>\n<li>Evitar que el kernel empiece a cerrar procesos al azar por falta de memoria (el famoso OOM killer).<\/li>\n<\/ul>\n<p>Para un emprendedor o una pyme que administra su propio servidor, esto marca la diferencia entre cinco minutos de lentitud y una hora con la web ca\u00edda. Si todav\u00eda est\u00e1s decidiendo qu\u00e9 sistema usar en tu servidor, conviene leer antes la comparaci\u00f3n <a href=\"https:\/\/www.neolo.com\/blog\/vps-linux-o-windows-cual-elegir.php\">VPS Linux o Windows: cu\u00e1l elegir<\/a>, porque todo lo que sigue aplica a Linux.<\/p>\n<h2>\u00bfQu\u00e9 es un proceso y qu\u00e9 es el PID en Linux?<\/h2>\n<p>Un proceso es un programa en ejecuci\u00f3n. Cada vez que arranca Nginx, PHP-FPM, MySQL o un <code>node app.js<\/code>, el kernel crea uno o varios procesos y le asigna a cada uno un n\u00famero \u00fanico: el <strong>PID<\/strong> (Process ID).<\/p>\n<p>Hay algunos datos que conviene tener claros desde el principio:<\/p>\n<ul>\n<li><strong>PID 1<\/strong> es el sistema de inicio, en casi todas las distribuciones actuales <code>systemd<\/code>. Est\u00e1 protegido: no se puede matar con una se\u00f1al normal.<\/li>\n<li><strong>PPID<\/strong> es el PID del proceso padre. Si un proceso padre lanza hijos (por ejemplo, el <em>master<\/em> de PHP-FPM y sus <em>workers<\/em>), matar al padre suele arrastrar a los hijos, y matar solo un hijo hace que el padre lance otro.<\/li>\n<li><strong>Estado del proceso<\/strong>: en la columna <code>STAT<\/code> de <code>ps<\/code> ver\u00e1s letras como <code>R<\/code> (ejecut\u00e1ndose), <code>S<\/code> (durmiendo), <code>D<\/code> (esperando disco o red, no se puede interrumpir), <code>Z<\/code> (zombie) o <code>T<\/code> (detenido). Este detalle explica por qu\u00e9 a veces <code>kill -9<\/code> \u00abno funciona\u00bb.<\/li>\n<\/ul>\n<h2>\u00bfC\u00f3mo encontrar el PID de un proceso con ps, top y pgrep?<\/h2>\n<p>Antes de matar algo tienes que saber exactamente qu\u00e9 vas a matar. Estas son las formas m\u00e1s \u00fatiles de hacerlo.<\/p>\n<h3>Con ps<\/h3>\n<p><code>ps aux<\/code> muestra todos los procesos del sistema con usuario, PID, CPU, memoria y el comando completo:<\/p>\n<pre><code class=\"language-bash\">ps aux | grep node\n<\/code><\/pre>\n<p>Una salida t\u00edpica en un VPS con una aplicaci\u00f3n Node colgada:<\/p>\n<pre><code class=\"language-text\">deploy    48213 98.7  6.1 1254880 249312 ?  Rl  10:02  41:17 node \/home\/deploy\/app\/server.js\ndeploy    51022  0.0  0.0   6480   2240 pts\/0 S+  10:44   0:00 grep --color=auto node\n<\/code><\/pre>\n<p>La segunda l\u00ednea es el propio <code>grep<\/code> y se puede ignorar. El PID que te interesa es <code>48213<\/code>, y adem\u00e1s ves que consume casi el 99 % de la CPU.<\/p>\n<p>Para ver los procesos que m\u00e1s memoria consumen:<\/p>\n<pre><code class=\"language-bash\">ps aux --sort=-%mem | head -n 10\n<\/code><\/pre>\n<h3>Con pgrep y pidof<\/h3>\n<p><code>pgrep<\/code> devuelve directamente el PID, sin ruido. Con <code>-a<\/code> muestra tambi\u00e9n el comando completo, que es la mejor forma de confirmar antes de actuar:<\/p>\n<pre><code class=\"language-bash\">pgrep -a node\npidof nginx\n<\/code><\/pre>\n<h3>Con top o htop<\/h3>\n<p><code>top<\/code> muestra los procesos en tiempo real. En la pr\u00e1ctica, es lo primero que se abre cuando el servidor \u00abanda lento\u00bb:<\/p>\n<ul>\n<li>Pulsa <strong>Shift + P<\/strong> para ordenar por CPU y <strong>Shift + M<\/strong> para ordenar por memoria.<\/li>\n<li>Pulsa <strong>k<\/strong>, escribe el PID y confirma la se\u00f1al (por defecto 15, SIGTERM) para matarlo desde la misma pantalla.<\/li>\n<\/ul>\n<p><code>htop<\/code> es m\u00e1s visual y permite seleccionar el proceso con las flechas y pulsar <strong>F9<\/strong> para elegir la se\u00f1al. En muchas im\u00e1genes m\u00ednimas de VPS no viene instalado: <code>sudo apt install htop<\/code>.<\/p>\n<h3>Cuando lo que sabes es el puerto<\/h3>\n<p>Si una aplicaci\u00f3n no arranca con el error <code>EADDRINUSE<\/code> o \u00abAddress already in use\u00bb, el problema es un proceso viejo que sigue escuchando en ese puerto:<\/p>\n<pre><code class=\"language-bash\">sudo ss -ltnp | grep :3000\nsudo lsof -i :3000\n<\/code><\/pre>\n<p>Ambos comandos muestran el PID que tiene ocupado el puerto.<\/p>\n<h2>Se\u00f1ales en Linux: SIGTERM, SIGKILL y las que casi nadie usa<\/h2>\n<p><code>kill<\/code> no \u00abmata\u00bb en sentido estricto: <strong>env\u00eda una se\u00f1al<\/strong>. El proceso decide qu\u00e9 hacer con ella, salvo en dos casos (SIGKILL y SIGSTOP) que el kernel aplica sin preguntar. Puedes ver la lista completa con <code>kill -l<\/code>.<\/p>\n<table>\n<thead>\n<tr>\n<th>Se\u00f1al<\/th>\n<th>N\u00famero<\/th>\n<th>Qu\u00e9 hace<\/th>\n<th>Cu\u00e1ndo usarla<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>SIGTERM<\/td>\n<td>15<\/td>\n<td>Pide al proceso que termine; puede cerrar archivos y conexiones<\/td>\n<td>Siempre como primera opci\u00f3n (es la que usa <code>kill<\/code> por defecto)<\/td>\n<\/tr>\n<tr>\n<td>SIGKILL<\/td>\n<td>9<\/td>\n<td>El kernel elimina el proceso de inmediato; no se puede capturar<\/td>\n<td>Solo si SIGTERM no funcion\u00f3 tras unos segundos<\/td>\n<\/tr>\n<tr>\n<td>SIGINT<\/td>\n<td>2<\/td>\n<td>Equivale a pulsar Ctrl + C<\/td>\n<td>Interrumpir un script lanzado en primer plano<\/td>\n<\/tr>\n<tr>\n<td>SIGHUP<\/td>\n<td>1<\/td>\n<td>Muchos daemons la interpretan como \u00abrecarga la configuraci\u00f3n\u00bb<\/td>\n<td>Recargar Nginx o rsyslog sin cortar el servicio<\/td>\n<\/tr>\n<tr>\n<td>SIGSTOP<\/td>\n<td>19 (x86\/ARM)<\/td>\n<td>Congela el proceso sin terminarlo<\/td>\n<td>Pausar un proceso pesado para investigarlo<\/td>\n<\/tr>\n<tr>\n<td>SIGCONT<\/td>\n<td>18 (x86\/ARM)<\/td>\n<td>Reanuda un proceso detenido<\/td>\n<td>Continuar tras SIGSTOP<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>La diferencia pr\u00e1ctica entre SIGTERM y SIGKILL es enorme. Con SIGTERM, MySQL escribe lo que tiene pendiente, Node cierra las conexiones y un script de backup borra sus archivos temporales. Con SIGKILL el proceso desaparece en mitad de lo que estuviera haciendo: pueden quedar archivos <code>.lock<\/code>, tablas que necesitan reparaci\u00f3n o un archivo comprimido a medias.<\/p>\n<p>Los n\u00fameros de SIGSTOP y SIGCONT cambian seg\u00fan la arquitectura (en MIPS o SPARC son otros). Por eso, en scripts conviene escribir el nombre: <code>kill -SIGTERM<\/code>, <code>kill -TERM<\/code> o <code>kill -s TERM<\/code> funcionan en cualquier sistema.<\/p>\n<h2>C\u00f3mo matar un proceso en Linux con kill, paso a paso<\/h2>\n<p>Este es el procedimiento que se sigue en un VPS de producci\u00f3n cuando una aplicaci\u00f3n se queda colgada. El ejemplo usa el proceso Node del apartado anterior (PID 48213) en Ubuntu 24.04 LTS, pero es igual en Debian, AlmaLinux o Rocky Linux.<\/p>\n<ol>\n<li><strong>Con\u00e9ctate<\/strong> al servidor por SSH con un usuario con permisos de <code>sudo<\/code>. Si solo tienes acceso como root o necesitas configurarlo, aqu\u00ed se explica <a href=\"https:\/\/www.neolo.com\/blog\/habilitar-root-ssh.php\">c\u00f3mo habilitar Root SSH de forma segura<\/a>.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">ssh deploy@203.0.113.25\n<\/code><\/pre>\n<ol>\n<li><strong>Identifica<\/strong> el proceso y confirma el comando completo para no equivocarte de PID.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">pgrep -a node\n<\/code><\/pre>\n<ol>\n<li><strong>Revisa<\/strong> qui\u00e9n es el due\u00f1o del proceso y si tiene un proceso padre que lo vuelva a lanzar.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">ps -o pid,ppid,user,stat,etime,cmd -p 48213\n<\/code><\/pre>\n<ol>\n<li><strong>Env\u00eda<\/strong> SIGTERM para pedirle que se cierre de forma ordenada.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">kill 48213\n<\/code><\/pre>\n<p>Si el proceso pertenece a otro usuario (por ejemplo, <code>www-data<\/code> o <code>mysql<\/code>), necesitar\u00e1s <code>sudo kill 48213<\/code>.<\/p>\n<ol>\n<li><strong>Comprueba<\/strong> si termin\u00f3. <code>kill -0<\/code> no env\u00eda ninguna se\u00f1al: solo verifica si el proceso sigue existiendo.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">sleep 5; kill -0 48213 &amp;&amp; echo &quot;Sigue vivo&quot; || echo &quot;Terminado&quot;\n<\/code><\/pre>\n<ol>\n<li><strong>Fuerza<\/strong> el cierre con SIGKILL solo si sigue vivo despu\u00e9s de esperar.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">kill -9 48213\n<\/code><\/pre>\n<ol>\n<li><strong>Investiga<\/strong> la causa para que no vuelva a pasar: revisa los logs de la aplicaci\u00f3n y comprueba si el kernel cerr\u00f3 algo por falta de memoria.<\/li>\n<\/ol>\n<pre><code class=\"language-bash\">sudo journalctl -u miapp --since &quot;30 min ago&quot;\nsudo dmesg -T | grep -i &quot;killed process&quot;\n<\/code><\/pre>\n<p>Para cerrar varios procesos a la vez, <code>kill<\/code> acepta varios PID: <code>kill 48213 48214 48220<\/code>. Y si quieres terminar un grupo de procesos completo (un script y todos sus hijos), puedes enviar la se\u00f1al al grupo con el PGID precedido de un guion: <code>kill -- -48200<\/code>.<\/p>\n<h2>kill, killall y pkill: diferencias y cu\u00e1ndo usar cada uno<\/h2>\n<p>Los tres env\u00edan se\u00f1ales y por defecto usan SIGTERM. Cambia la forma de elegir el objetivo.<\/p>\n<table>\n<thead>\n<tr>\n<th>Criterio<\/th>\n<th>kill<\/th>\n<th>killall<\/th>\n<th>pkill<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>C\u00f3mo identifica el proceso<\/td>\n<td>Por PID<\/td>\n<td>Por nombre exacto<\/td>\n<td>Por patr\u00f3n (expresi\u00f3n regular)<\/td>\n<\/tr>\n<tr>\n<td>Paquete en Debian\/Ubuntu<\/td>\n<td>Integrado en bash y <code>procps<\/code><\/td>\n<td><code>psmisc<\/code><\/td>\n<td><code>procps<\/code><\/td>\n<\/tr>\n<tr>\n<td>Ejemplo<\/td>\n<td><code>kill 48213<\/code><\/td>\n<td><code>killall php-fpm8.3<\/code><\/td>\n<td><code>pkill -f \"server.js\"<\/code><\/td>\n<\/tr>\n<tr>\n<td>Riesgo de matar algo que no quer\u00edas<\/td>\n<td>Bajo<\/td>\n<td>Medio<\/td>\n<td>Alto si el patr\u00f3n es corto<\/td>\n<\/tr>\n<tr>\n<td>Opci\u00f3n \u00fatil<\/td>\n<td><code>kill -0<\/code> para comprobar<\/td>\n<td><code>-i<\/code> pide confirmaci\u00f3n<\/td>\n<td><code>pgrep<\/code> para probar antes<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>killall: por nombre exacto<\/h3>\n<pre><code class=\"language-bash\">sudo killall -w php-fpm8.3\n<\/code><\/pre>\n<p>La opci\u00f3n <code>-w<\/code> espera a que todos los procesos terminen antes de devolverte la terminal, algo muy \u00fatil dentro de scripts. Otras opciones pr\u00e1cticas son <code>-u usuario<\/code> para limitarlo a un usuario e <code>-i<\/code> para que pida confirmaci\u00f3n uno por uno.<\/p>\n<p>Un detalle que se aprende con la pr\u00e1ctica: en im\u00e1genes m\u00ednimas de Debian o en contenedores, <code>killall<\/code> no viene instalado y aparece <code>command not found<\/code>. Se instala con <code>sudo apt install psmisc<\/code>. Y si alguna vez administras un servidor Solaris, ten cuidado: all\u00ed <code>killall<\/code> termina <strong>todos<\/strong> los procesos del sistema.<\/p>\n<h3>pkill: por patr\u00f3n<\/h3>\n<pre><code class=\"language-bash\">pgrep -af &quot;worker.py&quot;    # primero mira qu\u00e9 coincide\npkill -f &quot;worker.py&quot;     # luego mata exactamente eso\n<\/code><\/pre>\n<p><code>pkill<\/code> compara por defecto con el nombre del proceso, que el kernel limita a 15 caracteres. Con <code>-f<\/code> busca en la l\u00ednea de comandos completa, lo cual es imprescindible para scripts de Python o Node, donde el nombre del proceso es <code>python3<\/code> o <code>node<\/code>. Otras opciones \u00fatiles:<\/p>\n<ul>\n<li><code>pkill -x nginx<\/code>: coincidencia exacta, no parcial.<\/li>\n<li><code>pkill -u deploy<\/code>: todos los procesos de un usuario.<\/li>\n<li><code>pkill -HUP rsyslogd<\/code>: enviar otra se\u00f1al distinta de SIGTERM.<\/li>\n<\/ul>\n<p>La regla de oro: <strong>todo <code>pkill<\/code> va precedido de un <code>pgrep<\/code> con los mismos argumentos<\/strong>. <code>pkill php<\/code> mata <code>php-fpm<\/code>, <code>php8.3<\/code>, el script de un compa\u00f1ero y cualquier cosa que contenga esas tres letras.<\/p>\n<p>Hacer todo esto exige un servidor donde tengas acceso root y SSH real, algo que un hosting compartido no ofrece. Para quien ya ejecuta aplicaciones Node, Python, Docker o n8n, Neolo ofrece un <a href=\"https:\/\/www.neolo.com\/esp\/vps-hosting\/\">hosting VPS<\/a> con root completo y servidores en varias regiones del mundo. Si algo se complica en mitad de una emergencia, su soporte combina personas reales con herramientas de IA y responde el 80 % de las consultas en menos de una hora.<\/p>\n<p><a href=\"https:\/\/www.neolo.com\/esp\/vps-hosting\/\"><img decoding=\"async\" alt=\"Tabla de planes VPS de Neolo, del VPS 1 al VPS 7, con vCPU, RAM, SSD NVMe, transferencia y precio mensual\" src=\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/planes-vps-hosting-neolo-2026-10.png\" \/><\/a><\/p>\n<h2>\u00bfPor qu\u00e9 el proceso vuelve a aparecer despu\u00e9s de matarlo?<\/h2>\n<p>Es una de las situaciones m\u00e1s confusas para quien empieza: matas el proceso, ejecutas <code>pgrep<\/code> y aparece otra vez con un PID nuevo. No es un error, es que hay algo encargado de mantenerlo vivo.<\/p>\n<h3>Servicios gestionados por systemd<\/h3>\n<p>Si el servicio tiene <code>Restart=always<\/code> o <code>Restart=on-failure<\/code> en su unidad, systemd lo vuelve a lanzar en cuanto muere. En ese caso, lo correcto es pararlo desde systemd:<\/p>\n<pre><code class=\"language-bash\">sudo systemctl stop miapp\nsudo systemctl kill --signal=SIGKILL miapp   # solo si stop no responde\n<\/code><\/pre>\n<p>Al hacer <code>systemctl stop<\/code>, systemd env\u00eda SIGTERM y, si el servicio no termina dentro de <code>TimeoutStopSec<\/code> (90 segundos por defecto), env\u00eda SIGKILL. Lo mismo pasa con gestores como PM2 (<code>pm2 stop app<\/code>) o Supervisor (<code>supervisorctl stop app<\/code>): si matas el proceso por fuera, el gestor lo resucita.<\/p>\n<h3>Contenedores Docker<\/h3>\n<p><code>docker stop<\/code> env\u00eda SIGTERM al proceso principal del contenedor y, si no termina en 10 segundos, env\u00eda SIGKILL. <code>docker kill<\/code> env\u00eda SIGKILL directamente.<\/p>\n<p>Hay un matiz que provoca muchos dolores de cabeza: dentro del contenedor tu aplicaci\u00f3n corre como PID 1, y el kernel no aplica la acci\u00f3n por defecto de SIGTERM al PID 1 si el programa no la maneja expl\u00edcitamente. Por eso algunos contenedores tardan siempre exactamente 10 segundos en pararse. La soluci\u00f3n es manejar SIGTERM en el c\u00f3digo o arrancar el contenedor con <code>docker run --init<\/code>, que a\u00f1ade un peque\u00f1o proceso init (tini) que reenv\u00eda las se\u00f1ales.<\/p>\n<h3>Video: qu\u00e9 hosting usar con Docker<\/h3>\n<p><iframe loading=\"lazy\" title=\"\u00bfQu\u00e9 Hosting usar con Docker?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/vhE3PBuWKJQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe><\/p>\n<h3>Procesos zombie y procesos en estado D<\/h3>\n<p>Un proceso en estado <code>Z<\/code> (zombie) ya termin\u00f3: solo queda su entrada en la tabla de procesos, esperando que el padre la recoja. No se puede matar porque no hay nada que matar. Se resuelve terminando o reiniciando el proceso padre (b\u00fascalo con <code>ps -o ppid= -p PID<\/code>).<\/p>\n<p>Un proceso en estado <code>D<\/code> est\u00e1 esperando una operaci\u00f3n de disco o de red (por ejemplo, un montaje NFS ca\u00eddo). Ni siquiera SIGKILL lo elimina hasta que esa operaci\u00f3n termina. Si se acumulan muchos, el problema est\u00e1 en el almacenamiento, no en el proceso.<\/p>\n<h2>Errores comunes al matar un proceso en Linux en un VPS<\/h2>\n<ul>\n<li><strong>Usar <code>kill -9<\/code> como primera opci\u00f3n.<\/strong> Es el error m\u00e1s extendido. En MySQL o MariaDB puede obligar a una recuperaci\u00f3n al arrancar, y en aplicaciones que escriben archivos puede dejarlos corruptos. Antes de tocar procesos de bases de datos, aseg\u00farate de tener <a href=\"https:\/\/www.neolo.com\/esp\/backups\/\">copias de seguridad<\/a> recientes.<\/li>\n<li><strong>Matar el PID que aparece en la l\u00ednea del propio <code>grep<\/code>.<\/strong> Ese proceso ya termin\u00f3; usa <code>pgrep -a<\/code> para evitar la confusi\u00f3n.<\/li>\n<li><strong>Matar workers de PHP-FPM uno por uno.<\/strong> El proceso master los vuelve a lanzar, y si matas al master sin volver a levantarlo, la web empieza a responder con <a href=\"https:\/\/www.neolo.com\/blog\/que-es-el-error-503-service-unavailable-y-como-solucionarlo.php\">el error 503 Service Unavailable<\/a>. Lo correcto es <code>sudo systemctl restart php8.3-fpm<\/code>.<\/li>\n<li><strong>Ejecutar <code>kill -9 -1<\/code>.<\/strong> El <code>-1<\/code> significa \u00abtodos los procesos que puedo matar\u00bb. Como root, deja el servidor inaccesible y obliga a reiniciarlo desde el panel.<\/li>\n<li><strong>Matar procesos en vez de reiniciar el servicio.<\/strong> Si existe una unidad de systemd, <code>systemctl restart<\/code> es m\u00e1s limpio y queda registrado en el journal.<\/li>\n<li><strong>No investigar por qu\u00e9 se colg\u00f3.<\/strong> Si una tarea cron se cuelga todas las noches, matarla cada ma\u00f1ana no es una soluci\u00f3n. Envolverla con <code>timeout<\/code> limita su duraci\u00f3n autom\u00e1ticamente:<\/li>\n<\/ul>\n<pre><code class=\"language-bash\">timeout -k 10 3600 \/home\/deploy\/scripts\/importar.sh\n<\/code><\/pre>\n<p>Este comando env\u00eda SIGTERM al cabo de una hora y SIGKILL diez segundos despu\u00e9s si el script sigue vivo.<\/p>\n<h2>Preguntas frecuentes<\/h2>\n\n<div class=\"schema-faq wp-block-yoast-faq-block\"><div class=\"schema-faq-section\" id=\"faq-question-1793000000001\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfQu\u00e9 diferencia hay entre kill -9 y kill -15?<\/strong> <p class=\"schema-faq-answer\"><code>kill -15<\/code> env\u00eda SIGTERM, que pide al proceso que termine y le da tiempo para cerrar archivos, conexiones y transacciones. <code>kill -9<\/code> env\u00eda SIGKILL: el kernel elimina el proceso de inmediato, sin que este pueda reaccionar. Conviene usar siempre <code>-15<\/code> primero y recurrir a <code>-9<\/code> solo si el proceso no responde despu\u00e9s de unos segundos.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000002\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfPor qu\u00e9 no puedo matar un proceso zombie en Linux?<\/strong> <p class=\"schema-faq-answer\">Un proceso zombie ya termin\u00f3 su ejecuci\u00f3n. Solo queda su registro en la tabla de procesos, esperando que el proceso padre lea su c\u00f3digo de salida. Como no hay nada en ejecuci\u00f3n, ninguna se\u00f1al lo afecta. Para eliminarlo hay que identificar al padre con <code>ps -o ppid= -p PID<\/code> y reiniciarlo o terminarlo; entonces systemd recoge al zombie.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000003\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfC\u00f3mo matar un proceso que ocupa un puerto en Linux?<\/strong> <p class=\"schema-faq-answer\">Primero identifica qu\u00e9 proceso escucha en el puerto con <code>sudo ss -ltnp | grep :3000<\/code> o <code>sudo lsof -i :3000<\/code>, que muestran el PID. Despu\u00e9s env\u00eda <code>kill PID<\/code>. Tambi\u00e9n puedes usar <code>sudo fuser -k 3000\/tcp<\/code>, que localiza y termina el proceso en un solo paso, aunque conviene revisar antes qu\u00e9 est\u00e1s cerrando para no cortar un servicio necesario.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000004\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfC\u00f3mo terminar todos los procesos de un usuario en Linux?<\/strong> <p class=\"schema-faq-answer\">Usa <code>sudo pkill -u nombreusuario<\/code> o <code>sudo killall -u nombreusuario<\/code>. Ambos env\u00edan SIGTERM a todos los procesos de ese usuario. Primero comprueba qu\u00e9 se ver\u00e1 afectado con <code>pgrep -u nombreusuario -a<\/code>. Es \u00fatil cuando una cuenta comprometida o un usuario de despliegue tiene scripts descontrolados, pero no lo ejecutes nunca sobre root ni sobre usuarios de sistema como <code>mysql<\/code>.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000005\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfSe pierden datos al usar kill -9?<\/strong> <p class=\"schema-faq-answer\">Puede pasar. SIGKILL no deja que el proceso guarde lo que ten\u00eda en memoria, as\u00ed que se pierden las escrituras pendientes, quedan transacciones incompletas o archivos a medio generar. Las bases de datos modernas como MySQL con InnoDB o PostgreSQL se recuperan usando su registro de transacciones, pero los archivos temporales y las exportaciones a medias suelen quedar inservibles. Por eso SIGKILL es el \u00faltimo recurso.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000006\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfC\u00f3mo matar un proceso en Linux sin conocer el PID?<\/strong> <p class=\"schema-faq-answer\">Puedes usar <code>killall nombre<\/code>, que mata por nombre exacto del proceso, o <code>pkill patr\u00f3n<\/code>, que busca coincidencias parciales. Para scripts de Python o Node, a\u00f1ade <code>-f<\/code> a <code>pkill<\/code> para buscar en la l\u00ednea de comandos completa, por ejemplo <code>pkill -f server.js<\/code>. Antes de ejecutarlo, prueba el mismo patr\u00f3n con <code>pgrep -af<\/code> para ver exactamente qu\u00e9 procesos coinciden.<\/p><\/div><div class=\"schema-faq-section\" id=\"faq-question-1793000000007\"><strong class=\"schema-faq-question\" style=\"display:block;font-size:1.25em;margin:1.3em 0 .3em\">\u00bfPara qu\u00e9 sirve kill -HUP?<\/strong> <p class=\"schema-faq-answer\"><code>kill -HUP<\/code> env\u00eda SIGHUP. Originalmente indicaba que se hab\u00eda cortado la terminal, pero muchos daemons lo interpretan como una orden para recargar su configuraci\u00f3n sin detenerse. Por ejemplo, <code>sudo kill -HUP $(cat \/run\/nginx.pid)<\/code> hace que Nginx relea sus archivos y renueve sus workers sin cortar las conexiones activas. Si un programa no maneja esta se\u00f1al, SIGHUP lo termina.<\/p><\/div><\/div>\n\n<h2>Lo que dicen los clientes de Neolo<\/h2>\n<blockquote>\n<p>\u2605\u2605\u2605\u2605\u2605 <strong>Larisa Navarro<\/strong><br \/>\n\u00abMe contestan absolutamente todo y no pierden la paciencia. No es solo que me contestan, sino que me ayudan.\u00bb<\/p>\n<p>\u2605\u2605\u2605\u2605\u2605 <strong>Mauro Lopreste<\/strong><br \/>\n\u00abLlevo muchos a\u00f1os alojando mis webs en Neolo. La atenci\u00f3n siempre fue excelente.\u00bb<\/p>\n<p>\u2605\u2605\u2605\u2605\u2605 <strong>Bruno Balzani<\/strong><br \/>\n\u00abCliente desde 2009. Neolo lo que tiene es la mejor atenci\u00f3n, pero por lejos.\u00bb<\/p>\n<\/blockquote>\n<h2>Conclusi\u00f3n<\/h2>\n<p>Matar un proceso en Linux se reduce a una secuencia fija: identificar el PID con <code>pgrep -a<\/code>, <code>ps<\/code> o <code>top<\/code>; enviar SIGTERM con <code>kill<\/code>; esperar; y solo entonces usar <code>kill -9<\/code>. <code>killall<\/code> y <code>pkill<\/code> ahorran tiempo cuando no conoces el PID, pero siempre conviene comprobar antes qu\u00e9 coincide. Y si el proceso vuelve a aparecer, pararlo desde systemd, PM2 o Docker es lo correcto.<\/p>\n<p>Para practicar todo esto necesitas un servidor con acceso root. Neolo es una opci\u00f3n s\u00f3lida para pymes y desarrolladores que se administran su propio servidor: es una empresa bootstrapped que opera desde 2002, se financia con sus propios clientes y ofrece garant\u00eda de reembolso de 30 d\u00edas. Puedes revisar los planes de <a href=\"https:\/\/www.neolo.com\/esp\/vps-hosting\/\">hosting VPS con acceso root<\/a> y elegir el que se ajuste a lo que ejecutas hoy.<\/p>\n<hr \/>\n<p>Unas notas sobre las decisiones que tom\u00e9:<\/p>\n<ul>\n<li><strong>Video:<\/strong> us\u00e9 \u00ab\u00bfQu\u00e9 Hosting usar con Docker?\u00bb porque encaja con el apartado sobre se\u00f1ales en contenedores.<\/li>\n<li><strong>Categor\u00eda:<\/strong> ninguna de la lista es de Linux o servidores, as\u00ed que elige <code>desarrollo-web<\/code>.<\/li>\n<li><strong>Menciones de Neolo:<\/strong> escribe el nombre solo 3 veces en mi propio texto. Dos de las rese\u00f1as lo incluyen y no se pod\u00edan alterar. Si quieres que el nombre aparezca menos veces en total, puedes cambiar la rese\u00f1a de Bruno o la de Mauro por la de Nuria.<\/li>\n<li><strong>Enlaces a Neolo:<\/strong> son tres. Dos van al hosting VPS (la recomendaci\u00f3n a mitad del art\u00edculo y la conclusi\u00f3n) y uno a copias de seguridad, en la secci\u00f3n de errores comunes. Adem\u00e1s, la imagen enlaza a la p\u00e1gina de planes VPS.<\/li>\n<li><strong>Enlaces al blog:<\/strong> elige tres: Root SSH, VPS Linux o Windows y el error 503.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>TL;DR: Para matar un proceso en Linux, primero busca su PID con ps aux | grep nombre, pgrep o top. Luego ejecuta kill PID, que env\u00eda la se\u00f1al SIGTERM (15) y deja que el programa se cierre de forma ordenada. Si en unos segundos no responde, fu\u00e9rzalo con kill -9 PID (SIGKILL). Si no sabes [&hellip;]<\/p>\n","protected":false},"author":21,"featured_media":33711,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[351],"tags":[],"class_list":["post-33710","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-desarrollo-web"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v25.6 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>C\u00f3mo matar un proceso en Linux con kill - Neolo Blog<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"C\u00f3mo matar un proceso en Linux con kill - Neolo Blog\" \/>\n<meta property=\"og:description\" content=\"TL;DR: Para matar un proceso en Linux, primero busca su PID con ps aux | grep nombre, pgrep o top. Luego ejecuta kill PID, que env\u00eda la se\u00f1al SIGTERM (15) y deja que el programa se cierre de forma ordenada. Si en unos segundos no responde, fu\u00e9rzalo con kill -9 PID (SIGKILL). Si no sabes [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\" \/>\n<meta property=\"og:site_name\" content=\"Neolo Blog\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/neolohosting\" \/>\n<meta property=\"article:published_time\" content=\"2026-11-06T10:27:59+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg\" \/>\n\t<meta property=\"og:image:width\" content=\"2560\" \/>\n\t<meta property=\"og:image:height\" content=\"1707\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Leo\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@neolo\" \/>\n<meta name=\"twitter:site\" content=\"@neolo\" \/>\n<meta name=\"twitter:label1\" content=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"Leo\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\"},\"author\":{\"name\":\"Leo\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/5fe808bcffd4347c68bc5388a05a5a30\"},\"headline\":\"C\u00f3mo matar un proceso en Linux con kill\",\"datePublished\":\"2026-11-06T10:27:59+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\"},\"wordCount\":2994,\"publisher\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg\",\"articleSection\":[\"Desarrollo web\"],\"inLanguage\":\"es\"},{\"@type\":[\"WebPage\",\"FAQPage\"],\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\",\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\",\"name\":\"C\u00f3mo matar un proceso en Linux con kill - Neolo Blog\",\"isPartOf\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg\",\"datePublished\":\"2026-11-06T10:27:59+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#breadcrumb\"},\"mainEntity\":[{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006\"},{\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007\"}],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage\",\"url\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg\",\"contentUrl\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg\",\"width\":2560,\"height\":1707,\"caption\":\"A red 'Speed Kills' sign stands in a sunlit Maltese field, highlighting road safety.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Inicio\",\"item\":\"https:\/\/www.neolo.com\/blog\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Desarrollo web\",\"item\":\"https:\/\/www.neolo.com\/blog\/temas\/desarrollo-web\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"C\u00f3mo matar un proceso en Linux con kill\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#website\",\"url\":\"https:\/\/www.neolo.com\/blog\/\",\"name\":\"Neolo Blog\",\"description\":\"Blog de Neolo: Dominios, Web Hosting y Marketing Digital\",\"publisher\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.neolo.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#organization\",\"name\":\"Neolo\",\"url\":\"https:\/\/www.neolo.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2017\/07\/neolo-verde-chico.png\",\"contentUrl\":\"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2017\/07\/neolo-verde-chico.png\",\"width\":392,\"height\":83,\"caption\":\"Neolo\"},\"image\":{\"@id\":\"https:\/\/www.neolo.com\/blog\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/neolohosting\",\"https:\/\/x.com\/neolo\",\"https:\/\/www.instagram.com\/neolodotcom\/\",\"https:\/\/www.linkedin.com\/company\/neolo.com\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/5fe808bcffd4347c68bc5388a05a5a30\",\"name\":\"Leo\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/279168ad52820892dbc4c5b373d7fec5?s=96&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/279168ad52820892dbc4c5b373d7fec5?s=96&r=g\",\"caption\":\"Leo\"},\"url\":\"https:\/\/www.neolo.com\/blog\/author\/leo\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001\",\"position\":1,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001\",\"name\":\"\u00bfQu\u00e9 diferencia hay entre kill -9 y kill -15?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"kill -15 env\u00eda SIGTERM, que pide al proceso que termine y le da tiempo para cerrar archivos, conexiones y transacciones. kill -9 env\u00eda SIGKILL: el kernel elimina el proceso de inmediato, sin que este pueda reaccionar. Conviene usar siempre -15 primero y recurrir a -9 solo si el proceso no responde despu\u00e9s de unos segundos.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002\",\"position\":2,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002\",\"name\":\"\u00bfPor qu\u00e9 no puedo matar un proceso zombie en Linux?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Un proceso zombie ya termin\u00f3 su ejecuci\u00f3n. Solo queda su registro en la tabla de procesos, esperando que el proceso padre lea su c\u00f3digo de salida. Como no hay nada en ejecuci\u00f3n, ninguna se\u00f1al lo afecta. Para eliminarlo hay que identificar al padre con ps -o ppid= -p PID y reiniciarlo o terminarlo; entonces systemd recoge al zombie.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003\",\"position\":3,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003\",\"name\":\"\u00bfC\u00f3mo matar un proceso que ocupa un puerto en Linux?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Primero identifica qu\u00e9 proceso escucha en el puerto con sudo ss -ltnp | grep :3000 o sudo lsof -i :3000 , que muestran el PID. Despu\u00e9s env\u00eda kill PID . Tambi\u00e9n puedes usar sudo fuser -k 3000\/tcp , que localiza y termina el proceso en un solo paso, aunque conviene revisar antes qu\u00e9 est\u00e1s cerrando para no cortar un servicio necesario.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004\",\"position\":4,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004\",\"name\":\"\u00bfC\u00f3mo terminar todos los procesos de un usuario en Linux?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Usa sudo pkill -u nombreusuario o sudo killall -u nombreusuario . Ambos env\u00edan SIGTERM a todos los procesos de ese usuario. Primero comprueba qu\u00e9 se ver\u00e1 afectado con pgrep -u nombreusuario -a . Es \u00fatil cuando una cuenta comprometida o un usuario de despliegue tiene scripts descontrolados, pero no lo ejecutes nunca sobre root ni sobre usuarios de sistema como mysql .\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005\",\"position\":5,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005\",\"name\":\"\u00bfSe pierden datos al usar kill -9?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Puede pasar. SIGKILL no deja que el proceso guarde lo que ten\u00eda en memoria, as\u00ed que se pierden las escrituras pendientes, quedan transacciones incompletas o archivos a medio generar. Las bases de datos modernas como MySQL con InnoDB o PostgreSQL se recuperan usando su registro de transacciones, pero los archivos temporales y las exportaciones a medias suelen quedar inservibles. Por eso SIGKILL es el \u00faltimo recurso.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006\",\"position\":6,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006\",\"name\":\"\u00bfC\u00f3mo matar un proceso en Linux sin conocer el PID?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Puedes usar killall nombre , que mata por nombre exacto del proceso, o pkill patr\u00f3n , que busca coincidencias parciales. Para scripts de Python o Node, a\u00f1ade -f a pkill para buscar en la l\u00ednea de comandos completa, por ejemplo pkill -f server.js . Antes de ejecutarlo, prueba el mismo patr\u00f3n con pgrep -af para ver exactamente qu\u00e9 procesos coinciden.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"},{\"@type\":\"Question\",\"@id\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007\",\"position\":7,\"url\":\"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007\",\"name\":\"\u00bfPara qu\u00e9 sirve kill -HUP?\",\"answerCount\":1,\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"kill -HUP env\u00eda SIGHUP. Originalmente indicaba que se hab\u00eda cortado la terminal, pero muchos daemons lo interpretan como una orden para recargar su configuraci\u00f3n sin detenerse. Por ejemplo, sudo kill -HUP $(cat \/run\/nginx.pid) hace que Nginx relea sus archivos y renueve sus workers sin cortar las conexiones activas. Si un programa no maneja esta se\u00f1al, SIGHUP lo termina.\",\"inLanguage\":\"es\"},\"inLanguage\":\"es\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"C\u00f3mo matar un proceso en Linux con kill - Neolo Blog","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php","og_type":"article","og_title":"C\u00f3mo matar un proceso en Linux con kill - Neolo Blog","og_description":"TL;DR: Para matar un proceso en Linux, primero busca su PID con ps aux | grep nombre, pgrep o top. Luego ejecuta kill PID, que env\u00eda la se\u00f1al SIGTERM (15) y deja que el programa se cierre de forma ordenada. Si en unos segundos no responde, fu\u00e9rzalo con kill -9 PID (SIGKILL). Si no sabes [&hellip;]","og_url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php","og_site_name":"Neolo Blog","article_publisher":"https:\/\/www.facebook.com\/neolohosting","article_published_time":"2026-11-06T10:27:59+00:00","og_image":[{"width":2560,"height":1707,"url":"http:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg","type":"image\/jpeg"}],"author":"Leo","twitter_card":"summary_large_image","twitter_creator":"@neolo","twitter_site":"@neolo","twitter_misc":{"Escrito por":"Leo","Tiempo de lectura":"17 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#article","isPartOf":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php"},"author":{"name":"Leo","@id":"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/5fe808bcffd4347c68bc5388a05a5a30"},"headline":"C\u00f3mo matar un proceso en Linux con kill","datePublished":"2026-11-06T10:27:59+00:00","mainEntityOfPage":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php"},"wordCount":2994,"publisher":{"@id":"https:\/\/www.neolo.com\/blog\/#organization"},"image":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage"},"thumbnailUrl":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg","articleSection":["Desarrollo web"],"inLanguage":"es"},{"@type":["WebPage","FAQPage"],"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php","url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php","name":"C\u00f3mo matar un proceso en Linux con kill - Neolo Blog","isPartOf":{"@id":"https:\/\/www.neolo.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage"},"image":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage"},"thumbnailUrl":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg","datePublished":"2026-11-06T10:27:59+00:00","breadcrumb":{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#breadcrumb"},"mainEntity":[{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006"},{"@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007"}],"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#primaryimage","url":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg","contentUrl":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2026\/10\/como-matar-un-proceso-en-linux-con-kill-scaled.jpeg","width":2560,"height":1707,"caption":"A red 'Speed Kills' sign stands in a sunlit Maltese field, highlighting road safety."},{"@type":"BreadcrumbList","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Inicio","item":"https:\/\/www.neolo.com\/blog"},{"@type":"ListItem","position":2,"name":"Desarrollo web","item":"https:\/\/www.neolo.com\/blog\/temas\/desarrollo-web"},{"@type":"ListItem","position":3,"name":"C\u00f3mo matar un proceso en Linux con kill"}]},{"@type":"WebSite","@id":"https:\/\/www.neolo.com\/blog\/#website","url":"https:\/\/www.neolo.com\/blog\/","name":"Neolo Blog","description":"Blog de Neolo: Dominios, Web Hosting y Marketing Digital","publisher":{"@id":"https:\/\/www.neolo.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.neolo.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Organization","@id":"https:\/\/www.neolo.com\/blog\/#organization","name":"Neolo","url":"https:\/\/www.neolo.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.neolo.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2017\/07\/neolo-verde-chico.png","contentUrl":"https:\/\/www.neolo.com\/blog\/wp-content\/uploads\/2017\/07\/neolo-verde-chico.png","width":392,"height":83,"caption":"Neolo"},"image":{"@id":"https:\/\/www.neolo.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/neolohosting","https:\/\/x.com\/neolo","https:\/\/www.instagram.com\/neolodotcom\/","https:\/\/www.linkedin.com\/company\/neolo.com\/"]},{"@type":"Person","@id":"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/5fe808bcffd4347c68bc5388a05a5a30","name":"Leo","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.neolo.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/279168ad52820892dbc4c5b373d7fec5?s=96&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/279168ad52820892dbc4c5b373d7fec5?s=96&r=g","caption":"Leo"},"url":"https:\/\/www.neolo.com\/blog\/author\/leo"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001","position":1,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000001","name":"\u00bfQu\u00e9 diferencia hay entre kill -9 y kill -15?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"kill -15 env\u00eda SIGTERM, que pide al proceso que termine y le da tiempo para cerrar archivos, conexiones y transacciones. kill -9 env\u00eda SIGKILL: el kernel elimina el proceso de inmediato, sin que este pueda reaccionar. Conviene usar siempre -15 primero y recurrir a -9 solo si el proceso no responde despu\u00e9s de unos segundos.","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002","position":2,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000002","name":"\u00bfPor qu\u00e9 no puedo matar un proceso zombie en Linux?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"Un proceso zombie ya termin\u00f3 su ejecuci\u00f3n. Solo queda su registro en la tabla de procesos, esperando que el proceso padre lea su c\u00f3digo de salida. Como no hay nada en ejecuci\u00f3n, ninguna se\u00f1al lo afecta. Para eliminarlo hay que identificar al padre con ps -o ppid= -p PID y reiniciarlo o terminarlo; entonces systemd recoge al zombie.","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003","position":3,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000003","name":"\u00bfC\u00f3mo matar un proceso que ocupa un puerto en Linux?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"Primero identifica qu\u00e9 proceso escucha en el puerto con sudo ss -ltnp | grep :3000 o sudo lsof -i :3000 , que muestran el PID. Despu\u00e9s env\u00eda kill PID . Tambi\u00e9n puedes usar sudo fuser -k 3000\/tcp , que localiza y termina el proceso en un solo paso, aunque conviene revisar antes qu\u00e9 est\u00e1s cerrando para no cortar un servicio necesario.","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004","position":4,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000004","name":"\u00bfC\u00f3mo terminar todos los procesos de un usuario en Linux?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"Usa sudo pkill -u nombreusuario o sudo killall -u nombreusuario . Ambos env\u00edan SIGTERM a todos los procesos de ese usuario. Primero comprueba qu\u00e9 se ver\u00e1 afectado con pgrep -u nombreusuario -a . Es \u00fatil cuando una cuenta comprometida o un usuario de despliegue tiene scripts descontrolados, pero no lo ejecutes nunca sobre root ni sobre usuarios de sistema como mysql .","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005","position":5,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000005","name":"\u00bfSe pierden datos al usar kill -9?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"Puede pasar. SIGKILL no deja que el proceso guarde lo que ten\u00eda en memoria, as\u00ed que se pierden las escrituras pendientes, quedan transacciones incompletas o archivos a medio generar. Las bases de datos modernas como MySQL con InnoDB o PostgreSQL se recuperan usando su registro de transacciones, pero los archivos temporales y las exportaciones a medias suelen quedar inservibles. Por eso SIGKILL es el \u00faltimo recurso.","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006","position":6,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000006","name":"\u00bfC\u00f3mo matar un proceso en Linux sin conocer el PID?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"Puedes usar killall nombre , que mata por nombre exacto del proceso, o pkill patr\u00f3n , que busca coincidencias parciales. Para scripts de Python o Node, a\u00f1ade -f a pkill para buscar en la l\u00ednea de comandos completa, por ejemplo pkill -f server.js . Antes de ejecutarlo, prueba el mismo patr\u00f3n con pgrep -af para ver exactamente qu\u00e9 procesos coinciden.","inLanguage":"es"},"inLanguage":"es"},{"@type":"Question","@id":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007","position":7,"url":"https:\/\/www.neolo.com\/blog\/como-matar-un-proceso-en-linux-con-kill.php#faq-question-1793000000007","name":"\u00bfPara qu\u00e9 sirve kill -HUP?","answerCount":1,"acceptedAnswer":{"@type":"Answer","text":"kill -HUP env\u00eda SIGHUP. Originalmente indicaba que se hab\u00eda cortado la terminal, pero muchos daemons lo interpretan como una orden para recargar su configuraci\u00f3n sin detenerse. Por ejemplo, sudo kill -HUP $(cat \/run\/nginx.pid) hace que Nginx relea sus archivos y renueve sus workers sin cortar las conexiones activas. Si un programa no maneja esta se\u00f1al, SIGHUP lo termina.","inLanguage":"es"},"inLanguage":"es"}]}},"_links":{"self":[{"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/posts\/33710","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/comments?post=33710"}],"version-history":[{"count":5,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/posts\/33710\/revisions"}],"predecessor-version":[{"id":33896,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/posts\/33710\/revisions\/33896"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/media\/33711"}],"wp:attachment":[{"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/media?parent=33710"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/categories?post=33710"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.neolo.com\/blog\/wp-json\/wp\/v2\/tags?post=33710"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}