Comment tuer un processus s'exécutant sur un port particulier sous Linux?

J'ai essayé de fermer le tomcat en utilisant le répertoire ./shutdown.shtomcat /bin. Mais a constaté que le serveur n'était pas fermé correctement. Et donc je n'ai pas pu redémarrer
Mon tomcat fonctionne sur le port 8080.

Je veux tuer le processus tomcat en cours d'exécution 8080. Je veux d'abord avoir la liste des processus en cours d'exécution sur un port spécifique (8080) afin de sélectionner le processus à tuer.

Cela vous fuser 8080/tcpaffichera le PID du processus lié sur ce port.

Et cela fuser -k 8080/tcptuera ce processus.

Fonctionne uniquement sur Linux. Plus universel est l'utilisation de lsof -i4(ou 6 pour IPv6).

Pour répertorier tout processus écoutant le port 8080:

lsof -i:8080

Pour tuer tout processus écoutant le port 8080:

kill $(lsof -t -i:8080)

ou plus violemment:

kill -9 $(lsof -t -i:8080)

( -9correspond au SIGKILL - terminate immediately/hard killsignal: voir Liste des signaux de destruction et Quel est le but de l'option -9 dans la commande kill?. Si aucun signal n'est spécifié à kill, le signal TERM aka -15ou soft killest envoyé, ce qui parfois n'est pas suffisant pour tuer un processus.).

Utilisez la commande

 sudo netstat -plten |grep java

utilisé grep javacomme tomcatutilisationsjava que leurs processus.

Il affichera la liste des processus avec le numéro de port et l'identifiant du processus

tcp6       0      0 :::8080                 :::*                    LISTEN      
1000       30070621    16085/java

le nombre avant /javaest un identifiant de processus. Utilisez maintenant la killcommande pour tuer le processus

kill -9 16085

-9 implique que le processus sera tué de force.

J'ajouterais ce one-liner pour ne tuer que LISTEN sur un port spécifique:

kill -9 $(lsof -t -i:3000 -sTCP:LISTEN)

Vous pouvez utiliser la commande lsof. Soit le numéro de port comme ici est 8090

lsof -i:8090

Cette commande renvoie une liste des processus ouverts sur ce port.

Quelque chose comme…

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
ssh 75782 eoin 5u IPv6 0x01c1c234 0t0 TCP localhost:8090 (LISTEN)

Pour libérer le port, tuez le processus en l'utilisant (l'ID du processus est 75782)…

kill -9 75782

Celui-ci a fonctionné pour moi. voici le lien du post original: lien

Si vous voulez tuer un processus exécuté sur le numéro de port 8080, vous devez d'abord trouver le numéro d'identification de processus (PID) du port 8080, puis le tuer. Exécutez la commande suivante pour rechercher le numéro de port 8080 PID:

sudo lsof -t -i:8080

Ici,

• sudo - commande pour demander le privilège administrateur (identifiant utilisateur et mot de passe).
• lsof - liste de fichiers (également utilisé pour lister les processus associés)
• -t - affiche uniquement l'ID de processus
• -i - affiche uniquement le processus lié aux connexions Internet
• : 8080 - afficher uniquement les processus dans ce numéro de port

Ainsi, vous pouvez maintenant facilement tuer votre PID en utilisant la commande suivante:

sudo kill -9 <PID>

Ici,

• kill - commande pour tuer le processus
• -9 - avec force

Vous pouvez utiliser une commande pour tuer un processus sur un port spécifique à l'aide de la commande suivante:

sudo kill -9 $(sudo lsof -t -i:8080)

Pour en savoir plus, vous pouvez voir le lien suivant Comment tuer un processus sur un port spécifique sous Linux

Le meilleur moyen de tuer tous les processus sur un port spécifique;

kill -9 $(sudo lsof -t -i:8080)

Cela s'imprime pour afficher les identifiants de processus de tout ce qui fonctionne <port_number>:

fuser -n tcp <port_number> 

Il imprime également certaines choses sur stderr, donc:

fuser -n tcp <port_number> 2> /dev/null

Nous pouvons alors fournir ces identifiants de processus à la killcommande:

sudo kill $(fuser -n tcp <port_number> 2> /dev/null)

Vous pouvez également mettre cela dans une fonction si vous le faites souvent:

function killport() {
    sudo kill $(fuser -n tcp $1 2> /dev/null)
}

Obtenez le PID de la tâche et tuez-le.

lsof -ti:8080 | xargs kill

Pour connaître le pid de service exécuté sur un port particulier:

netstat -tulnap | grep :*port_num*

vous obtiendrez la description de ce processus. Utilisez maintenant kill ou kill -9 pid. Facilement tué.

par exemple

netstat -ap | grep :8080

tcp6       0      0 :::8080       :::*    LISTEN      1880/java 

Maintenant:

kill -9 1880

N'oubliez pas d'exécuter toutes les commandes en tant que root

Bon mot

kill -9 $(lsof -t -i tcp:8080)

explication ici: utilisez une combinaison de lsof and kill

root@localhost:~# lsof -i tcp:8080
COMMAND   PID USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
java    23672 sine  238u  IPv6 3028222      0t0  TCP localhost:http-alt (LISTEN)

sélectionner pid et utiliser kill

kill 23672

essayez comme ça,

 sudo fuser -n tcp -k 8080

Choisissez le numéro de port et appliquez la commande grep dans netstat comme indiqué ci-dessous

netstat -ap | grep :7070

Sortie console

tcp 0 0 ::: 7070 ::: * ÉCOUTER 3332 / java

Tuez le service en fonction du PID (Process Identification Number)

kill -9 3332

1. lsof -i tcp:8000 Cette commande répertorie les informations sur le processus en cours d'exécution sur le port 8000

2. kill -9 [PID] Cette commande tue le processus

Linux : vous pouvez d'abord trouver le PID de cette commande si vous connaissez le port:

netstat -tulpn 

exemple:-

 Local Address  Foreign Address  State    PID/Program name

  :::3000       :::*             LISTEN    15986/node 

Vous prenez ensuite le processus de mise à mort. exécutez la commande suivante:

tuer -9 PID

Exemple: -

tuer -9 15986

Linux : vous pouvez utiliser cette commande si vous connaissez le port:

netstat -plten | grep LISTEN | grep 8080

AIX :

netstat -Aan | grep LISTEN | grep 8080

Vous prenez ensuite la première colonne (exemple: f100050000b05bb8) et exécutez la commande suivante:

rmsock f100050000b05bb8 tcpcb

tuer le processus.

Vous pouvez connaître la liste de tous les ports fonctionnant dans le système ainsi que ses détails (pid, adresse, etc.):

netstat -tulpn

Vous pouvez connaître les détails d'un numéro de port particulier en fournissant le numéro de port dans la commande suivante:

sudo netstat -lutnp | grep -w '{port_number}'

ex: sudo netstat -lutnp | grep -w '8080' Les détails seront fournis comme ceci:

Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name

si vous voulez tuer un processus en utilisant pid alors :kill -9 {PID}

si vous voulez tuer un processus en utilisant le numéro de port :fuser -n tcp {port_number}

utiliser sudosi vous n'êtes pas en mesure d'accéder à tout.

kill -9 `fuser 8080/tcp|xargs -n 1`, cette commande tue également le processus qui écoute sur le port 8080 avec une connexion TCP

sudo apt-get install psmisc (or sudo yum install psmisc)
sudo fuser 80/tcp

Résultat: 80 / tcp: 1858 1867 1868 1869 1871

Tuer les processus un par un

tuer -9 1858

Je travaille sur un système Yocto Linux qui dispose d'un ensemble limité d'outils Linux disponibles. Je voulais tuer le processus qui utilisait un port particulier (1883).

Tout d'abord, pour voir quels ports nous écoutons, j'ai utilisé la commande suivante:

root@root:~# netstat -lt
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       
tcp        0      0 0.0.0.0:hostmon         0.0.0.0:*               LISTEN      
tcp        0      0 localhost.localdomain:domain 0.0.0.0:*               LISTEN      
tcp        0      0 0.0.0.0:9080            0.0.0.0:*               LISTEN      
tcp        0      0 0.0.0.0:1883            0.0.0.0:*               LISTEN      
tcp        0      0 :::hostmon              :::*                    LISTEN      
tcp        0      0 localhost:domain        :::*                    LISTEN      
tcp        0      0 :::ssh                  :::*                    LISTEN      
tcp        0      0 :::1883                 :::*                    LISTEN      

Ensuite, j'ai trouvé le nom du processus utilisant le port 1883 de la manière suivante:

root@root:~# fuser 1883/tcp
290 
root@root:~# ps | grep 290
  290 mosquitt 25508 S    /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
12141 root      8444 S    grep 290

Comme nous pouvons le voir ci-dessus, c'est le programme /usr/sbin/mosquitto qui utilise le port 1883.

Enfin, j'ai tué le processus:

root@root:~# systemctl stop mosquitto

J'ai utilisé systemctlparce que dans ce cas c'était un service systemd.

Dans mon cas, cent os a un problème dans la réponse suggérée. J'ai donc utilisé la solution suivante:

  ss -tanp | grep 65432 | head -1 | grep -Po "(?<=pid=).*(?=,)" | xargs kill

pour s'appuyer sur ce que @ veer7 a dit:

si vous voulez savoir ce qu'il y avait sur le port, faites-le avant de le tuer.

$ sudo netstat -plten |grep java
tcp6       0      0 127.0.0.1:8005          :::*                    LISTEN      1000       906726      25296/java      
tcp6       0      0 :::8009                 :::*                    LISTEN      1000       907503      25296/java      
tcp6       0      0 :::8080                 :::*                    LISTEN      1000       907499      25296/java      
$ ps 25296
  PID TTY      STAT   TIME COMMAND
25296 ?        Sl     0:16 /usr/lib/jvm/java-8-openjdk-amd64/bin/java -Dcatalina.base=/hom

Utilisez 'ps' et le numéro du processus rapporté par netstat

Autre façon avec Git Bash:

stopProcessByPortNumber() {
port=":${1}"
portStrLine="$(netstat -ano | findstr LISTENING | findstr $port)"
processId="$(grep -oP '(\d+)(?!.*\d)' <<< $portStrLine)"
echo $processId
taskkill -PID $processId -F
}

1. vérifiez d'abord le processus netstat -lt
2. vérifier l'identifiant du processus fuser <port number>/tcp
3. tuer le processus en cours d'exécution sur le port kill <process id>

Sous Windows, ce sera le cas netstat -ano | grep "8080"et nous recevrons le message suivantTCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 10076

NOUS pouvons tuer le PID en utilisant taskkill /F /PID 10076