Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

03-Procesos Linux 3/5 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 1 de enero de 2022 por Fernando Jesús H.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a seguir con cómo podemos finalizar un proceso que ha empezado a ejecutarse, pero antes me queda comentaros un comando que nos puede resultar útil, sobre todo cuando estemos viendo script, y es el comando que se llama pgrep. 00:00:00
Este comando pgrep lo que hace es utilizar una expresión regular y lo que hace es mostrar todos los ids de todos los procesos que se están ejecutando actualmente 00:00:16
Que coincidan con dicha expresión regular que nosotros le pongamos en el pgrep 00:00:27
Entonces lo vemos mejor con un ejemplo 00:00:35
Imaginaros que nosotros, yo que sé, el XSize este ya que estamos utilizando 00:00:37
Lo voy a ejecutar varias veces en segundo plano para que no moleste 00:00:44
Y imaginaros que yo puedo decirle que quiero que me diga el PREP y yo le puedo decir aquí XSize 00:00:49
¿Qué es lo que me dice? Pues fijaros que lo que nos devuelve son los identificadores de todos los procesos que coinciden con XSize 00:01:00
¿Sí? Cuidado con poner, por ejemplo, xis porque te dice que no hay ninguno, a no ser que nosotros dentro de las opciones del pgrep le digamos que no quiero distinguir entre mayúsculas y minúsculas. 00:01:07
Imaginaros que estamos en lo del grep, ¿vale? Me junta aquí el ps con el grep, juntan los dos comandos en uno, pero esto lo que hace es devolver los ids, ¿sí? 00:01:21
Si en lugar de decirle que me devuelva uno en cada línea, yo le digo el "-d", y le digo, por ejemplo, que me lo separe con una coma, pues me devuelve separados con una coma. 00:01:30
Entonces, este comando nos resulta muy útil, sobre todo cuando estemos en script. 00:01:41
Otra de las opciones del comando pgrep es la opción, por ejemplo, "-n". 00:01:47
¿Qué es lo que hace el "-n"? Me devuelve el id del último comando que yo he ejecutado. 00:01:52
Entonces, hay veces que ejecutáis un comando, queréis obtener su ID, pues con poner el pgrep-n obtenéis el ID correspondiente al comando. 00:01:57
Otras opciones que podemos utilizar del comando pgrep. 00:02:08
Nosotros le podemos decir, por ejemplo, que quiero que me muestre del usuario root 00:02:11
Solo del usuario root 00:02:25
Y quiero que me muestre, por ejemplo, los que son ssh 00:02:30
Y me muestra el identificador del servidor ssh que se está ejecutando, que son el 16500 00:02:33
¿Sí? Entonces, repito, yo aquí le puedo decir por usuario, me está buscando del usuario root aquellos que son el SSH. Si yo le digo, por ejemplo, del alumno, pues obviamente me dice que el alumno no está ejecutando ningún proceso SSH. 00:02:40
vale, que otras opciones 00:02:55
nosotros vamos a poder utilizar dentro del pgrep 00:02:59
que nos pueden ayudar 00:03:02
antes le hemos dicho, voy a bajar aquí porque como tenemos los ojitos 00:03:03
le voy a decir que quiero que me busque del pgrep 00:03:07
y le hemos dicho el xsize 00:03:11
si yo le digo que en lugar de que eso 00:03:13
quiero saber cuánto se me están ejecutando, le digo 00:03:17
guion c, esto para que? porque imaginaros 00:03:20
que tenéis, yo que sé, instancias 00:03:23
del Apache y tenéis que vigilar 00:03:25
que no haya más instancias de las que vosotros 00:03:27
debéis, entonces vosotros dentro de un script 00:03:29
le podéis decir que si supera el número 00:03:31
de tres, pues entonces 00:03:33
monitorizáis y matáis 00:03:34
aquellos que sobran o a saber 00:03:37
¿vale? entonces hay veces que os puede 00:03:39
interesar cuánto están ejecutando 00:03:41
pero 00:03:43
quiero que veáis también que 00:03:43
yo por ejemplo voy a 00:03:47
ejecutar el gedit 00:03:49
simplemente para que lo veáis 00:03:51
me voy a ejecutar en segundo plano 00:03:52
¿sí? entonces se me ha abierto 00:03:58
aquí el gedit 00:04:00
entonces imaginaros que yo quiero 00:04:01
buscar, porque el pgrep 00:04:04
yo puedo poner una expresión regular 00:04:06
entonces, si yo quiero poner 00:04:08
una expresión regular 00:04:10
si yo le digo 00:04:11
el pgrep 00:04:14
y por ejemplo 00:04:15
pues yo que sé 00:04:18
le digo 00:04:20
que sea, que sea, que sea 00:04:26
Bueno, si yo le digo ahora aquí un n simplemente para que lo veáis, pues me muestra el último que yo he ejecutado. 00:04:32
Pero si yo le digo que me muestre todo lo que empieza por una x y asterisco, pues fijaros que me muestran todos los ids de todos los procesos que coinciden con el patrón de que empiezan por e y una x. 00:04:37
si yo le digo x size tenemos ese si yo le digo 00:04:51
g edit tengo ese pero yo le puedo decir 00:04:56
oye quiero que me muestres por x o por e 00:05:01
no por x o por g 00:05:04
seguido de una e o una g 00:05:07
y seguido de una 00:05:13
y o una e y después 00:05:17
cualquier cosa. Entonces fijaros que aquí me tiene que devolver estos tres, el 2, 2, 4, 1, 5, 4, 9, 4, 6 y el 2, 2, 8, es decir, estos cuatro de aquí coinciden que empiezan por x, coge, sigue una e, una g y le sigue una y, una e, es decir, yo aquí puedo poner expresiones regulares, ¿vale? Las que ponía con el grepo, aquí también las puedo poner, ¿de acuerdo? 00:05:20
Entonces, hemos visto que podemos utilizar el guión i para que no me distinga entre mayúsculas y minúsculas, le hemos dicho que puedo decirle que me diga cuántos hay, le hemos dicho que le puedo decir que el delimitador, por ejemplo, es el espacio en blanco, y me pone el espacio en blanco, le puedo decir que nos muestre el id del proceso, ¿vale? 00:05:47
si yo le digo guión L me muestra el nombre del proceso 00:06:11
¿qué más opciones le podemos decir? 00:06:17
le puedo decir que solamente me muestres aquellos que son de un terminal 00:06:29
por ejemplo si yo pongo aquí el PTS1 00:06:34
yo soy el PTS1 00:06:37
si yo le digo que me muestre todos los que son del terminal 00:06:40
y le pongo guion t y le pongo el pts 1 pues solamente me muestran los que se están ejecutando 00:06:45
en ese terminal correspondiente entonces aquí tenéis una opción a tener en cuenta a la hora 00:06:53
de conseguir identificadores de proceso pero que junta el comando ps con el comando cre para obtener 00:07:00
repito identificadores si hemos visto que le puedo decir el guión para obtener el usuario 00:07:07
correspondiente le puede ser guión g para obtener el grupo correspondiente 00:07:13
de acuerdo si queréis lo que esto ya simplemente ya son si queréis decirle 00:07:19
por ejemplo los que no sean este pues esto es como el v decir te van a 00:07:25
devolver los identificadores que no coinciden con ese patrón si vale pues 00:07:32
viendo esto vamos a ver cómo podemos finalizar procesos entonces por ejemplo 00:07:38
vamos a coger aquí y nosotros que sepáis que cuando se va a finalizar un proceso lo que se 00:07:43
hace es enviar una señal a ese programa indicando dependiendo del tipo de señal indicando que lo que 00:07:50
es lo que queremos que haga entonces las señales tienen un nombre o un número asignado los números 00:07:58
de señal van a variar dependiendo de la plataforma de linux que nosotros tengamos vale pero los 00:08:06
nombres y los significados suelen estar estandarizados vale entonces vamos a ver 00:08:11
qué tipo de comandos o qué tipo de señales nosotros vamos a poder enviar a 00:08:16
los diferentes procesos para decir que queremos terminarlos 00:08:22
entonces este tipo de señales lo voy a mostrar directamente en lugar de poner 00:08:27
las transparencias lo vamos a ver aquí si yo pongo kill guión l quiero que 00:08:32
veáis que estas son todas las señales que tengo puesto en cada una de ellas es 00:08:37
decir tengo el nombre de la señal y el número asignado a cada una de ellas sí 00:08:42
entonces aquí solamente voy a comentar un par de ellas que son las que se 00:08:47
suelen utilizar prácticamente siempre y estas señales son o esta de aquí 00:08:51
o esta de aquí 00:09:01
o a ver si la veo que no la encuentro 00:09:05
o esta de aquí 00:09:08
y las otras dos 00:09:12
el SYNC CONTINUE 00:09:14
y el SYNC STOP 00:09:18
vale entonces vamos a ver esas que son las que más os pueden vosotros ayudar 00:09:20
pero fijaros que tenemos hasta 64 tipos de señales diferentes que se le pueden 00:09:25
mirar 00:09:29
a los procesos 00:09:30
Vamos a ver qué quiere decir cada una de ellas. Aquí sí que os voy a mostrar la transparencia. A ver si se ve. Sí, ok. 00:09:32
Entonces quiero que veáis que o tenemos el número de señal 00:09:47
Porque yo le puedo indicar la señal que le quiero enviar 00:09:52
O se lo envío con el número 00:09:55
O se lo envío en este caso con el nombre 00:09:56
Aquí tenéis el nombre abreviado 00:10:00
Pero si no queréis el nombre abreviado 00:10:02
Lo que hacen es poner, por ejemplo, el SIG y el AP 00:10:05
SIG, INT, SIG, QUIT, SIG, KILL, SIG, TEN 00:10:08
¿De acuerdo? 00:10:12
¿Qué es lo que hace cada uno de estos? 00:10:13
Pues fijaros que el que nos van a interesar nosotros, voy a empezar por este, que es el valor por defecto. Es decir, cuando nosotros le decimos a un proceso que queremos terminarlo, por defecto se envía esta señal que se llama SIGTEN y tienen asignado el numerito 15. 00:10:15
Y me dice, provoca la finalización del programa. Me dice, oye, a diferencia del syskill, que este es el 9, que es este de aquí, me dice, puede bloquearse, ignorarse y manipularse. 00:10:30
dice es la manera correcta de solicitar la finalización de un programa me explico cuando 00:10:46
yo le envío esta señal a un programa imaginaros que tiene un fichero abierto pues yo a ese programa 00:10:52
le estoy diciendo oye cierra te entonces va a terminar de escribir las cosas del buffer que 00:10:58
tenga en el disco duro y se va a terminar correctamente si el envío esta señal en cambio 00:11:02
si yo le envío esta señal de aquí es como si yo hiciese un botonazo en el ordenador por decirlo 00:11:07
alguna manera es decir es mata esa aplicación cierra la y puede que los datos que hay o con 00:11:12
los que yo esté trabajando se queden de forma incorrecta entonces el menos 9 es la última 00:11:20
opción que tendría es que intentar utilizar pero sí que es cierto que la gente se acostumbra mucho 00:11:27
a utilizar siempre el six kill porque como sabe que eso lo mata sí o sí pero qué os puede pasar 00:11:34
Pues esto es como cuando sacáis un pendrive y no lo extraéis de forma segura que se pueden crear los actos corruptos, pues aquí igual, es decir, el 15 haciendo una analogía con el USB, extraéis el USB de forma correcta y el guión 9 saquéis el USB al capón con todos los problemas que eso puede acarrear, ¿de acuerdo? 00:11:41
¿Sí? Y luego nosotros tenemos aquí el 18 y el 19. ¿Os acordáis cuando estuvimos viendo el control de los trabajos que teníamos, lo de poner en segundo plano, en pausado y cuando queríamos reanudar? Pues aquí tenemos las señales. Cuando yo le quería decir que el control Z, que lo quería suspender, ¿vale? O cuando yo lo quería reanudar, que poníamos en este caso el BG o el FG. 00:11:58
Entonces son las señales que nosotros le podemos enviar. Pero tenéis hasta 64. Aquí tenéis algunas más conocidas, pero con que sepamos esta que tenemos aquí, repito que tenemos la 18, la 19, la 15 y la 9. 00:12:24
¿De acuerdo? Vale, pues vamos a ver cómo podemos nosotros matar un proceso. 00:12:41
Ya hemos visto que nosotros podemos ver todas las señales con un comando que se llama kill. 00:12:49
Pues ese comando es el que nosotros vamos a utilizar para matar, para terminar un proceso. 00:12:58
tenéis que saber que los usuarios pueden finalizar sus propios procesos, obvio, pero si alguien quiere matar o quiere terminar un proceso que no es suyo 00:13:05
ya necesito privilegios de administrador, pues vamos a ver cómo funciona el comando kill, yo al comando kill le puedo pasar o el numerito de la señal 00:13:18
o el número 15, o le puedo pasar el nombre de la señal, es decir, el system, que es el valor por defecto, el número 15, recordar, ¿de acuerdo? 00:13:28
¿Y qué es lo que le tengo que pasar al comando kill? El identificador de proceso que quiero matar. 00:13:37
Por ejemplo, si yo le digo aquí el pgrep y le digo xice, os recuerdo que si queréis ver en este caso cuáles son los p y d de los procesos, poníamos en este caso el guión l. 00:13:43
Y tenemos ahí que efectivamente tenemos los procesos 00:14:08
¿Qué pasa si yo quiero matar un proceso? 00:14:13
Pues yo puedo utilizar lo siguiente 00:14:17
Quiero que lo veáis, ¿vale? 00:14:18
Lo voy a poner así, lo voy a poner más chiquitito 00:14:20
Porque quiero que veáis los tres ojos 00:14:22
Yo por ejemplo voy a decirle 00:14:23
Oye, sin poner nada, ¿eh? 00:14:26
Le voy a poner kill y le voy a poner el primero 00:14:27
Y quiero que veáis 00:14:30
Qué es lo que pasa con el primer ojo 00:14:31
Que lo he matado 00:14:33
Que quiero matar, que yo le digo ya 00:14:34
oye, otra vez quiero ver y tengo dos 00:14:37
me dice que hay uno que ha sido terminado 00:14:39
¿vale? con el kill 00:14:41
como yo no he puesto el número de señal 00:14:42
por defecto me está mandando la señal 15 00:14:44
la que se llama 610 00:14:46
la que tenemos aquí arriba 00:14:48
que estoy seleccionando 00:14:49
con el ratón, esta de aquí 00:14:51
¿de acuerdo? 00:14:54
si yo no pongo nada 00:14:57
por defecto estoy mandando esa señal 00:14:58
¿sí? 00:15:00
vale, ¿qué pasa si yo ahora hago lo siguiente? 00:15:02
nosotros tenemos 00:15:05
que se está ejecutando estos tres 00:15:06
comandos. ¿Qué pasa si yo quiero 00:15:11
decirles, por ejemplo, le decimos 00:15:15
el pgrep y vamos a coger este segundo 00:15:19
y le vamos a decir que lo quiero 00:15:23
parar. Yo le puedo decir, oye, kill 00:15:25
y le digo, lo quiero parar y le voy a decir 00:15:30
Pues este de aquí 00:15:38
Parece que no me ha hecho nada 00:15:39
Si yo le digo ahora el jobs 00:15:42
Quiero que veáis que ha hecho aquí 00:15:45
¿Lo veis? 00:15:46
Me lo ha detenido 00:15:48
¿Veis donde estoy? 00:15:49
Ahí 00:15:54
Entonces veis que me lo ha detenido 00:15:55
¿Qué pasa si lo quiero volver a reanudar? 00:16:00
Pues en lugar de decirle el seek stop 00:16:02
Le voy a decir 00:16:06
Que quiero continuarlo 00:16:07
De forma que si yo le digo el jobs 00:16:11
Pues ahora de nuevo, yo ya lo tengo ejecutándose. 00:16:13
¿De acuerdo? 00:16:19
¿Entendemos esto? 00:16:22
Son las opciones que os podéis encontrar dentro del kill. 00:16:24
Ahora, yo también puedo mandarle la señal correspondiente. 00:16:29
Es decir, imaginaros que me voy a cargar el GEDIC que tengo aquí. 00:16:33
Lo voy a poner aquí, en este lado. 00:16:37
Imaginaros que a mí se me ocurra hacer esto 00:16:41
En lugar de poner el nombre 00:16:45
Porque repito, si yo no pongo nada 00:16:46
Es como si estuviese mandando 00:16:48
Esta señal, ¿vale? 00:16:49
Esto 00:16:53
Y esto es lo mismo 00:16:53
¿Sí? O le mando el número 00:16:58
O le mando el nombre de la señal 00:17:00
Pues imaginaros que yo hago esto 00:17:02
Le hago el 9 00:17:05
Y le voy a mandar, por ejemplo, el del gedit 00:17:05
Que, espérate que no me lo sé cuál es 00:17:09
Este de aquí 00:17:11
Pues imaginaros que yo le digo kill 00:17:17
Y le digo 9 00:17:20
Y le voy a decir este de aquí 00:17:21
¿Sí? 00:17:23
Es decir, me lo ha matado, ¿vale? 00:17:27
Me ha intentado incluso matar el VAS, pero bueno 00:17:30
Porque este de aquí de que le he dicho el heading 00:17:32
Me ha cogido el padre, pero me da igual 00:17:35
Pero me ha matado 00:17:37
¿Y qué pasa si yo tuviese ahí escrito 15.000 cosas? 00:17:39
Pues yo hubiese perdido absolutamente todo 00:17:43
En cambio, si yo hubiese hecho esto, se hubiese cerrado o se hubiese intentado cerrar correctamente. 00:17:45
¿Cuándo tenemos que utilizar el 9? 00:17:53
Tenemos que utilizar el 9 cuando esta opción normal no nos funciona. 00:17:56
Imaginaros que yo le digo aquí que quiero borrar o que quiero quitar el XSize y no me funciona. 00:18:00
Entonces intentar en este caso con la opción 9. 00:18:06
¿Sí? 00:18:10
Vale. 00:18:11
Ya hemos visto las tres opciones. 00:18:12
Repito que esto, cierro todos para que lo veáis y voy a borrar este de aquí. Ese me ha cerrado correctamente y esto es lo mismo. En lugar de este de aquí, vamos a decirle el que nos queda, que me parece que es este de aquí. 00:18:15
me da igual que sea o por número o por nombre de la señal 00:18:40
pues que sepáis que tenéis otro comando que es como el kill 00:18:47
pero es de lo siguiente, imaginaros que yo tengo lo mismo 00:18:52
tengo aquí 3 o 4, yo le digo que tengo aquí los correspondientes 00:18:57
Yo le tengo aquí el pgrep xsize. Pues hay un comando que es kill all, que lo que hace es, yo le paso el nombre del proceso, le paso la señal que le quiero pasar, por ejemplo, le puedo pasar el 15 o le puedo pasar la señal que quiera, exactamente igual que el kill. 00:19:09
Pero aquí lo que le voy a decir es, oye, XSize, y quiero que veáis que lo que hace, pues me ha terminado todo cuyo nombre coincide con ese de ahí. 00:19:36
Entonces, si tenéis abiertos cinco pestañitas o cinco Firefox o Chrome o lo que pueda ser y lo queréis matar todo a la vez, pues aquí tenéis el comando KeyLol. 00:19:44
si yo al comando 00:19:53
si yo al comando 00:19:58
kilol 00:20:04
le digo menos L 00:20:05
pues ahí son las señales que yo le puedo enviar 00:20:09
esas son las versiones abreviadas 00:20:12
sin el sig 00:20:14
sig quit 00:20:15
de acuerdo 00:20:17
y si yo tengo lo mismo 00:20:20
imaginaros que yo tengo 00:20:23
pues esto de aquí 00:20:25
con 3 me vale, yo tengo estos 3 00:20:27
Entonces, si yo le digo que quiero matar todos los que son XIs, ¿qué es lo que hace el W? El W lo que hace es, si hay un proceso padre que ha ejecutado esos tres XIs, pues espera a que todos terminen para terminarse correctamente, ¿vale? Simplemente por curiosidad para que lo tengáis en cuenta. 00:20:29
vale, lo que os he dicho 00:20:56
siempre que podáis por favor 00:21:00
utilizamos la señal por defecto 00:21:02
que es el SYNC TERM 00:21:04
que es la predeterminada 00:21:06
porque si utilizamos el SYNC KILL 00:21:07
SYNC KILL 00:21:10
que es el menos 9 00:21:12
no va a poder terminarse 00:21:13
correctamente 00:21:16
el programa, el proceso 00:21:18
y lo que son las opciones por ejemplo 00:21:20
de limpieza, de caché, etc 00:21:22
Todo eso no se va a realizar. Entonces hay muchas posibilidades de que perdamos información del proceso en cuestión. Entonces solamente utilizarlo cuando sea estrictamente necesario. 00:21:24
¿De acuerdo? Hemos visto la opción el KeyLol y ahora simplemente para que veáis, imaginaros que nosotros tenemos esto de aquí y tenemos el gedit o la 1.txt. 00:21:35
Vale, nosotros tenemos esto de aquí, ¿de acuerdo? Entonces nosotros tenemos aquí el PSJ para ver los procesos que tenemos nosotros de esto de aquí, ¿de acuerdo? Vale, ¿qué pasa si yo quiero matar todos con el kill all? 00:21:54
El kill all yo le puedo pasar una expresión regular 00:22:18
Si yo le digo kill all 00:22:23
Yo le puedo decir, oye, pues quiero que empiecen 00:22:29
Pues por ejemplo, para decirle que voy a utilizar una expresión regular 00:22:33
Voy a utilizar guión R 00:22:39
Y le voy a decir, por ejemplo, mira, va a empezar por 00:22:40
la x 00:22:47
o la g, igual que hemos hecho antes 00:22:51
le sigue la e 00:22:53
x size 00:22:55
y el g edit 00:23:04
le sigue una e y le sigue 00:23:05
una i 00:23:09
o una d 00:23:13
¿si? y luego 00:23:15
cualquier cosa 00:23:17
y le voy a decir 00:23:18
guion i, ¿por qué le digo guion i? 00:23:23
porque fijaros que el guion 00:23:26
es interactivo, me pregunta 00:23:28
vaya a ser que yo la cague y digo 00:23:30
oye, ¿quieren matar este proceso? por defecto 00:23:32
me pone que no, pero mira, este sí que 00:23:34
es el x6, este sí que lo mato, este 00:23:36
lo mato y el gedit también lo mato 00:23:38
¿vale? porque si no ponéis 00:23:40
la i, hay a veces que no habéis probado 00:23:42
la expresión regular, os va a dar 00:23:44
procesos que no queréis matar y os lo va a matar 00:23:45
entonces, el guión i, hay a veces 00:23:48
que está muy interesante y siempre que queráis 00:23:50
poner una expresión regular, ponéis 00:23:52
el guión r 00:23:54
y aquí igual que antes, si no queréis 00:23:55
distinguir entre mayúsculas y minúsculas pues en este caso vamos a ponerla y mayúscula sí porque 00:23:57
la y minúscula se utiliza para interactivo que queremos listar todas las señales ya hemos visto 00:24:03
que tenemos la opción l perdonarme la opción l si quiero buscar exactamente algo es decir que 00:24:09
se llame x hay exactamente así no que empiece ni que contenga sino si quiero que encuentre eso 00:24:21
pongo guión y me busca exactamente lo que quiera buscar de acuerdo y si quiero coger y quiero 00:24:28
decirle oye que pertenezca al usuario alumno pues ponemos el rayado y que sea oye mátame todos los 00:24:34
x 6 del alumno usuario obviamente como no tengo ninguno si yo tuviese aquí un par de ellos con 00:24:40
que tengo uno pues directamente terminado de acuerdo que más opciones nosotros podemos tener 00:24:48
¿Os acordáis que nosotros teníamos el pgrep para buscar los identificadores? 00:24:59
Pues nosotros tenemos el mismo comando que pgrep, pero para matar. 00:25:06
Es decir, tenemos el pkill. 00:25:10
Entonces, el pkill va a ser como el killall, pero yo tengo que indicar los id de los procesos. 00:25:12
Entonces, ¿qué le podemos decir en el pkill? 00:25:19
Pues imaginaros que yo tengo cosas como esta. 00:25:23
a ver me voy a conectar al usuario desde manera remota y me voy a conectar como 00:25:30
fernando y aquí con el fernando voy a ejecutar por ejemplo pues un slip yo le 00:25:45
digo oye slip y le digo 10 minutos 11 minutos 12 minutos y 13 minutos vale 00:25:58
entonces si yo aquí, lo que pasa es que me voy a meter como root para que yo lo pueda hacer 00:26:13
porque como es otro usuario necesito privilegio de administración 00:26:18
e imaginaros que yo quiero decirle que quiero que me muestre en el pgrep todo lo que son de sleep 00:26:22
y me muestra esos procesos, si yo le digo el guion l, pues me muestra eso de ahí, de acuerdo 00:26:31
Yo tengo esos procesos que si yo pongo psfax, yo voy a tener por aquí lf, que así me muestra los usuarios, yo voy a tener aquí al usuario Fernando con estos identificadores, ¿de acuerdo? 00:26:40
¿Cómo puedo obtener estos identificadores? Pues hemos visto antes que yo puedo utilizar el comando pgrep para obtener esos identificadores y le digo, oye, quiero el pgrep, quiero los identificadores de proceso del usuario Fernando correspondiente a sleep y me da esos de ahí. 00:27:00
Si quiero ver el nombre de los procesos, ya sabéis que tenemos que poner el guión L. 00:27:23
¿Qué pasa si yo quiero matar esos procesos directamente? 00:27:29
Yo puedo utilizar P, kill, y lo que le voy a decir el P, kill, es decir, 00:27:32
oye, quiero que me mates todos los procesos del usuario, Fernando, todos, ¿eh? 00:27:37
Así me va a matar todos los procesos. 00:27:44
¿Sí? Si yo ahora le digo que me muestre, no me está mostrando nada. 00:27:48
si yo me voy aquí, que ha pasado 00:27:52
que me dice 00:27:54
se me ha quedado bloqueado 00:27:56
me ha echado 00:28:00
si, entonces yo tendría que 00:28:01
abrir otra vez la sesión 00:28:04
y volverme a meter 00:28:06
tenemos el 10 00:28:14
el 11 y el 12 00:28:25
de acuerdo 00:28:27
entonces yo con el pkill 00:28:28
puedo jugar y hacer lo mismo 00:28:30
que hace con el kill, pero en este 00:28:33
caso yo le puedo pasar varios 00:28:35
procesos si a mí me da la gana separados por espacios si acaso lo hacéis de acuerdo 00:28:37
no sé si me faltaba algo del pequeño vale perfecto entonces que podemos ver también del 00:28:47
fijaros que estoy conectado estoy aquí y me dice que fernando está conectado del pts 0 lo veis 00:28:55
pues yo también le puedo decir cosas como esta oye quiero que me mates los que están en el 00:29:03
terminal y le cojo este y le digo oye quiero que todo lo que esté en ese 00:29:08
terminal melo machaques si si yo me voy a directamente me ha cerrado vale me ha 00:29:12
cerrado directamente la consola ahora tendría que abrir otra vez la consola 00:29:23
entonces tendría que abrir otra de la consola porque yo le he hecho que todo 00:29:27
lo que en ese terminal me lo cierre de acuerdo y tendría que abrir otra vez 00:29:33
aquí el fernando entonces opciones que podéis jugar con el comando pekín 00:29:37
este junto con el pekín se llevan de la mano vale se utiliza tanto uno con otro 00:29:48
para utilizarlos dentro de él de los scripts que sepáis que el comando 00:29:54
pekín yo no lo estoy pasando nada pero yo aquí le puedo pasar la señal y yo 00:30:00
Aquí le puedo pasar, oye, SIDKILL, o le puedo pasar SIDTEN, o le pongo el numerito, ¿vale? 00:30:04
Y le pongo aquí el guión 9 o el guión 15. 00:30:11
Le puedo pasar o el nombre de la señal o le puedo pasar el numerito correspondiente a la señal que yo le quiera pasar. 00:30:14
¿De acuerdo? 00:30:22
¿Sí? 00:30:25
Otra cosa que podemos hacer es la siguiente. 00:30:29
Abro un terminal. 00:30:32
Estoy abriendo el terminal como el usuario normal. 00:30:34
Este es el usuario normal e imaginaros que yo hago aquí pues otra vez el sleep y le pongo aquí 15 minutos, uy perdón, que si no no puedo seguir escribiendo y 16 y 17 minutos, ¿vale? 00:30:37
si yo estando como root por ejemplo le digo ps y le pongo aquí el fax por ejemplo si yo me voy 00:30:58
aquí al usuario veis que lo tengo aquí sí entonces mi pregunta es si yo cojo este de aquí fijaros que 00:31:08
El identificador del bus es 23036 y dentro del bus se está ejecutando 3 sleep, 15, 16 y 17. 00:31:27
¿Lo veis? 00:31:38
Yo puedo coger en este caso y decirle lo siguiente. 00:31:40
Quiero coger el 23036. 00:31:46
Lo voy a copiar. 00:31:55
Y yo le puedo decir pkill, le voy a decir la opción "-p", y le voy a decir el identificador. 00:31:59
Si yo le doy, y le vuelvo a decir que quiero que me muestre, o por ejemplo, le voy a pasar el ps3, y le voy a decir "-p", y le digo aquí alumno. 00:32:08
Lo que pasa es que aquí me va a mostrar un montonazo de cosas, y no quiero eso, pero bueno. 00:32:24
Que aquí esté. Ahora no me gusta. Quiero que veáis por aquí que yo sigo teniendo el 23036, pero lo que hay dentro de me lo ha quitado. Repito, yo he ejecutado el 23036, pero no me ha matado el 23026. 00:32:29
si yo ahora aquí le doy al intro 00:32:52
me ha matado los tres hijos 00:32:54
pero el terminal en sí no me lo ha matado 00:32:56
entonces yo tendría que utilizar 00:32:59
el comando kill para matar 00:33:01
en concreto el bus 00:33:03
porque con la opción guión p 00:33:04
lo que le estoy diciendo es que 00:33:07
todo lo que hay contenido dentro 00:33:09
del padre directamente 00:33:10
lo elimine 00:33:13
¿de acuerdo? 00:33:14
mal 00:33:18
y luego por último, y con esto ya 00:33:19
terminamos esta parte 00:33:22
tenemos el comando pido 00:33:23
que es lo que hace este comando 00:33:25
este comando busca el 00:33:29
identificador de un programa que se está 00:33:31
ejecutando 00:33:33
me explico 00:33:34
si nosotros tenemos aquí 00:33:36
el x 00:33:39
size 00:33:41
si yo pongo el pido 00:33:42
y le pongo aquí 00:33:45
del x size 00:33:47
me dice oye este es su 00:33:48
identificador 00:33:51
¿lo veis? 00:33:52
si yo tengo varios 00:33:55
y le digo el p2 00:34:01
pues me muestra a todos 00:34:05
si yo solamente quiero que me retorne 00:34:06
en este caso el último 00:34:13
le pongo el guión s 00:34:15
entonces si vosotros queréis la última instancia del Firefox 00:34:16
para coger el id y para matar solamente la última instancia 00:34:20
porque pensáis que es la que se me ha quedado bloqueada 00:34:24
o que me ha permitido esto, pues tirándome ya 00:34:26
entonces aquí ya podemos eliminar como nos dé la gana 00:34:28
el kill all y le decimos 00:34:32
xice 00:34:35
¿de acuerdo? 00:34:38
entonces simplemente a modo de resumen 00:34:42
para que veamos aquí las opciones que nosotros tenemos 00:34:45
os recuerdo 00:34:51
¿dónde lo tengo? aquí 00:34:53
para las opciones que hemos visto 00:34:59
hemos visto el comando, a ver si puedo escribir 00:35:06
a ver, sí 00:35:12
el pgrep 00:35:13
que me devuelve los identificadores de procesos 00:35:19
de la expresión regular que coincida con la expresión regular 00:35:23
y luego para matar los procesos 00:35:26
hemos visto varios comandos 00:35:28
uno de ellos, el más conocido obviamente 00:35:31
es el kill 00:35:34
que le digo aquí la señal 00:35:36
y el PID del proceso que quiero eliminar 00:35:41
también tenemos el KILL ALL 00:35:45
que yo le puedo poner aquí una expresión regular 00:35:47
y me va a matar todos, pasándole también la señal si quiero 00:35:52
¿de acuerdo? 00:35:56
tengo el PKILL 00:35:58
que este y este van relacionados 00:36:00
¿de acuerdo? 00:36:05
Y teníamos también, que no sé si me queda alguno, el último, que era el PIDOFF, que se me había olvidado, que me devuelve el identificador del programa que yo le indique que se esté ejecutando. 00:36:07
Entonces, estos tres de aquí son los que se utilizan para terminar un proceso o terminar o enviarle una señal. La señal correspondiente que hemos visto, la 9, la 15, el stop y el continue, que son las que a mí por ahora me interesa que sepáis. 00:36:33
¿De acuerdo? Entonces ya podemos ejecutar procesos, sabemos gestionarlos, sabemos ver su información y sabemos matarlos. ¿Qué nos queda ver? Pues nos queda ver cómo podemos gestionar la monitorización de dichos procesos. Pues eso es lo que vamos a ver en el siguiente vídeo. Venga, un saludo. 00:36:53
Idioma/s:
es
Autor/es:
Fernando Herrero Núñez
Subido por:
Fernando Jesús H.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
21
Fecha:
1 de enero de 2022 - 13:02
Visibilidad:
Público
Centro:
IES EL CAÑAVERAL
Duración:
37′ 15″
Relación de aspecto:
1.85:1
Resolución:
1920x1040 píxeles
Tamaño:
105.23 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid