0:00:07.881,0:00:09.753
Você tem percebido[br]que o seu sistema

0:00:09.753,0:00:13.383
está se comportando[br]de uma maneira não comum.

0:00:13.383,0:00:17.211
Uma série de processos está[br]consumindo recursos desnecessários

0:00:17.211,0:00:19.624
e você precisa[br]tomar uma decisão.

0:00:20.624,0:00:23.928
Um dos comandos mais utilizados[br]para o envio de sinais a processos

0:00:23.928,0:00:25.791
é o comando "kill".

0:00:25.791,0:00:27.935
Comando "kill",[br]do inglês "matar",

0:00:27.935,0:00:30.732
não necessariamente[br]mata os processos.

0:00:30.732,0:00:32.443
O correto é afirmar[br]que ele envia

0:00:32.443,0:00:34.973
um determinado sinal[br]para o processo.

0:00:34.973,0:00:38.106
Eu posso enviar um sinal[br]para o processo parar,

0:00:38.106,0:00:42.717
para o processo reiniciar,[br]para o processo ser morto,

0:00:42.717,0:00:45.781
para o processo[br]ser suspendido,

0:00:45.781,0:00:49.178
enfim, eu posso enviar[br]vários tipos de sinais

0:00:49.178,0:00:51.398
para um processo[br]utilizando o comando "kill".

0:00:52.571,0:00:55.634
Vamos dar uma olhada em todas[br]as opções que conseguimos explorar,

0:00:55.634,0:00:57.575
utilizando[br]o comando "kill".

0:00:57.575,0:01:02.048
Primeiramente, eu vou executar[br]o comando "kill -l".

0:01:02.817,0:01:05.698
Quando nós executamos[br]esse comando,

0:01:05.698,0:01:09.772
ele me dá uma lista de possíveis[br]sinais que eu posso enviar.

0:01:09.772,0:01:12.278
Detalhe importante:[br]o comando "kill" aceita

0:01:12.278,0:01:16.315
com que eu passe o sinal[br]tanto de forma numérica

0:01:16.315,0:01:20.397
quanto através do próprio[br]nome do sinal.

0:01:20.397,0:01:21.645
Aqui, nós vamos abordar

0:01:21.645,0:01:25.626
somente as principais opções[br]do comando "kill".

0:01:25.626,0:01:28.515
Se você tiver interesse[br]em obter mais detalhes,

0:01:28.515,0:01:32.362
é só você ler o manual[br]do "kill", o "man kill".

0:01:32.362,0:01:35.062
Toda vez que eu quiser[br]enviar um sinal para o processo,

0:01:35.062,0:01:39.270
eu tenho que saber[br]qual é o PID do processo.

0:01:39.270,0:01:42.373
Então, eu vou executar[br]aqui um processo.

0:01:42.373,0:01:47.044
Eu vou enviar esse processo[br]para o segundo plano, parando-o,

0:01:47.044,0:01:51.383
e, depois, eu vou enviar um outro[br]sinal para o processo com o "kill".

0:01:51.383,0:01:53.046
Eu vou executar[br]o seguinte comando:

0:01:53.046,0:02:00.856
"grep menos ri, espaço, aspas[br]duplas, linux, aspas duplas, barra".

0:02:00.856,0:02:03.695
Eu estou procurando todas[br]as ocorrências da palavra Linux

0:02:03.695,0:02:08.066
em todos os arquivos a partir[br]da raiz, de forma recursiva.

0:02:08.066,0:02:10.028
Se eu der enter,[br]automaticamente,

0:02:10.028,0:02:12.911
ele vai mostrar uma série[br]de informações na tela.

0:02:12.911,0:02:14.283
Então, eu vou usar

0:02:15.328,0:02:16.976
esse comando

0:02:18.112,0:02:21.828
para que ele mande[br]o que encontrar

0:02:21.828,0:02:25.133
para dentro do diretório[br]"barra dev barra null".

0:02:27.362,0:02:29.336
Perceba que o comando[br]está executando,

0:02:29.336,0:02:32.192
porém ele está executando[br]em segundo plano.

0:02:32.192,0:02:36.264
Se der o comando [br]"ps aux | grep grep",

0:02:37.570,0:02:41.034
ele trouxe para mim o comando,[br]que está aqui.

0:02:41.034,0:02:44.053
Então, esse é o PID[br]do comando,

0:02:44.053,0:02:46.570
que é o número[br]que identifica o processo.

0:02:46.570,0:02:51.412
Se eu digitar o comando "jobs",[br]ele vai mostrar todos os processos

0:02:51.412,0:02:52.986
que eu executei.

0:02:52.986,0:02:57.384
Então, automaticamente,[br]tenho dois processos em execução.

0:02:57.384,0:02:59.153
Dois greps rodando.

0:02:59.153,0:03:00.403
Vamos imaginar[br]o seguinte:

0:03:00.403,0:03:02.994
se você digitar[br]o comando "jobs -l",

0:03:02.994,0:03:06.824
automaticamente, ele mostra[br]o PID do processo.

0:03:06.824,0:03:09.115
Lembre-se: para poder[br]executar o comando "kill",

0:03:09.115,0:03:11.696
eu tenho que saber[br]o PID do processo.

0:03:11.696,0:03:14.575
Vamos imaginar que eu queira[br]enviar um sinal

0:03:14.575,0:03:17.839
para esse comando[br]de PID 959.

0:03:17.839,0:03:20.415
Eu vou usar[br]o comando "kill espaço".

0:03:20.415,0:03:22.224
Qual o sinal que eu[br]quero enviar?

0:03:22.224,0:03:25.914
Se nós dermos um "kill -l",[br]conseguimos ver todos os sinais.

0:03:25.914,0:03:29.049
Vamos imaginar que eu[br]quero mandar um "SIGTSTP",

0:03:29.049,0:03:32.287
que é o sinal[br]de parar o processo.

0:03:32.287,0:03:37.493
Eu dou um "kill",[br]posso usar a opção -20

0:03:37.493,0:03:40.830
e posso usar[br]o PID 959.

0:03:40.830,0:03:41.809
Pronto.

0:03:41.809,0:03:44.317
Se nós digitarmos agora[br]o comando de "jobs -l",

0:03:44.317,0:03:47.422
perceba que o processo[br]está parado.

0:03:47.422,0:03:50.204
Esse processo não foi morto,[br]ele só foi parado

0:03:50.204,0:03:52.734
Automaticamente,[br]eu consigo mandar um sinal

0:03:52.734,0:03:55.005
para poder continuar[br]esse processo?

0:03:55.005,0:03:55.751
Sim.

0:03:56.861,0:04:00.858
"kill" menos o sinal[br]que eu vou utilizar,

0:04:00.858,0:04:04.731
que é SIGCONT,[br]que é o 18.

0:04:04.731,0:04:11.149
Eu posso tanto colocar o -18,[br]como eu posso colocar -SIGCONT,

0:04:11.149,0:04:14.231
e colocar o número[br]do PID, 959.

0:04:14.231,0:04:19.791
Pronto, se eu der o "jobs -l",[br]o processo voltou a ser executado.

0:04:20.735,0:04:21.922
O que nós fizemos?

0:04:21.922,0:04:26.444
Pegamos um processo, enviamos[br]um sinal com "kill" para ele parar.

0:04:26.444,0:04:27.972
Esse processo parou.

0:04:27.972,0:04:29.363
Imagine que fosse[br]um processo

0:04:29.363,0:04:32.060
que estava consumindo[br]muito recurso na sua máquina.

0:04:32.060,0:04:34.712
E, depois,[br]nós demos um sinal

0:04:34.712,0:04:37.896
para ele continuar a execução[br]normalmente.

0:04:37.896,0:04:40.399
Um outro sinal que podemos[br]mandar para o processo

0:04:40.399,0:04:43.705
é o sinal para ele parar.

0:04:43.705,0:04:45.914
O sinal padrão[br]de parada de processo

0:04:45.914,0:04:49.945
é o sinal 15[br]ou SIGTERM.

0:04:49.945,0:04:54.039
Esse sinal permite com que eu[br]pare o processo de forma tranquila.

0:04:54.039,0:04:55.720
Sabe quando você dá,[br]por exemplo,

0:04:55.720,0:04:59.952
o comando "systemctl stop"[br]e o nome do serviço?

0:04:59.952,0:05:02.827
Ou você quer que um processo[br]pare de forma tranquila,

0:05:02.827,0:05:05.400
sem ser parado[br]abruptamente?

0:05:05.400,0:05:10.790
A opção padrão de parada[br]de processo é essa: -15 ou SIGTERM.

0:05:10.790,0:05:13.670
Eu vou executar agora na tela[br]e vamos ver o que acontece.

0:05:13.670,0:05:18.264
"kill -15 959",[br]que é o PID.

0:05:18.264,0:05:19.783
Pronto.

0:05:19.783,0:05:25.492
Se der um "jobs -l", estará dizendo[br]que o processo foi terminado.

0:05:25.492,0:05:28.892
Processos terminados[br]não podem ser continuados,

0:05:28.892,0:05:31.498
ou seja, ele acabou[br]de ser finalizado.

0:05:31.498,0:05:33.898
Se nós dermos[br]novamente um "jobs -l",

0:05:33.898,0:05:37.505
ele não mais aparece na listagem[br]dos processos em execução.

0:05:37.505,0:05:40.407
Existe uma outra opção[br]do comando "kill",

0:05:40.407,0:05:42.343
que é o que as pessoas[br]associam

0:05:42.343,0:05:45.216
ao fato dele ser usado[br]para matar processos,

0:05:45.216,0:05:46.846
que é a opção -9

0:05:46.846,0:05:50.461
Ela manda um sinal[br]chamado SIGKILL,

0:05:50.461,0:05:56.337
ou seja, ela manda o processo[br]ser morto de forma abrupta.

0:05:56.337,0:06:00.408
Se você tiver algum arquivo aberto,[br]o "kill" não vai se importar.

0:06:00.408,0:06:03.428
Se alguém estiver usando esse[br]arquivo, ele não vai se importar.

0:06:03.428,0:06:07.449
Ele simplesmente vai parar[br]abruptamente o processo.

0:06:07.449,0:06:11.353
Apesar desta informação ser enviada[br]diretamente para o processo,

0:06:11.353,0:06:14.210
isso pode ocasionar[br]alguns problemas graves

0:06:14.210,0:06:16.708
de corrompimento de dados[br]no seu sistema,

0:06:16.708,0:06:18.681
como, por exemplo,[br]se você mandar

0:06:18.681,0:06:21.629
um sinal com -9[br]para um banco de dados.

0:06:21.629,0:06:23.759
Eu vou executá-lo[br]agora, aqui no terminal,

0:06:23.759,0:06:26.102
para vocês entenderem[br]o poder que ele tem.

0:06:26.102,0:06:28.414
Vamos executar[br]o comando "jobs -l".

0:06:28.414,0:06:31.616
Eu ainda tenho um outro[br]processo do grep executando

0:06:31.616,0:06:34.143
com o PID 965.

0:06:34.143,0:06:38.622
Vou dar um "kill -9 965".

0:06:39.369,0:06:41.598
E vou dar um "jobs -l".

0:06:41.598,0:06:45.025
Perceba que, agora, o processo[br]não foi parado, ele foi morto.

0:06:45.025,0:06:48.292
Então, ele mandou um sinal[br]para matar o processo.

0:06:48.292,0:06:51.662
É possível matar vários processos[br]ao mesmo tempo?

0:06:51.662,0:06:52.492
Sim.

0:06:52.492,0:06:56.116
Nós vamos ver aqui uma lista[br]de processos e vamos matá-los,

0:06:56.116,0:06:57.825
todos com o comando "kill".

0:06:57.825,0:07:02.467
Eu vou executar novamente[br]o "grep -ri,

0:07:04.759,0:07:07.966
a palavra linux na raiz,

0:07:09.427,0:07:11.990
dois e,

0:07:11.990,0:07:18.028
maior que um, maior[br]que barra dev, barra null",

0:07:18.028,0:07:19.710
mandando[br]para segundo plano.

0:07:21.323,0:07:24.122
Pronto, vou rodar[br]algumas outras vezes.

0:07:24.122,0:07:27.141
Vou executar 10 vezes[br]esse comando.

0:07:28.774,0:07:34.974
Se nós dermos[br]um "jobs -l", está lá.

0:07:34.974,0:07:38.280
Todos os PIDs dos processos[br]que estão rodando

0:07:38.280,0:07:40.856
Para você finalizar todos[br]os processos ao mesmo tempo,

0:07:40.856,0:07:42.859
a gente vai executar[br]o seguinte comando:

0:07:42.859,0:07:47.899
eu vou capturar todos[br]os PIDs e vou executar,

0:07:47.899,0:07:53.213
"kill" e aí, podemos passar[br]tanto -9 quanto -15.

0:07:53.213,0:07:56.208
Lembrando que -9 vai matar[br]o processo abruptamente

0:07:56.208,0:08:01.016
e o -15 vai somente parar[br]o processo de forma tranquila.

0:08:02.185,0:08:05.765
Vou usar o sinal -9,[br]que é o SIGKILL,

0:08:06.633,0:08:11.879
e posso passar todos os PIDs,[br]separados por espaço.

0:08:22.576,0:08:24.161
Perceba que realmente[br]dá trabalho.

0:08:24.161,0:08:26.095
Se tivesse 100[br]processos rodando,

0:08:26.095,0:08:29.455
eu teria que passar[br]os 100 números dos PIDs.

0:08:31.271,0:08:35.726
Se eu der um "jobs -l", só ficou[br]executando o processo 1037,

0:08:35.726,0:08:38.371
que, provavelmente,[br]eu o pulei aqui da lista.

0:08:39.671,0:08:43.618
Vamos aproveitar, então,[br]e treinar o -15.

0:08:48.213,0:08:49.161
Pronto.

0:08:49.161,0:08:50.345
Esse é o comando "kill",

0:08:50.345,0:08:53.265
comando usado para podermos[br]enviar um sinal para o processo.

0:08:53.265,0:08:56.162
Você pode mandar um sinal[br]para ele parar, continuar,

0:08:56.162,0:08:58.447
para ele suspender,[br]para ele reiniciar.

0:08:58.447,0:09:03.377
Tudo depende do quanto você[br]precisa que o sinal seja enviado

0:09:03.377,0:09:05.952
e como você quer[br]que esse comando se comporte.

0:09:05.952,0:09:08.463
O comando "kill" permite[br]matar processos

0:09:08.463,0:09:11.628
utilizando o PID,[br]o "Process Identification".

0:09:11.628,0:09:14.714
Existem dois comandos[br]que facilitam muito a nossa vida

0:09:14.714,0:09:18.798
quando o objetivo é matar[br]vários processos ao mesmo tempo.

0:09:18.798,0:09:21.579
Esses comandos[br]são "PKILL" e "KILLALL".

0:09:21.579,0:09:26.156
O PKILL permite matar processos[br]utilizando o nome do processo,

0:09:26.156,0:09:27.594
assim como KILLALL.

0:09:27.594,0:09:31.328
Então, todos os sinais que enviei[br]para os processos usando kill,

0:09:31.328,0:09:34.550
eu posso fazer também[br]com os comandos PKILL e KILLALL,

0:09:34.550,0:09:36.645
porém, ao invés[br]de eu passar o PID,

0:09:37.509,0:09:40.689
eu passo o nome[br]do processo.

0:09:42.003,0:09:43.039
Vamos executar agora.

0:09:43.827,0:09:47.727
Eu vou gerar uma lista de processos[br]novamente com o comando grep.

0:09:51.369,0:09:54.519
Cinco processos foram gerados[br]com esse comando grep:

0:09:54.519,0:09:58.208
"grep menos ri, linux, barra 2,[br]e comercial, maior que 1,

0:09:58.208,0:10:00.892
maior que barra dev,[br]barra null, e comercial".

0:10:00.892,0:10:05.040
Se nós dermos um "jobs -l",[br]estão lá todos os processos.

0:10:05.040,0:10:07.896
Todos os processos[br]tem o nome de "grep".

0:10:07.896,0:10:10.932
Nesse momento, eu vou[br]executar o comando "pkill"

0:10:10.932,0:10:13.054
e posso usar todas[br]as opções de sinais

0:10:13.054,0:10:16.575
que vimos no "kill",[br]-9, -15.

0:10:16.575,0:10:21.714
Eu vou usar a opção -15 para parar[br]esses processos de forma natural.

0:10:21.714,0:10:23.748
E, ao invés de eu[br]passar PID por PID,

0:10:23.748,0:10:26.410
como eu faria no "kill"[br]eu passo simplesmente o nome

0:10:26.410,0:10:32.579
do comando que foi executado,[br]no caso aqui, o próprio "grep".

0:10:33.857,0:10:34.948
Quando eu dou[br]um enter,

0:10:34.948,0:10:38.865
ele termina todos os processos[br]com o nome "grep".

0:10:38.865,0:10:41.489
Isso permite com que eu[br]tenha muito mais velocidade

0:10:41.489,0:10:45.081
na execução do comando[br]quando quiser finalizar um processo

0:10:45.081,0:10:48.408
ou vários processos[br]utilizando o nome.

0:10:48.408,0:10:49.689
O comando[br]KILLALL funciona

0:10:49.689,0:10:52.202
de maneira parecida[br]com o comando PKILL.

0:10:52.202,0:10:54.610
Nós conseguimos[br]matar diversos processos

0:10:54.610,0:10:57.271
utilizando o nome[br]dos processos.

0:10:57.271,0:10:59.226
Eu vou executar, agora,[br]novamente o "grep"

0:10:59.226,0:11:02.281
para que possamos visualizar isso[br]acontecendo dentro do sistema.

0:11:03.194,0:11:05.668
Eu vou executar agora[br]5 vezes o comando "grep"

0:11:05.668,0:11:07.007
para que gerem[br]os processos

0:11:07.007,0:11:09.265
e a gente possa utilizar[br]o KILLALL para matá-lo.

0:11:10.325,0:11:13.397
1, 2, 3, 4, 5.

0:11:14.379,0:11:18.139
Se nós executarmos o comando[br]"jobs -l", está lá,

0:11:18.139,0:11:19.518
5 processos[br]de execução.

0:11:19.518,0:11:21.843
O nome do processo é "grep".

0:11:21.843,0:11:25.747
Eu vou usar o "killall"[br]para poder matar esses processos.

0:11:25.747,0:11:28.817
Vou utilizar os mesmos sinais[br]que eu uso no "kill" e no "pkill".

0:11:28.817,0:11:33.046
Vou usar, por exemplo, o -9[br]para matar o processo forçando.

0:11:33.046,0:11:34.399
E o comando[br]que quero matar

0:11:34.399,0:11:36.919
são todos os comandos[br]que contêm o nome "grep".

0:11:36.919,0:11:38.930
Recebi uma mensagem[br]que o comando "killall"

0:11:38.930,0:11:40.970
não foi encontrado.

0:11:40.970,0:11:46.804
Vamos instalá-lo através do comando[br]"apt install psmisc".

0:11:46.804,0:11:48.426
Vou utilizar[br]a opção menos y

0:11:48.426,0:11:50.844
para ele dizer sim[br]para todos os questionamentos.

0:11:55.405,0:11:57.180
Pronto, uma vez[br]instalado o "psmisc",

0:11:57.180,0:11:59.166
ele trouxe para mim[br]o "killall".

0:11:59.166,0:12:02.789
E eu vou executar novamente[br]o comando "killall -9"

0:12:02.789,0:12:04.254
e, automaticamente,[br]ele matou

0:12:04.254,0:12:07.624
todos os processos[br]que tinham o nome "grep".

0:12:07.624,0:12:10.705
Com esses três comandos,[br]"kill", "pkill" e "killall",

0:12:10.705,0:12:13.953
nós podemos enviar diversos[br]sinais aos processos.

0:12:13.953,0:12:18.169
Podemos parar, reiniciar,[br]suspender, continuar.

0:12:18.169,0:12:20.635
Ou seja, você pode[br]manipular os processos

0:12:20.635,0:12:22.258
conforme[br]a sua necessidade

0:12:22.258,0:12:25.396
e se tornar ainda[br]mais eficiente

0:12:25.396,0:12:28.486
na operação do terminal Linux,[br]utilizando processo.