WEBVTT

00:00:07.881 --> 00:00:09.753
Você tem percebido
que o seu sistema

00:00:09.753 --> 00:00:13.383
está se comportando
de uma maneira não comum.

00:00:13.383 --> 00:00:17.211
Uma série de processos está
consumindo recursos desnecessários

00:00:17.211 --> 00:00:19.624
e você precisa
tomar uma decisão.

00:00:20.624 --> 00:00:23.928
Um dos comandos mais utilizados
para o envio de sinais a processos

00:00:23.928 --> 00:00:25.791
é o comando "kill".

00:00:25.791 --> 00:00:27.935
Comando "kill",
do inglês "matar",

00:00:27.935 --> 00:00:30.732
não necessariamente
mata os processos.

00:00:30.732 --> 00:00:32.443
O correto é afirmar
que ele envia

00:00:32.443 --> 00:00:34.973
um determinado sinal
para o processo.

00:00:34.973 --> 00:00:38.106
Eu posso enviar um sinal
para o processo parar,

00:00:38.106 --> 00:00:42.717
para o processo reiniciar,
para o processo ser morto,

00:00:42.717 --> 00:00:45.781
para o processo
ser suspendido,

00:00:45.781 --> 00:00:49.178
enfim, eu posso enviar
vários tipos de sinais

00:00:49.178 --> 00:00:51.398
para um processo
utilizando o comando "kill".

00:00:52.571 --> 00:00:55.634
Vamos dar uma olhada em todas
as opções que conseguimos explorar,

00:00:55.634 --> 00:00:57.575
utilizando
o comando "kill".

00:00:57.575 --> 00:01:02.048
Primeiramente, eu vou executar
o comando "kill -l".

00:01:02.817 --> 00:01:05.698
Quando nós executamos
esse comando,

00:01:05.698 --> 00:01:09.772
ele me dá uma lista de possíveis
sinais que eu posso enviar.

00:01:09.772 --> 00:01:12.278
Detalhe importante:
o comando "kill" aceita

00:01:12.278 --> 00:01:16.315
com que eu passe o sinal
tanto de forma numérica

00:01:16.315 --> 00:01:20.397
quanto através do próprio
nome do sinal.

00:01:20.397 --> 00:01:21.645
Aqui, nós vamos abordar

00:01:21.645 --> 00:01:25.626
somente as principais opções
do comando "kill".

00:01:25.626 --> 00:01:28.515
Se você tiver interesse
em obter mais detalhes,

00:01:28.515 --> 00:01:32.362
é só você ler o manual
do "kill", o "man kill".

00:01:32.362 --> 00:01:35.062
Toda vez que eu quiser
enviar um sinal para o processo,

00:01:35.062 --> 00:01:39.270
eu tenho que saber
qual é o PID do processo.

00:01:39.270 --> 00:01:42.373
Então, eu vou executar
aqui um processo.

00:01:42.373 --> 00:01:47.044
Eu vou enviar esse processo
para o segundo plano, parando-o,

00:01:47.044 --> 00:01:51.383
e, depois, eu vou enviar um outro
sinal para o processo com o "kill".

00:01:51.383 --> 00:01:53.046
Eu vou executar
o seguinte comando:

00:01:53.046 --> 00:02:00.856
"grep menos ri, espaço, aspas
duplas, linux, aspas duplas, barra".

00:02:00.856 --> 00:02:03.695
Eu estou procurando todas
as ocorrências da palavra Linux

00:02:03.695 --> 00:02:08.066
em todos os arquivos a partir
da raiz, de forma recursiva.

00:02:08.066 --> 00:02:10.028
Se eu der enter,
automaticamente,

00:02:10.028 --> 00:02:12.911
ele vai mostrar uma série
de informações na tela.

00:02:12.911 --> 00:02:14.283
Então, eu vou usar

00:02:15.328 --> 00:02:16.976
esse comando

00:02:18.112 --> 00:02:21.828
para que ele mande
o que encontrar

00:02:21.828 --> 00:02:25.133
para dentro do diretório
"barra dev barra null".

00:02:27.362 --> 00:02:29.336
Perceba que o comando
está executando,

00:02:29.336 --> 00:02:32.192
porém ele está executando
em segundo plano.

00:02:32.192 --> 00:02:36.264
Se der o comando 
"ps aux | grep grep",

00:02:37.570 --> 00:02:41.034
ele trouxe para mim o comando,
que está aqui.

00:02:41.034 --> 00:02:44.053
Então, esse é o PID
do comando,

00:02:44.053 --> 00:02:46.570
que é o número
que identifica o processo.

00:02:46.570 --> 00:02:51.412
Se eu digitar o comando "jobs",
ele vai mostrar todos os processos

00:02:51.412 --> 00:02:52.986
que eu executei.

00:02:52.986 --> 00:02:57.384
Então, automaticamente,
tenho dois processos em execução.

00:02:57.384 --> 00:02:59.153
Dois greps rodando.

00:02:59.153 --> 00:03:00.403
Vamos imaginar
o seguinte:

00:03:00.403 --> 00:03:02.994
se você digitar
o comando "jobs -l",

00:03:02.994 --> 00:03:06.824
automaticamente, ele mostra
o PID do processo.

00:03:06.824 --> 00:03:09.115
Lembre-se: para poder
executar o comando "kill",

00:03:09.115 --> 00:03:11.696
eu tenho que saber
o PID do processo.

00:03:11.696 --> 00:03:14.575
Vamos imaginar que eu queira
enviar um sinal

00:03:14.575 --> 00:03:17.839
para esse comando
de PID 959.

00:03:17.839 --> 00:03:20.415
Eu vou usar
o comando "kill espaço".

00:03:20.415 --> 00:03:22.224
Qual o sinal que eu
quero enviar?

00:03:22.224 --> 00:03:25.914
Se nós dermos um "kill -l",
conseguimos ver todos os sinais.

00:03:25.914 --> 00:03:29.049
Vamos imaginar que eu
quero mandar um "SIGTSTP",

00:03:29.049 --> 00:03:32.287
que é o sinal
de parar o processo.

00:03:32.287 --> 00:03:37.493
Eu dou um "kill",
posso usar a opção -20

00:03:37.493 --> 00:03:40.830
e posso usar
o PID 959.

00:03:40.830 --> 00:03:41.809
Pronto.

00:03:41.809 --> 00:03:44.317
Se nós digitarmos agora
o comando de "jobs -l",

00:03:44.317 --> 00:03:47.422
perceba que o processo
está parado.

00:03:47.422 --> 00:03:50.204
Esse processo não foi morto,
ele só foi parado

00:03:50.204 --> 00:03:52.734
Automaticamente,
eu consigo mandar um sinal

00:03:52.734 --> 00:03:55.005
para poder continuar
esse processo?

00:03:55.005 --> 00:03:55.751
Sim.

00:03:56.861 --> 00:04:00.858
"kill" menos o sinal
que eu vou utilizar,

00:04:00.858 --> 00:04:04.731
que é SIGCONT,
que é o 18.

00:04:04.731 --> 00:04:11.149
Eu posso tanto colocar o -18,
como eu posso colocar -SIGCONT,

00:04:11.149 --> 00:04:14.231
e colocar o número
do PID, 959.

00:04:14.231 --> 00:04:19.791
Pronto, se eu der o "jobs -l",
o processo voltou a ser executado.

00:04:20.735 --> 00:04:21.922
O que nós fizemos?

00:04:21.922 --> 00:04:26.444
Pegamos um processo, enviamos
um sinal com "kill" para ele parar.

00:04:26.444 --> 00:04:27.972
Esse processo parou.

00:04:27.972 --> 00:04:29.363
Imagine que fosse
um processo

00:04:29.363 --> 00:04:32.060
que estava consumindo
muito recurso na sua máquina.

00:04:32.060 --> 00:04:34.712
E, depois,
nós demos um sinal

00:04:34.712 --> 00:04:37.896
para ele continuar a execução
normalmente.

00:04:37.896 --> 00:04:40.399
Um outro sinal que podemos
mandar para o processo

00:04:40.399 --> 00:04:43.705
é o sinal para ele parar.

00:04:43.705 --> 00:04:45.914
O sinal padrão
de parada de processo

00:04:45.914 --> 00:04:49.945
é o sinal 15
ou SIGTERM.

00:04:49.945 --> 00:04:54.039
Esse sinal permite com que eu
pare o processo de forma tranquila.

00:04:54.039 --> 00:04:55.720
Sabe quando você dá,
por exemplo,

NOTE Paragraph

00:04:55.720 --> 00:04:59.952
o comando "systemctl stop"
e o nome do serviço?

00:04:59.952 --> 00:05:02.827
Ou você quer que um processo
pare de forma tranquila,

00:05:02.827 --> 00:05:05.400
sem ser parado
abruptamente?

00:05:05.400 --> 00:05:10.790
A opção padrão de parada
de processo é essa: -15 ou SIGTERM.

00:05:10.790 --> 00:05:13.670
Eu vou executar agora na tela
e vamos ver o que acontece.

00:05:13.670 --> 00:05:18.264
"kill -15 959",
que é o PID.

00:05:18.264 --> 00:05:19.783
Pronto.

00:05:19.783 --> 00:05:25.492
Se der um "jobs -l", estará dizendo
que o processo foi terminado.

00:05:25.492 --> 00:05:28.892
Processos terminados
não podem ser continuados,

NOTE Paragraph

00:05:28.892 --> 00:05:31.498
ou seja, ele acabou
de ser finalizado.

00:05:31.498 --> 00:05:33.898
Se nós dermos
novamente um "jobs -l",

00:05:33.898 --> 00:05:37.505
ele não mais aparece na listagem
dos processos em execução.

00:05:37.505 --> 00:05:40.407
Existe uma outra opção
do comando "kill",

00:05:40.407 --> 00:05:42.343
que é o que as pessoas
associam

00:05:42.343 --> 00:05:45.216
ao fato dele ser usado
para matar processos,

00:05:45.216 --> 00:05:46.846
que é a opção -9

00:05:46.846 --> 00:05:50.461
Ela manda um sinal
chamado SIGKILL,

00:05:50.461 --> 00:05:56.337
ou seja, ela manda o processo
ser morto de forma abrupta.

00:05:56.337 --> 00:06:00.408
Se você tiver algum arquivo aberto,
o "kill" não vai se importar.

00:06:00.408 --> 00:06:03.428
Se alguém estiver usando esse
arquivo, ele não vai se importar.

00:06:03.428 --> 00:06:07.449
Ele simplesmente vai parar
abruptamente o processo.

00:06:07.449 --> 00:06:11.353
Apesar desta informação ser enviada
diretamente para o processo,

00:06:11.353 --> 00:06:14.210
isso pode ocasionar
alguns problemas graves

00:06:14.210 --> 00:06:16.708
de corrompimento de dados
no seu sistema,

00:06:16.708 --> 00:06:18.681
como, por exemplo,
se você mandar

00:06:18.681 --> 00:06:21.629
um sinal com -9
para um banco de dados.

00:06:21.629 --> 00:06:23.759
Eu vou executá-lo
agora, aqui no terminal,

00:06:23.759 --> 00:06:26.102
para vocês entenderem
o poder que ele tem.

00:06:26.102 --> 00:06:28.414
Vamos executar
o comando "jobs -l".

00:06:28.414 --> 00:06:31.616
Eu ainda tenho um outro
processo do grep executando

00:06:31.616 --> 00:06:34.143
com o PID 965.

00:06:34.143 --> 00:06:38.622
Vou dar um "kill -9 965".

00:06:39.369 --> 00:06:41.598
E vou dar um "jobs -l".

00:06:41.598 --> 00:06:45.025
Perceba que, agora, o processo
não foi parado, ele foi morto.

00:06:45.025 --> 00:06:48.292
Então, ele mandou um sinal
para matar o processo.

00:06:48.292 --> 00:06:51.662
É possível matar vários processos
ao mesmo tempo?

00:06:51.662 --> 00:06:52.492
Sim.

00:06:52.492 --> 00:06:56.116
Nós vamos ver aqui uma lista
de processos e vamos matá-los,

00:06:56.116 --> 00:06:57.825
todos com o comando "kill".

00:06:57.825 --> 00:07:02.467
Eu vou executar novamente
o "grep -ri,

00:07:04.759 --> 00:07:07.966
a palavra linux na raiz,

00:07:09.427 --> 00:07:11.990
dois e,

00:07:11.990 --> 00:07:18.028
maior que um, maior
que barra dev, barra null",

00:07:18.028 --> 00:07:19.710
mandando
para segundo plano.

00:07:21.323 --> 00:07:24.122
Pronto, vou rodar
algumas outras vezes.

00:07:24.122 --> 00:07:27.141
Vou executar 10 vezes
esse comando.

00:07:28.774 --> 00:07:34.974
Se nós dermos
um "jobs -l", está lá.

00:07:34.974 --> 00:07:38.280
Todos os PIDs dos processos
que estão rodando

00:07:38.280 --> 00:07:40.856
Para você finalizar todos
os processos ao mesmo tempo,

00:07:40.856 --> 00:07:42.859
a gente vai executar
o seguinte comando:

00:07:42.859 --> 00:07:47.899
eu vou capturar todos
os PIDs e vou executar,

00:07:47.899 --> 00:07:53.213
"kill" e aí, podemos passar
tanto -9 quanto -15.

00:07:53.213 --> 00:07:56.208
Lembrando que -9 vai matar
o processo abruptamente

00:07:56.208 --> 00:08:01.016
e o -15 vai somente parar
o processo de forma tranquila.

00:08:02.185 --> 00:08:05.765
Vou usar o sinal -9,
que é o SIGKILL,

00:08:06.633 --> 00:08:11.879
e posso passar todos os PIDs,
separados por espaço.

00:08:22.576 --> 00:08:24.161
Perceba que realmente
dá trabalho.

00:08:24.161 --> 00:08:26.095
Se tivesse 100
processos rodando,

00:08:26.095 --> 00:08:29.455
eu teria que passar
os 100 números dos PIDs.

00:08:31.271 --> 00:08:35.726
Se eu der um "jobs -l", só ficou
executando o processo 1037,

00:08:35.726 --> 00:08:38.371
que, provavelmente,
eu o pulei aqui da lista.

00:08:39.671 --> 00:08:43.618
Vamos aproveitar, então,
e treinar o -15.

00:08:48.213 --> 00:08:49.161
Pronto.

00:08:49.161 --> 00:08:50.345
Esse é o comando "kill",

00:08:50.345 --> 00:08:53.265
comando usado para podermos
enviar um sinal para o processo.

00:08:53.265 --> 00:08:56.162
Você pode mandar um sinal
para ele parar, continuar,

00:08:56.162 --> 00:08:58.447
para ele suspender,
para ele reiniciar.

00:08:58.447 --> 00:09:03.377
Tudo depende do quanto você
precisa que o sinal seja enviado

00:09:03.377 --> 00:09:05.952
e como você quer
que esse comando se comporte.

00:09:05.952 --> 00:09:08.463
O comando "kill" permite
matar processos

00:09:08.463 --> 00:09:11.628
utilizando o PID,
o "Process Identification".

00:09:11.628 --> 00:09:14.714
Existem dois comandos
que facilitam muito a nossa vida

00:09:14.714 --> 00:09:18.798
quando o objetivo é matar
vários processos ao mesmo tempo.

00:09:18.798 --> 00:09:21.579
Esses comandos
são "PKILL" e "KILLALL".

NOTE Paragraph

00:09:21.579 --> 00:09:26.156
O PKILL permite matar processos
utilizando o nome do processo,

00:09:26.156 --> 00:09:27.594
assim como KILLALL.

00:09:27.594 --> 00:09:31.328
Então, todos os sinais que enviei
para os processos usando kill,

00:09:31.328 --> 00:09:34.550
eu posso fazer também
com os comandos PKILL e KILLALL,

00:09:34.550 --> 00:09:36.645
porém, ao invés
de eu passar o PID,

00:09:37.509 --> 00:09:40.689
eu passo o nome
do processo.

00:09:42.003 --> 00:09:43.039
Vamos executar agora.

00:09:43.827 --> 00:09:47.727
Eu vou gerar uma lista de processos
novamente com o comando grep.

00:09:51.369 --> 00:09:54.519
Cinco processos foram gerados
com esse comando grep:

00:09:54.519 --> 00:09:58.208
"grep menos ri, linux, barra 2,
e comercial, maior que 1,

00:09:58.208 --> 00:10:00.892
maior que barra dev,
barra null, e comercial".

00:10:00.892 --> 00:10:05.040
Se nós dermos um "jobs -l",
estão lá todos os processos.

00:10:05.040 --> 00:10:07.896
Todos os processos
tem o nome de "grep".

00:10:07.896 --> 00:10:10.932
Nesse momento, eu vou
executar o comando "pkill"

00:10:10.932 --> 00:10:13.054
e posso usar todas
as opções de sinais

00:10:13.054 --> 00:10:16.575
que vimos no "kill",
-9, -15.

00:10:16.575 --> 00:10:21.714
Eu vou usar a opção -15 para parar
esses processos de forma natural.

00:10:21.714 --> 00:10:23.748
E, ao invés de eu
passar PID por PID,

00:10:23.748 --> 00:10:26.410
como eu faria no "kill"
eu passo simplesmente o nome

00:10:26.410 --> 00:10:32.579
do comando que foi executado,
no caso aqui, o próprio "grep".

00:10:33.857 --> 00:10:34.948
Quando eu dou
um enter,

00:10:34.948 --> 00:10:38.865
ele termina todos os processos
com o nome "grep".

00:10:38.865 --> 00:10:41.489
Isso permite com que eu
tenha muito mais velocidade

00:10:41.489 --> 00:10:45.081
na execução do comando
quando quiser finalizar um processo

00:10:45.081 --> 00:10:48.408
ou vários processos
utilizando o nome.

00:10:48.408 --> 00:10:49.689
O comando
KILLALL funciona

00:10:49.689 --> 00:10:52.202
de maneira parecida
com o comando PKILL.

00:10:52.202 --> 00:10:54.610
Nós conseguimos
matar diversos processos

00:10:54.610 --> 00:10:57.271
utilizando o nome
dos processos.

00:10:57.271 --> 00:10:59.226
Eu vou executar, agora,
novamente o "grep"

00:10:59.226 --> 00:11:02.281
para que possamos visualizar isso
acontecendo dentro do sistema.

00:11:03.194 --> 00:11:05.668
Eu vou executar agora
5 vezes o comando "grep"

00:11:05.668 --> 00:11:07.007
para que gerem
os processos

00:11:07.007 --> 00:11:09.265
e a gente possa utilizar
o KILLALL para matá-lo.

00:11:10.325 --> 00:11:13.397
1, 2, 3, 4, 5.

00:11:14.379 --> 00:11:18.139
Se nós executarmos o comando
"jobs -l", está lá,

00:11:18.139 --> 00:11:19.518
5 processos
de execução.

00:11:19.518 --> 00:11:21.843
O nome do processo é "grep".

00:11:21.843 --> 00:11:25.747
Eu vou usar o "killall"
para poder matar esses processos.

00:11:25.747 --> 00:11:28.817
Vou utilizar os mesmos sinais
que eu uso no "kill" e no "pkill".

00:11:28.817 --> 00:11:33.046
Vou usar, por exemplo, o -9
para matar o processo forçando.

00:11:33.046 --> 00:11:34.399
E o comando
que quero matar

00:11:34.399 --> 00:11:36.919
são todos os comandos
que contêm o nome "grep".

00:11:36.919 --> 00:11:38.930
Recebi uma mensagem
que o comando "killall"

00:11:38.930 --> 00:11:40.970
não foi encontrado.

00:11:40.970 --> 00:11:46.804
Vamos instalá-lo através do comando
"apt install psmisc".

00:11:46.804 --> 00:11:48.426
Vou utilizar
a opção menos y

00:11:48.426 --> 00:11:50.844
para ele dizer sim
para todos os questionamentos.

00:11:55.405 --> 00:11:57.180
Pronto, uma vez
instalado o "psmisc",

00:11:57.180 --> 00:11:59.166
ele trouxe para mim
o "killall".

00:11:59.166 --> 00:12:02.789
E eu vou executar novamente
o comando "killall -9"

00:12:02.789 --> 00:12:04.254
e, automaticamente,
ele matou

00:12:04.254 --> 00:12:07.624
todos os processos
que tinham o nome "grep".

00:12:07.624 --> 00:12:10.705
Com esses três comandos,
"kill", "pkill" e "killall",

00:12:10.705 --> 00:12:13.953
nós podemos enviar diversos
sinais aos processos.

00:12:13.953 --> 00:12:18.169
Podemos parar, reiniciar,
suspender, continuar.

00:12:18.169 --> 00:12:20.635
Ou seja, você pode
manipular os processos

00:12:20.635 --> 00:12:22.258
conforme
a sua necessidade

00:12:22.258 --> 00:12:25.396
e se tornar ainda
mais eficiente

00:12:25.396 --> 00:12:28.486
na operação do terminal Linux,
utilizando processo.