Código

Conhecendo o GNU Screen

(Last Updated On: 19 de fevereiro de 2019)

Recentemente, estive trabalhando em uma aplicação de agenda de contatos usando o Django, da qual já fiz o deploy em um servidor remoto que eu aluguei.

Aparentemente, tudo estava certo, o site funcionava bem. Assim, fechei minha conexão SSH com o servidor, recarreguei a página aberta no meu navegador local e olha o que apareceu:
Error 502
Xi! Olha esse erro! Erros do tipo 50x indicam um problema do servidor, como é o caso do 502. Mas o que aconteceu? Há apenas algum tempinho tudo funcionava bem!

Me conectei novamente ao servidor remoto e surpresa… o Gunicorn não estava mais rodando! Mas ué, por que será?

Os processos no Linux

Quando fechamos nossa conexão SSH com o servidor, o Gunicorn parou. Por que isso aconteceu? Afinal, só queríamos fechar o Bash e a conexão que havíamos criado. Automaticamente, porém, encerramos o processo do Gunicorn junto… O que acontece é que, por mais óbvio que pareça, iniciamos o Gunicorn a partir do Bash e, assim, ele existe como processo filho do Bash.

Dessa forma, ao encerrarmos o Bash, encerramos junto todos os seus processos filhos – incluindo o Gunicorn. Mas ué, então qual a saída? Teremos de deixar o terminal rodando para que nosso site fique de pé? Isso até funcionaria, mas não seria legal.

O ideal seria se pudéssemos, de alguma forma, multiplicar o terminal em diferentes sessões. Isto é, tudo poderia funcionar se tivéssemos uma espécie de pequeno terminal rodando à parte, que não fecharia quando fechássemos o terminal principal. Mas isso é possível? É sim – e bem facilmente!

Aplicações chamadas de multiplicadoras de terminal são capazes de separar sessões diferentes de terminais em uma única janela. Assim, são úteis quando queremos trabalhar com mais de um programa na linha de comando (CLI) ao mesmo tempo e, no nosso caso, quando queremos que um programa não se inicie como filho do Bash, para que possa continuar rodando mesmo quando desconectarmos da máquina.

Existem diversas aplicações que funcionam como multiplicadoras de terminal, estando, dentre as mais famosas, o GNU Screen e o tmux. No nosso caso, usaremos o GNU Screen, por vir pré-instalado, por padrão, na maioria das distribuições Linux. E então, como podemos usá-lo?

Usando o GNU Screen para preservar a execução de um processo

Estamos em nosso terminal, e agora? Como podemos usar o GNU Screen para separarmos a execução do Gunicorn? Bem, podemos começar rodando um comando para criar uma nova sessão, da qual vou chamar de rodaGunicorn:

screen -S rodaGunicorn

Podemos checar as sessões do Screen rodando com o seguinte comando:

screen -ls

E verificar que estamos vinculados (attached) à sessão rodaGunicorn:
Lista sessões do Screen
Vinculados à nossa nova sessão, podemos voltar para o nosso projeto Django e executar o Gunicorn:
Gunicorn em execução
Legal! E agora? Ficamos presos nesta tela? Com o GNU Screen, isso é fácil! Vinculados a uma screen, podemos usar os comandos específicos do software através de uma tecla de escape, que geralmente é Ctrl-a. Para simplesmente nos desvincularmos da screen, podemos usar esta tecla de escape seguida da tecla d. Podemos checar novamente a lista de sessões e olha só:
Lista de screens detached
O Gunicorn continua rodando na screen que criamos!

Fui entrar no meu site pelo navegador e continuou dando aquele mesmo erro! Acabei me confundindo e esqueci que eu configurei meu servidor web para direcionar as requisições para a porta 8001, não 8000.

Precisamos reiniciar o Gunicorn com as configurações corretas. Mas como voltamos para a sessão onde o Gunicorn está rodando? Para nos vincularmos a uma sessão a partir do nome dela, basta usar a flag -r do comando screen:

screen -r rodaGunicorn

Podemos encerrar o Gunicorn com o comando Ctrl-C e iniciá-lo novamente com as configurações corretas:
Reiniciando o Gunicorn
Dessa vez, podemos nos desvincular dessa screen e até fechar o terminal, que olha só:
Site funcionando!
Nosso site continua funcionando!

Para saber mais: Múltiplos terminais em uma única tela com Screen

O GNU Screen, além do uso básico que acabamos de ver, em que temos sessões diferentes para diferentes processos, tem mais algumas funcionalidades muito úteis!

Uma muito bacana é a que nos permite dividir uma única tela de terminal em diversos pequenos terminais, mais ou menos dessa forma:
Divisões de tela com Screen
Para isso, basta usarmos alguns comandos de gerenciamentos de janelas e divisão de telas próprio do GNU Screen!

Controlando múltiplos terminais com o GNU Screen

Muitas vezes, precisamos deixar um processo rodando em nosso terminal por tempo indeterminado. Inevitavelmente, chega um momento em que precisamos fechar o terminal, mas queremos que o processo continue executando – e aí?

Entendemos que os processos inicializados pelo terminal são filhos dele e, por isso, são encerrados assim que este é. Por conta disso, tínhamos um grande problema, afinal precisávamos manter o processo do Gunicorn rodando!

Assim, conhecemos o GNU Screen – um multiplicador de terminal que nos permite separar nossos processos por sessões que não interferem uma na outra. Dessa forma, quando fechássemos o terminal, os processos dentro das sessões do Screen continuariam rodando!

Além disso tudo, ainda demos uma olhadinha no poder do GNU Screen, com sua funcionalidade de divisão de telas e janelas dentro de um único terminal.

E aí? Já conhecia o GNU Screen? Ele pode nos ajudar bastante, não acha? Deixe um comentário aqui no post com a sua opinião para conversarmos um pouco mais! 😉

FIQUE POR DENTRO

Desenvolvedor Python apaixonado por educação e segurança.
Explicit is better than implicit.
Twitter: @yanorestes
Email: yan.orestes@alura.com.br

Próximo ArtigoConhecendo os tipos de aprendizado de máquina