Criar pendrive bootável do Windows no Linux pode parecer algo complexo a primeira vista, mas com algumas ferramentas é possível atingir o objetivo sem muito esforço ou conhecimento. O melhor da história é que seguindo os passos deste tutorial, você vai conseguir criar um pendrive bootável do Windows 7, Windows 8 e Windows 10 sem ter que mudar absolutamente nada além da ISO de instalação do Windows desejado.

Para este tutorial vou utilizar o Debian 8, porém, isso deverá funcionar em várias distros do Linux sem muitas alterações. Além do Debian como sistema operacional, vamos utilizar o ms-sys para escrever a MBR do Windows no pendrive e o GParted para formatação e criação de partições do mesmo. Mas não se preocupe com isso agora, vou passar cada detalhe em um passo a passo mais a diante.

Atenção: Como vamos manipular partições, você deve prestar muita atenção em cada parte descrita a seguir para não aplicar comandos no dispositivo incorreto. É muito fácil confundir os nomes dos dispositivos. Caso você exclua a partição incorreta, será muito complexo ou impossível recuperar os dados que ela continha.

Sem mais delongas, vamos ao tutorial.

Como criar pendrive bootável do Windows no Linux

Para começar vamos instalar tudo o que é necessário para concluir os passos adiante. Não é muita coisa, apenas o Gparted e o ms-sys.

O Gparted já vem com algumas distros do Linux, porém, caso precise instalar digite o seguinte no terminal da sua distro Debian ou baseadas.

sudo apt-get install gparted

Caso tenha algum problema ou sua distro for diferente, siga os passos indicados no site oficial do Gparted: http://gparted.org/download.php.

O ms-sys não vem com nenhuma distro e também não está presentes dentro os pacotes das mesmas, por isso é necessário baixar e instalar este programa. Para tal, siga os passos abaixo:

1 – Baixe o ms-sys para o local de sua preferência no seu computador;

2 – Digite o seguinte comando para descompactar a pasta baixada:

tar xzvf /caminho/para/o/ms-sys*.tar.gz

3 – Acesse a pasta descompactada digitando:

cd ms-sys-*

4 – Instale o programa digitando:

make
sudo make install

O dois comandos acima farão a instalação do ms-sys. Caso tenha problemas, veja mais detalhes no site oficial: http://ms-sys.sourceforge.net/.

Atenção: Verifique seus discos

Antes de sair excluindo as partições, tenha certeza de qual disco você está selecionando. Para isso vamos utilizar o comando fdisk que já vem com a maioria das distros Linux.

Abra o terminal e digite:

sudo fdisk -l

Você verá uma tela indicando os discos presentes em seu computador, suas respectivas partições e detalhes de tamanho, tipo, etc… O importante aqui é que você saiba qual é o seu pendrive. Existem várias maneiras para descobrir isso, uma delas é pelo tamanho em GBs (mais fácil e rápido). Outra maneira simples seria executar o comando acima com o pendrive desconectado, marcar quais os discos estão sendo apresentados, conectar o pendrive, executar o comando novamente e verificar qual novo disco foi exibido, mais trabalhoso, porém, mais efetivo.

Os discos são exibidos da seguinte maneira no Linux:

/dev/sdX

Onde o X representa uma letra que será diferente para cada disco, por exemplo:

/dev/sda
...
/dev/sdb
...
/dev/sdc

Isto representa um disco inteiro, a representação das partições vem depois da última letra como um número, por exemplo:

/dev/sda
    /dev/sda1
    /dev/sda2
    /dev/sda3
...

No trecho acima você está vendo um disco com 3 partições. Normalmente os pendrives têm apenas uma partição, no caso acima estaríamos falando de um HDD dentro do seu computador.

Veja na imagem abaixo o que foi detectado em meu computador no momento em que este tutorial foi escrito.

Saída do comando sudo fdisk -l

Saída do comando sudo fdisk -l

Perceba que pelo tamanho já podemos saber que o pendrive é o disco /dev/sdb, portanto meus comandos serão voltados para esse disco.

Atenção: Nunca, em hipótese alguma execute nenhum comando antes de checar qual a identificação do seu pendrive no sistema. A cada reinicialização do sistema as letras podem ser invertidas automaticamente, com isso pode ser que você exclua partições do sistema, ou de outro disco que contenha dados importantes para você.

Formatando o pendrive e adicionando partição NTFS

Agora você já sabe qual é o seu pendrive, então não corremos o risco de você formatar a partição incorreta acidentalmente. Abra o Gparted e selecione a partição do seu pendrive.

Selecione o pendrive correto, conforme vimos anteriormente

Selecione o pendrive correto, conforme vimos anteriormente

Clique com o botão direito do mouse sobre a partição e selecione a opção “Desmontar”; Em seguida, clique novamente com o botão direito do mouse sobre a partição e selecione “Excluir”. Por fim clique no botão superior para “Aplicar” as configurações.

Aplicando as configurações que fizemos

Aplicando as configurações que fizemos

Agora clique no botão “Novo” e adicione uma nova partição “ntfs” com o rótulo “msdos”.

Adicionando uma nova partição NTFS

Adicionando uma nova partição NTFS

Depois de adicionar, aplique as configurações novamente.

Agora clique com o botão direito do mouse sobre a nova partição criada e selecione a opção “Gerenciar sinalizadores”. Marque a opção “Boot”.

Adicionando a flag de boot

Adicionando a flag de boot

Para finalizar, feche o Gparted e abra o terminal novamente.

Gravando a MBR do Windows com o ms-sys

Agora que já temos um pendrive de boot formatado com o sistema de arquivos NTFS e a flag de boot ativa, vamos gravar a MBR do Windows utilizando o ms-sys, para isso digite o seguinte no terminal:

sudo ms-sys -7 /dev/sdb

Atenção: Se você não gravar a MBR indicada acima o pendrive vai até dar boot, mas não iniciará o Windows. Lembre-se de trocar “sdb” para o nome do seu pendrive.

Copiando os arquivos da ISO

Agora só precisamos copiar os arquivos da ISO do seu Windows para dentro do Pendrive, para isso vamos montar o pendrive e a ISO.

Dentro do terminal, digite o seguinte para criar duas pastas:

sudo mkdir --mode=777 /mnt/pendrive
sudo mkdir --mode=777 /mnt/windows

Agora monte o pendrive e a ISO com os seguintes comandos:

sudo mount /dev/sdb1 /mnt/pendrive
sudo mount -o loop /caminho/da/windows.iso /mnt/windows/

Perceba que você deve alterar duas coisas no comando acima:

  • sdb1 – para o nome do seu pendrive (o número 1 continua);
  • /caminho/da/windows.iso – para o caminho da sua ISO do Windows.

Depois de tudo montado, é só digitar o seguinte para copiar os arquivos:

cp -r /mnt/windows/* pendrive/

Isso vai levar um tempão, mas aguarde até o terminal o liberar para poder digitar novamente.

Boot da placa-mãe

Depois de terminar tudo o que foi indicado acima, seu pendrive bootável do Windows foi criado, o próximo passo é modificar o sistema de boot da placa-mãe para iniciar pelo pendrive que você acabou de criar e pronto, faça o que desejar com sua nova instalação do Windows.

Vídeo tutorial

Abaixo um vídeo tutorial para ajudar você caso tenha tido dúvidas:

Link do vídeo: https://www.youtube.com/watch?v=pVNHPTsLW-4

Espero que tenha ajudado!

Saber se seu Linux é de 32-Bit ou 64-Bit pode parecer algo extremamente simples para quem já é avançado no sistema, porém, pode ser algo complexo para pessoas que não costumam verificar esse tipo de informação. Além de ser importante saber informações básicas sobre o sistema que você executa em seu computador, isso também poderá determinar qual software escolher quando for instalar algo que tenha ambas as opções.

Existem diversas maneiras para saber se seu Linux é de 32-Bit ou 64-Bit, tanto por linha de comando quanto por interface gráfica, no entanto, vamos falar apenas algumas voltadas para o shell, já que a maioria dos servidores não conta com interface gráfica.

Como saber se meu Linux é de 32-Bit ou 64-Bit

Se você estiver usando um computador com Interface gráfica, abra o terminal e digite o seguinte:

uname –a

Você várias informações, por exemplo:

Linux luizotaviopc 3.16.0-4-amd64 #1 SMP Debian 3.16.7-ckt25-1 (2016-03-06) x86_64 GNU/Linux

As informações acimas são indicadas na seguinte ordem:

kernel-name nodename kernel-release kernel-version
machine processor hardware-platform operating-system

Via: GNU Coreutils

A única parte importante para que você saiba se seu Linux é de 32-Bit ou 64-Bit é a “machine”, que no meu caso mostra “x86_64”, ou seja: 64-Bit. Caso você tenha visto algo como i686 ou i386, seu sistema é de 32-bit.

Se você pretende ver apenas a informação “machine” ao utilizar o comando “uname”, você pode simplificar a saída do mesmo digitando apenas o seguinte:

uname -m

A saída será apenas o seguinte:

x86_64 para 64-Bit ou i686 / i386 para 32-Bit

x86_64 para 64-Bit ou i686 / i386 para 32-Bit

Assim fica mais fácil para que você possa checar a informação.

Conforme descrevi, você também pode verificar essa informação direto pela interface gráfica, para isso acesse as “Configurações do sistema” / “Informações do sistema”.

Debian x86_64

Debian x86_64

É só isso… Espero que tenha sido útil.

Obs: Sempre que faço algum vídeo para nosso canal do Youtube, alguém questiona qual sistema estou utilizando. Agora você já sabe rsrs!

Cron e Crontab no Linux são, de maneira geral, responsáveis por agendar e executar tarefas que o usuário pretenda que sejam executadas com determinada regularidade, seja uma ou várias vezes por minuto, hora, dia, mês e assim por diante. Com a adição do poder e vantagem que os scripts possibilitam (em qualquer linguagem que seja escrito) as possibilidades se tornam praticamente infinitas.

Suponhamos que você faça um backup (dump) de suas bases de dados MySQL todo santo dia às 5h da manhã. Não seria melhor que o próprio Linux fizesse esse backup automaticamente para você? É este tipo de conforto que o cron lhe da, simplesmente crie um script e agende no arquivo crontab para que ele seja executado todos os dias pela madrugada.

O exemplo acima poderia ser facilmente atingido se você colocar a seguinte linha no arquivo /etc/crontab:

0  5  *  *  *  usuario  /bin/bash '/caminho/mysql_dump.sh'

Mais adiante neste artigo vou entrar em maiores detalhes sobre a linha acima, mais primeiro vamos entender melhor o que é cron e crontab para que você saiba o que eles fazem e como trabalham juntos.

O cron do Linux

O Cron do Linux é um daemon que executa comandos ou scripts agendados por uma tabela chamada de crontab. Quando iniciado, ele procura por arquivos crontab (geralmente na pasta /var/spool/cron/crontabs) para carregá-los na memória. Além disso, o cron também lê o arquivo /etc/crontab e os arquivos em /etc/cron.d em busca de ainda mais tarefas a serem executadas em uma espécie de agenda.

Depois de tudo carregado na memória, o cron será executado minuto a minuto, examinando todos os crontabs armazenados e verificando cada comando para saber se algo deve ser executado no minuto atual.

Sendo multi-usuário, cada usuário pode ter uma tabela crontab diferente e o cron saberá quando deverá executar tais tarefas e quem será responsável pelas mesmas.

 E quanto ao Crontab?

Crontab é um arquivo que contém dados sobre quando um comando ou script deve ser executado e quem é seu responsável. Este é um arquivo de texto simples que recebe um formato especial para que o cron o entenda.

Para explicar de maneira simples, o arquivo crontab seria como uma agenda e o cron o dono dessa agenda, que a verifica minuto a minuto para ver se tem alguma tarefa a fazer.

Também existe um comando “crontab” que serve para criar crontabs de acordo com parâmetros passados a ele. É possível criar um crontab para cada usuário em específico, porém, vamos editar apenas o arquivo /etc/crontab (que nos dará praticamente as mesmas possibilidades) neste tutorial.

Cron e Crontab no Linux

Colocando em prática tudo o que você leu, a única coisa que você precisa fazer para agendar tarefas no Linux é adicionar uma linha no arquivo /etc/crontab. Cada linha é responsável por uma tarefa e deve ser escrita seguindo um formato específico para o Cron, caso contrário não vai funcionar.

O formato de cada linha segue o seguinte padrão:

(minuto) (hora) (dia do mês) (mês) (dia da semana) (usuário) (comando/script)

Cada trecho da linha acima deve ser separado por espaços. Por exemplo, se eu quero que algo seja executado dia 29/10 às 23:28, ficaria assim:

28 23 29 10 * luizotavio /bin/bash "/caminho/script.sh"

Veja mais detalhes sobre cada trecho da linha do arquivo /etc/crontab.

  • Minuto: de 0 a 59.
  • Hora: de 0 a 23;
  • Dia do mês: de 1 a 31;
  • Mês: de 1 a 12;
  • Dia da semana: de 0 a 7 (0 e 7 equivalem a domingo);
  • Usuário: O responsável pela tarefa;
  • Comando/Script: Um comando ou script que você deseja que seja executado.

Além dos trechos acima, você também pode utilizar alguns símbolos interessantes, por exemplo:

  • * (um asterisco): Significa que aquele trecho irá se repetir continuamente; Por exemplo, se eu adicionar um * no lugar dos minutos, a tarefa será executada a cada minuto;
  • – (um traço): Significa um range, por exemplo 1-5 equivale a 1,2,3,4 e 5;
  • / (uma barra): Indica saltos para um range, por exemplo */2 significa “de dois em dois”. Se eu colocar isso no lugar de minutos, a tarefa será executada de 2 em 2 minutos;
  • , (uma vírgula): Separa valores e ranges, por exemplo 1-2,10. Dessa maneira eu poderia falar que uma tarefa será executada às 8h da manhã e às 15h da tarde, ou quantas vezes eu precisar.

Vamos ver alguns exemplos práticos para facilitar a sua vida.

Exemplos de crontab no Linux

Os exemplos abaixo devem ser adicionados no arquivo /etc/crontab. Caso não saiba como editar tal arquivo, basta abrir seu terminal e digitar:

sudo nano /etc/crontab

Note que algumas distros Linux já trazem tarefas específicas no crontab, portanto, você deve adicionar suas novas linhas ao final do arquivo. Por exemplo, no Debian 8 você terá o seguinte:

# /etc/crontab: system-wide crontab
# Unlike any other crontab you don't have to run the `crontab'
# command to install the new version when you edit this file
# and files in /etc/cron.d. These files also have username fields,
# that none of the other crontabs do.

SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

# m h dom mon dow user  command
17 *    * * *   root    cd / && run-parts --report /etc/cron.hourly
25 6    * * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
47 6    * * 7   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
52 6    1 * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )

# SUAS NOVAS LINHAS VIRÃO AQUI EM BAIXO

Perceba que a última linha foi adicionada por mim. Além disso, entenda que o sinal de # (cerquilha) tem a função de caracterizar aquela linha como um comentário, ou seja, toda linha que tiver um # no início não será lida pelo cron do Linux. Isso é útil para que você possa documentar suas tarefas, escrevendo o motivo pelo qual você adicionou aquela linha no crontab. Assim fica mais fácil de lembrar posteriormente e não correr risco de adicionar ou remover algo erroneamente.

Veja abaixo alguns exemplos básicos e complexos de tarefas no crontab do Linux.

Se você quer que uma tarefa seja executada minuto a minuto, adicione o seguinte:

# Minuto a minuto
* * * * * usuario /bin/bash '/caminho/do/meu_script.sh'

De dois em dois minutos ficaria assim:

# De 2 em 2 minutos
*/2 * * * * usuario /bin/bash '/caminho/do/meu_script.sh'

De hora em hora (lembre-se que você precisa especificar os minutos):

# De hora em hora (Aos 7 minutos de cada hora)
7 * * * * usuario /bin/bash '/caminho/do/meu_script.sh'

De quatro em quatro horas:

# De 4 em 4 horas (Aos 10 minutos de quatro em quatro horas)
10 */4 * * * usuario /bin/bash '/caminho/do/meu_script.sh'

Todos os dias (agora você precisa especificar minutos e horas):

# Todos os dias (Às 8 e 12 da noite)
12 20 * * * usuario /bin/bash '/caminho/do/meu_script.sh'

De dois em dois dias:

# De 2 em 2 dias (Às 8 e 25 da noite)
25 20 */2 * * usuario /bin/bash '/caminho/do/meu_script.sh'

De dois em dois dias, porém com um range diferente:

# De 2 em 2 dias (Porém apenas dias ímpares)
25 20 1-31/2 * * usuario /bin/bash '/caminho/do/meu_script.sh'

Todo mês, no primeiro dia do mês:

# Todo mês, no primeiro dia do mês, à meia noite
0 0 1 * * usuario /bin/bash '/caminho/do/meu_script.sh'

Em uma data específica:

# 26/10/AAAA 20:35
35 20 26 10 * usuario /bin/bash '/caminho/do/meu_script.sh'

Todo domingo à meia noite:

# Todo domingo à meia noite (0 ou 7)
0 0 * * 0 usuario /bin/bash '/caminho/do/meu_script.sh'

Toda segunda em uma hora específica:

# Toda segunda às 20:43
43 20 * * 1 usuario /bin/bash '/caminho/do/meu_script.sh'

Utilizando um range de horas e um range de minutos

# Às 19, 20 e 21 horas, de 56 até 59 minutos das horas determinadas
56-59 19-21 * * * usuario /bin/bash '/caminho/do/meu_script.sh'

Utilizando um range mais complexo:

# 12, 13, 14, 16 e 17 horas, nos minutos especificados abaixo
# 1, 2, 3, 4, 5, 10, 50, 51, 52, 53, 54, 55 e 59
1-5,10,50-55,59 12-14,16,17 * * * usuario /bin/bash '/caminho/do/meu_script.sh'

Perceba que detalhei tudo o que a linha faz no comentário (a linha que contém uma #) assim você já vai se acostumando a documentar seu código.

Até o próximo!

Su, Sudo e Sudoers no Linux: Neste tutorial você vai entender as permissões de usuários regulares e permissões de superusuário (root) no Linux.

Separação de privilégios é algo fundamental para a segurança de qualquer sistema operacional seja ele um servidor ou um computador pessoal. O Linux faz este papel muito bem não permitindo que nenhum usuário padrão execute tarefas que podem afetar a segurança do sistema como um todo (com exceção do superusuário – root).

Nós já detalhamos como gerenciar usuários no Linux aqui no TEO, mas hoje você vai entender melhor como funciona o sistema de usuários com maior foco no superusuário root, que pode fazer praticamente tudo dentro do seu Linux. Vamos detalhar como logar com o root utilizando o comando su, como executar tarefas com o root utilizando sudo e como manipular o arquivo sudoers para elevar privilégios de usuários dentro do sistema com segurança.

Não se preocupe se você é novato ou avançado no Linux, este tutorial vai do básico ao avançado, com algumas dicas para que você entenda melhor o que está acontecendo.

Então vamos lá?

Su, Sudo e Sudoers no Linux

Su, Sudo e Sudoers fazem papéis relativamente diferentes no sistema para atingir um mesmo objetivo, obter acesso elevado com o superusuário root do Linux.

Vamos dividi-los em partes e detalhar o que cada um faz.

Su

Uma maneira bem simples para obter acesso ao usuário root utilizando qualquer outro usuário é utilizando o comando “su”, simplesmente abra o terminal e digite o comando e o seguinte irá acontecer:

Utilizando o comando su

Utilizando o comando su

O processo acima segue os seguintes passos:

  • Abra o terminal;
  • Digite “su”;
  • Digite a senha do usuário root;
  • Se a senha estiver correta, um shell do usuário root é aberto dentro do terminal, a partir daí você é o rei do Linux;

O comando su pode ser utilizado por qualquer usuário por um fato bem simples, você precisa saber a senha do root para efetuar o login, caso contrário nada é feito.

Uma dica neste caso é que você evite utilizar o comando “su” e prefira “sudo”, porque o comando “su” faz login com o usuário root, permitindo executar tarefas de superusuário. Caso você faça algo imprudente dentro do sistema ao utilizar o comando “su” efetivamente, pode ser que você danifique o bom funcionamento do seu Linux.

Sudo

O comando “sudo” tem uma função similar à do “su” porém tem alguns detalhes que trazem maior segurança para o sistema. Veja algumas das diferenças:

  • Você não precisa saber a senha do usuário “root” para utilizar “sudo”, apenas do seu usuário;
  • O comando “sudo” não faz login com o usuário “root” apenas executa a tarefa requisitada como “root” e volta para seu shell;
  • Este comando é controlado pelo arquivo “sudoers” que, dentre milhares de outras coisas, indica quais usuários podem executar quais tarefas no sistema;
  • Você pode permitir que determinados usuários utilizem o comando “sudo” sem a necessidade de digitar sua senha (menos seguro);

Para executar tarefas com o superusuário root sem fazer login com o mesmo, simplesmente adicione “sudo” antes do comando que deseja executar, por exemplo, se eu quiser executar o comando “ifconfig”, ficaria assim:

sudo ifconfig

Na primeira vez que você executar o “sudo” dentro de um shell, sua senha será requisitada (dependendo da configuração do sudoers). Ao digitar a senha, ela não será mais requisitada até que o tempo de inatividade (timestamp_timeout) que estiver configurado no sudoers termine. Em outras palavras, ao utilizar “sudo” efetivamente uma vez, você só precisará digitar a senha novamente se ficar um determinado tempo sem utilizar o sudo novamente.

Os usuários que podem utilizar o comando “sudo” são definidos no arquivo “sudoers” (o qual vamos falar a seguir), se um usuário não estiver presente neste arquivo e tentar utilizar o “sudo”, receberá a seguinte mensagem:

usuario não está no arquivo sudoers. Este incidente será relatado.

Conforme imagem abaixo:

usuario não está no arquivo sudoers. Este incidente será relatado.

usuario não está no arquivo sudoers. Este incidente será relatado.

Vamos ver como editar o arquivo sudoers.

Editando o arquivo sudoers (visudo)

O arquivo sudoers pode ser editado com qualquer editor pelo superusuário root, porém, não é recomendado. O ideal é que você utilize o comando visudo. Por exemplo:

sudo visudo

Isso evita que você faça alguma besteira e perca o acesso ao “sudo” no seu Linux. Mas, se quiser correr o risco, basta editar o arquivo /etc/sudoers.

Ao digitar “sudo visudo” você verá um arquivo com várias coisas já configuradas (isso vai variar de distro pra distro – tenho usado o Debian 8 ultimamente).

Sudoers (visudo)

Sudoers (visudo)

Este arquivo pode conter milhares de configurações para controlar os acessos ao “sudo” do seu Linux, das quais você pode encontrar mais informações no manual. Para acessar o manual digite:

man sudoers

Porém vou detalhar algumas coisas importantes para que você possa entender melhor como dar privilégios para usuários no seu Linux.

As seguintes linhas são bastante importante pra gente:

root    ALL=(ALL:ALL) ALL
%sudo   ALL=(ALL:ALL) ALL

Elas indicam que o usuário “root” e membros do grupo “sudo” podem executar tudo dentro do sistema. Vamos detalhar melhor essas linhas começando pela primeira:

  • root – indica o nome do usuário que iremos configurar para obter acesso ao sudo, neste caso o usuário root;
  • ALL= – O primeiro ALL seguido do sinal de igual (=) indica o host, neste caso estamos indicando “todos os hosts”;
  • (ALL:ALL) – Esta combinação de (ALL:ALL) indica que o usuário “root” pode executar comandos como todos os usuários e grupos respectivamente.
  • ALL – O último ALL indica que essa regra aplica-se a qualquer comando que o usuário estiver tentando executar com o “sudo”.

Para a segunda linha temos o seguinte:

  • %sudo – indica o nome do grupo que iremos configurar para obter acesso ao sudo, neste caso o grupo “sudo”;
  • ALL= – O primeiro ALL seguido do sinal de igual (=) indica os hosts, neste caso estamos indicando “todos os hosts”;
  • (ALL:ALL) – Esta combinação de (ALL:ALL) indica que o grupo “sudo” pode executar comandos como todos os usuários e grupos respectivamente.
  • ALL – O último ALL indica que essa regra aplica-se a qualquer comando que um usuário do grupo sudo estiver tentando executar com o comando “sudo”.

Se você quiser adicionar um usuário para ter acesso completo ao sudo, simplesmente adicione uma linha da seguinte maneira:

luizotavio    ALL=(ALL:ALL) ALL

E agora o usuário luizotavio poderá utilizar sua própria senha para obter acesso ao comando “sudo”, ou seja, executar comandos com o superusuário root.

Se você quiser ir um pouco além e especificar quais os comandos você deseja que o usuário execute, adicione o seguinte:

usuario ALL=(ALL:ALL) /usr/bin/apt-get, NOPASSWD:/sbin/ifconfig

No trecho acima, o usuário chamado “usuario” poderá executar o comando “apt-get” utilizando sua própria senha e o comando “ifconfig” (sem digitar nenhuma senha). Perceba que “NOPASSWD:” antes do comando, indica que o usuário pode executar aquele comando sem digitar senha nenhuma.

Vídeo tutorial

O vídeo tutorial abaixo detalha o que foi descrito acima.

Link do vídeo: https://www.youtube.com/watch?v=aTbEhjvlmxg

Concluindo

A parte de segurança do Linux é fascinante, tome algum temo para ler o manual do sudoers e entender melhor o que você pode fazer ali, essa é uma das partes mais críticas de um sistema que envolve mais de um usuário.

Até o próximo tutorial!

Clonar HDD ou SSD com o dd pode ser algo bastante simples, com apenas uma linha de comando você pode criar uma cópia idêntica do seu disco ou partição para uma imagem, gerando o backup perfeito.

Antes de continuar lendo este artigo, tenha em mente de que assim como qualquer linha de comando do Linux, o dd pode causar danos irrecuperáveis caso você faça algo de maneira incorreta, portanto, tenha certeza do que está fazendo antes de continuar. Além disso, tenha certeza de que o local onde você vai salvar a imagem de clone do seu disco é maior ou igual ao tamanho do disco a ser clonado, caso contrário não continue. Por fim (e por motivos óbvios), lembre-se que você deve salvar o clone em outro disco, nunca, em hipótese alguma, tente salvar a imagem de clone dentro do próprio disco que está sendo clonado.

Agora que eu já passei um pouco de medo em você, vamos aos exemplos.

Primeiramente, com o dd você pode clonar qualquer disco que quiser, independente do sistema operacionais, tipo de particionamento ou qualquer outra coisa. Isso acontece porque ele fará uma cópia block-by-block  (bloco-a-bloco), salvando tudo exatamente como está no seu disco em uma imagem.

Também é interessante que a partição que você está tentando clonar não esteja montada, ou seja, se você fizer isso utilizando um Live CD do Linux seria mais interessante. Porém, eu já fiz clones com o sistema rodando normalmente e não vi problemas nisso.

O que vou clonar?

Para descobrir a partição que deseja clonar, utilize o comando:

df -h

Ou:

sudo fdisk -l

Ambos os comando irão mostrar as partições do seu Linux, caberá a você saber qual o disco ou partição deseja clonar.

Para o caso de partições, normalmente você verá um número na frente, por exemplo:

Device     Boot     Start       End   Sectors  Size Id Type
/dev/sda1  *         2048    718847    716800  350M  7 HPFS/NTFS/exFAT
/dev/sda2          718848 121960447 121241600 57,8G  7 HPFS/NTFS/exFAT
/dev/sda3       121960448 122882047    921600  450M 27 Hidden NTFS WinRE
/dev/sda4       122884094 234440703 111556610 53,2G  5 Extended
/dev/sda5       122884096 229822463 106938368   51G 83 Linux
/dev/sda6       229824512 234440703   4616192  2,2G 82 Linux swap / Solaris

Como clonar HDD ou SSD com o dd

Perceba que existem números de 1 a 6 em minhas partições, cada uma delas contém algo diferente. Se eu quisesse clonar apenas uma dessas partições, utilizaria o seguinte comando:

sudo dd if=/dev/sda5 of=/media/outro-disco/clone.dd bs=512 conv=noerror,sync

Neste caso estou clonando a partição sda5 para uma imagem chamada clone.dd em um HD Externo.

Para clonar o disco inteiro, basta remover o número da partição, por exemplo:

sudo dd if=/dev/sda of=/media/outro-disco/clone.dd bs=512 conv=noerror,sync

Agora estou clonando todo o disco (no caso um SSD de 120GB) para o HD Externo.

Como restaurar um clone feito com dd

Para restaurar o clone, basta acessar o sistema com um Live CD (do Ubuntu, por exemplo) e inverter o comando. Por exemplo:

sudo dd if=/media/outro-disco/clone.dd of=/dev/sda bs=512 conv=noerror,sync

Mas lembre-se do seguinte, pode ser que o novo disco tenha um novo nome. Se você tentar restaurar o clone em outro disco ou outra partição, poderá danificar todo o sistema de arquivos do novo disco.

Aqui também vale o que eu disse anteriormente, verifique qual é o novo disco ou partição (tenha certeza absoluta) e tenha certeza de que há espaço suficiente para que o clone seja restaurado com sucesso.

Caso tenha alguma dúvida, não hesite em comentar.

Até o próximo!

Para adicionar número de linhas no Vi ou Vim simplesmente abra o editor e digite o comando :set nu  enquanto estiver no modo de comandos. Caso queira desativar, digite :set nonu e deixará de ver o número das linhas.

Número de linhas no vi

Número de linhas no vi

Caso queira também mostrar cor na sintaxe (conforme a imagem acima), digite o comando :syntax on . É um comando que recebe apenas “on” ou “off” para ligado e desligado respectivamente.

Provavelmente você vai querer que essas opções fiquem ativas assim que você entrar no vi ou vim, nesse caso crie ou edite o arquivo ~/.vimrc digitando:

vi ~/.vimrc

Adicione o seguinte neste arquivo:

set number 
syntax on

Salve o arquivo, feche o vi ou vim e pronto!

Em adição a este tutorial, veja como está o meu arquivo ~/.vimrc pessoal:

# Número de linhas
set number

# Cor de sintaxe
syntax on

# Correção de tabs
set tabstop=4
set shiftwidth=4
set expandtab
set softtabstop=4
set smarttab

Pra mim está perfeito para edição e facilidade de uso. Faça um teste e me informe o que achou.

Até o próximo!

A mágica do GNU/Linux muitas vezes acontece sem que você tenha sequer uma interface gráfica para uso amigável, porém, o shell (ou o terminal) também tem suas malícias para agilizar o seu trabalho.

Você pode trabalhar com várias aplicações ao mesmo tempo sem ter que terminar o que estava fazendo para iniciar uma nova tarefa, isso graças aos comandos “jobs”, “fg” e “bg”. “Jobs” significa “Trabalhos” e serve para exibir tudo o que você está fazendo no shell do GNU/Linux mas que está em segundo plano. Claro, você precisa mandar as tarefas para segundo plano para poder utilizar o comando “jobs”.

“fg” (foreground) serve para trazer as tarefas que estão em segundo plano para o primeiro plano, assim você pode continuar fazendo o que estava fazendo anteriormente.

Já a última opção, “bg” (background) serve para continuar executando tarefas em segundo plano, para que o shell fique livre e você possa executar outras tarefas sem interromper a tarefa anterior.

Vamos ver alguns exemplos práticos para que você entenda melhor.

Enviando um comando para segundo plano

Existem várias maneiras para enviar um comando para segundo plano, porém, a mais simples é colocando um & (E comercial) ao final do comando. Por exemplo:

find / -iname *.mp3 >> musicas.txt &

Você verá algo parecido com o trecho abaixo:

[email protected]:~$ find / -iname *.mp3 >> musicas.txt &
[1] 7193
[email protected]:~$ 

Aquele [1] significa que essa é a tarefa %1 que está sendo executada em segundo plano. O Número na frente é o PID do processo.

Outra maneira para enviar processos para segundo plano é pressionando “CTRL” + “Z” para que a tarefa seja parada momentaneamente. Em seguida, digite “bg”. Assim a tarefa será continuada, porém em segundo plano.

Manipulando várias tarefas em segundo plano

Também é possível enviar várias tarefas para segundo plano e trazer a que você desejar para o primeiro plano quando quiser. Vamos enviar duas tarefas para segundo plano e ver o que ocorre.

ping -q google.com.br &
nano texto &

A primeira está enviando um ping para o IP do Google, já a segundo abre um arquivo de texto chamado “texto” para que você possa digitar alguma coisa.

Neste momento, se você digitar “jobs”, verá o seguinte:

[email protected]:~$ jobs
[1]-  Executando              ping -q google.com.br &
[2]+  Parado                  nano texto
[email protected]:~$ 

Perceba que existem dois processos, um parado e outro executando. Isso ocorre porque alguns comandos (como o nano) não continuam a ser executados quando estão em background, e faz sentido, pois não a nada que o nano possa fazer quando você não está olhando para a tela. Perceba também que existe um sinal de – e + na frente do número do processo, isso simplesmente indica que o processo com sinal de + foi iniciado por último e ele será trazido para o primeiro plano caso você digite apenas “fg”. O processo com um sinal de menos apenas indica que ele foi iniciado antes do processo com sinal de +. Se você iniciar mais tarefas, a próxima terá um sinal de +, a que estava com sinal de + ficará com um sinal de – e a primeira tarefa iniciada não terá nenhum sinal.

Se você quiser trazer uma tarefa para primeiro plano, digite fg %N (onde N é o número do processo que deseja). Veja um exemplo, vou trazer o “ping” para primeiro plano:

[email protected]:~$ fg %1
ping -q google.com.br

Perceba que agora fiquei “preso” ao ping, pois, não tenho mais como digitar comandos. Para resolver isso, você pode parar temporariamente a aplicação pressionando as teclas “CTRL” + “Z” do seu teclado.

[email protected]:~$ fg %1
ping -q google.com.br
^Z
[1]+  Parado                  ping -q google.com.br
[email protected]:~$ 

E o shell está livre para que eu possa digitar novamente. O problema é que se você digitar “jobs” novamente, verá que a tarefa não está executando:

[email protected]:~$ jobs
[1]+  Parado                  ping -q google.com.br
[2]-  Parado                  nano texto
[email protected]:~$ 

Perceba que o status do “ping” mudou de “Executando” para “Parado”. Para solucionar, simplesmente utilize o comando “bg” para continuar executando a tarefa em segundo plano. Veja:

[email protected]:~$ bg %1
[1]+ ping -q google.com.br &
[email protected]:~$ 

Agora o shell continuar livre e se você analisar os “jobs” verá que o ping também está executando:

[email protected]:~$ jobs
[1]-  Executando              ping -q google.com.br &
[2]+  Parado                  nano texto
[email protected]:~$ 

Vamos à algumas dicas finais.

Dicas finais sobre tarefas de primeiro e segundo plano no Linux

Apesar de ser uma excelente função, trabalhar com tarefas em primeiro (fg) e segundo (bg) plano no Linux tem lá suas falhas, por exemplo, você vai se deparar com saídas de alguns comandos na tela, elas simplesmente aparecem do nada, principalmente os erros.

Isso acontece porque o shell não teria como lhe avisar caso acontecesse um erro em uma tarefa que estava sendo executada em segundo plano. Mas não se preocupe, nada do que é mostrado na tela atrapalha o seu serviço atual, se você estiver digitando um texto no nano, por exemplo, simplesmente pressione “CTRL” + “L” para limpar a tela e continue com seu serviço normalmente.

Só tome cuidado com comandos que cospem texto na tela do tempo todo, se eles estiverem em “bg” e mostrando textos na sua tela de “fg”, você terá que trazê-los para o primeiro plano novamente e depois encerrá-los.

Observação: Tarefas em segundo plano não respondem aos seus comandos.

Espero ter ajudado.

Se você tem um servidor Linux disponível na web, provavelmente deve ter acesso a ele por SSH (Secure Shell). Apesar de um método bastante seguro, se não configurado corretamente seu servidor pode ser alvo de ataques de brute force para acesso não autorizado. Existem várias maneiras para contornar essa situação, sendo uma das mais comuns é a técnica de proibir o acesso por senha, permitindo apenas chaves públicas.

Se o acesso por chave pública estiver ativo, será necessário realizar a combinação de uma chave no computador cliente e no servidor. Clientes só serão autenticados se a combinação das chaves for positiva. A autenticação será feita sem a necessidade de uma senha, mas você também poderá aumentar ainda mais a segurança da chave pública protegendo-a com uma senha, nesse caso será necessário digitar uma senha para destravar a chave, só então a combinação da chave cliente com a do servidor serão verificadas.

Neste tutorial vou detalhar como gerar uma chave pública em computadores cliente com Linux e Windows, porém, no Windows você irá precisar de um software chamado Putty.

Então vamos lá.

Gerando a chave no Linux

Se você tem um computador com Linux que faz acesso ao seu servidor remoto via SSH, acesse o terminal e digite o seguinte:

ssh-keygen -t rsa

Você será requisitado a escolher o arquivo onde a chave será gravada (normalmente em ~/.ssh/id_rsa) não precisa mudar isso se não quiser, simplesmente pressione “ENTER”.

Em seguida, será necessário digitar uma senha para a chave pública. Se quiser, poderá deixar a chave sem uma senha, neste caso o acesso ao servidor será direto, sem a necessidade de senha alguma (só do computador onde você está gerando a chave, é claro). Após escolher ou não digitar uma senha, você precisará confirmar digitando novamente a mesma (salvo se você tiver deixado uma senha em branco).

Feito isso está pronto, se quiser checar para saber se sua chave foi criada com sucesso, digite:

ls ~/.ssh

Você verá algo assim:

id_rsa  id_rsa.pub  known_hosts

Agora será necessário copiar a chave pública que você acabou de gerar para o servidor, para isso digite o seguinte:

ssh-copy-id [email protected]_do_host

Após digitar o comando acima, será necessário entrar com a senha do usuário escolhido para acesso no servidor remoto.

Observação: Você também poderá copiar a chave pública manualmente para o arquivo “~/.ssh/authorized_keys” da home do usuário desejado no servidor remoto (você vai ver como fazer isso mais adiante quando formos falar do Windows).

Após entrar com a chave pública no cliente e copiá-la no servidor (conforme descrito acima) seu acesso agora poderá ser baseado apenas na chave, com isso você poderá remover o acesso via senha do servidor para aumentar a segurança. Veremos mais sobre isso mais adiante neste tutorial quando formos configurar o arquivo /etc/ssh/sshd_config.

Gerando a chave com o Putty para Windows

Conforme descrevi, para configurar uma chave pública no Windows vamos precisar de um software que tenha suporte para isso, em minha opinião o melhor de todos é o Putty (para acesso ao servidor) e o Puttygen para gerar a chave. Faça o download do pacote no site putty.org. Observe que existe um arquivo compactado que trás todos os programas relacionados com o Putty de maneira portátil, ou como instalador.

Se você baixou a pasta compactada (.zip) extraia seu conteúdo, caso tenha utilizado o instalador, faça a instalação do Putty no seu Windows. De qualquer maneira que você tenha escolhido, deverá ver um programa chamado “Puttygen”, este é o programa que irá gerar a chave pública para seu Windows.

Abra o Puttygen e clique em “Generate”; Não pare de mexer o mouse até que a chave tenha sido criada.

Chave gerada com o Puttygen

Chave gerada com o Puttygen

Em “Key passphase” e “Confirm passphrase”, digite uma senha conforme preferir. Este campo também pode ser deixado em branco, mas você terá menos segurança caso o faça, pois não existirá nenhum senha para acesso ao seu servidor.

Quando terminar, você vai precisar da chave privada, já que ela servirá para você autenticar seu computador ao servidor quando precisar fazer o acesso. Portanto, clique em “Save private key” (já já vamos utiliza-la). Sem fechar a janela, copie o texto que está no quadrado “Key”, começando com “ssh-rsa”.

Essa é a chave que vamos colar dentro servidor remoto, no arquivo "autorized_keys"

Essa é a chave que vamos colar dentro servidor remoto, no arquivo “authorized_keys”

Agora utilize o Putty para abrir seu servidor:

Troque os dados pelos dados do seu servidor

Troque os dados pelos dados do seu servidor

Já dentro do seu servidor (com o usuário desejado), digite:

vi ~/.ssh/authorized_keys

Cole o texto que você copiou anteriormente na última linha (se não tiver nada nele, pode ser na primeira mesmo). Note que este arquivo pode não existir, mas o comando acima irá criá-lo.

Se você tiver dificuldades com o “vi”, troque por “nano” no comando, ficando assim:

nano ~/.ssh/authorized_keys

Nano é um editor de texto mais simples para ser utilizado.

Após a inclusão da chave, salve o arquivo e volte para o seu computador cliente com o Windows.

Para realizar o acesso, abra a chave privada que você achou com o programa “PAGEANT.EXE” (também pertence ao pacote do Putty). Quando você abrir a chave, o programa irá requisitar que você digite a senha que escolheu quando a gerou, digite-a corretamente e verá o seguinte símbolo perto do relógio do Windows.

Ícone do Putty Agent indicando que você pode acessar seu servidor

Ícone do Putty Agent indicando que você pode acessar seu servidor

Agora é só voltar ao Putty e acessar seu servidor normalmente.

Configurando o arquivo /etc/ssh/sshd_config

Agora que você já tem a chave de segurança pública e já realizou o teste para acesso ao servidor sem ter a necessidade de digitar uma senha, vamos remover essa opção para que ele se torne mais seguro.

Atenção: Não continue se não conseguiu criar e testar a chave pública com sucesso em pelo menos um sistema operacional, caso contrário você ficará sem acesso SSH no seu servidor.

Digite o seguinte dentro do servidor remoto:

sudo nano /etc/ssh/sshd_config

Já dentro do arquivo de configuração, edite as linhas indicadas abaixo:

# ...
PermitRootLogin no
# ...
PubkeyAuthentication yes
# ...
PasswordAuthentication no
# ...

A primeira linha remove completamente o acesso do root ao servidor SSH, a segunda permite o acesso via chave pública e a terceira remove o acesso via senhas de texto. Pense bem antes de seguir a diante, isso é uma medida de segurança, caso algo dê errado, não terá como voltar atrás.

Pressione CTRL+O para salvar e digite:

sudo service ssh restart

Para reiniciar o servidor SSH. Por fim, digite:

exit

Para sair e tente refazer o acesso. Se tudo correu conforme descrevi, você conseguirá acessar o servidor sem a necessidade de digitar a senha do usuário, utilizando apenas a chave pública.

Lembre-se que essa chave agora é como se fosse a sua senha, portanto, não deixe qualquer um acessar seu computador ou copiá-la.

Finalizando

Este foi um tutorial relativamente simples, mas pode ser que gere dúvidas para muitos usuários. Caso as tenha, não hesite em deixar nos comentário.

Até o próximo.

Quando temos uma interface gráfica à disposição, compactar / descompactar arquivos pode ser algo bastante simples, mas não se engane e imagine que fazer isso naquela tela de um servidor Linux sem interface gráfica seja mais complicado. Na verdade, fazer a compactação e descompactação de arquivos por linha de comando pode ser bem mais simples e eficiente.

Nesse tutorial vou passar vários comandos para compactar / descompactar arquivos no Linux utilizando um terminal ou o acesso direto ao shell do sistema. Vamos trabalhar com a maioria dos formatos mais utilizados, como tar, tar.gz, tar.bz2, zip e rar, além disso, vou passar as partes mais utilizadas, como: compactar / descompactar pastas e arquivos separadamente, listar / testar, compactar / descompactar utilizando uma senha e assim por diante.

Algumas coisas você precisará decorar, mas lhe garanto que se você fizer a compactação e descompactação algumas vezes, não irá mais esquecer os comandos.

Então vamos lá!

Compactar / Descompactar arquivos no Linux usando o terminal

Observe que estou utilizando o Debian 8 para a criação desse tutorial, mas a maioria dos comandos descritos irão funcionar em todas as distros do Linux. De fato, a única coisa que será diferente, vai ser o modo como você instala os aplicativos necessários para ZIP ou RAR.

Juntar / separar arquivos .tar

Este é um dos métodos mais rápidos para juntar vários arquivos dentro de um único container, porém, sem compressão. Portanto, se você quer apenas guardar todos os arquivos dentro de um único arquivo e salvar tempo, siga os passos abaixo:

juntar                  tar -cvf unico.tar pasta/
separa                  tar -xvf unico.tar
listar                  tar -tvf unico.tar
Juntar separadamente    tar -cvf unico.tar arquivo1 arquivo2 arquivo3
Separar p/ pasta        tar -xvf unico.tar -C caminho/da/pasta/

Lembre-se do seguinte, o “-c” significa “criar”, porque você está pegando uma pasta ou vários arquivos e jogando dentro de um único pacote. Quando você for separar tais arquivos ou pastas, irá utilizar “-x” (essa é a única diferença entre juntar e separar arquivos).

Por exemplo, se eu quiser separar (descompactar) vários arquivos, simplesmente digito:

tar -xvf arquivos.tar

A estrutura dos arquivos separados será a mesma de quando você os juntou, ou seja, se for uma pasta, a saída também será uma pasta; se forem vários arquivos separados, a saída serão vários arquivos separados.

Nos próximos exemplos vamos adicionar dois métodos de compressão, ou gzip (.gz) ou bzip2 (.bz2). Cada qual com seus pontos fortes e fracos.

Compactar e descompactar arquivos .tar.gz

Este é o método de compactação gzip (.gz), não consome tanto processamento e tem um fator de compressão muito bom. Para compactar / descompactar arquivos .tar.gz siga as instruções abaixo:

compactar             tar -zcvf compactada.tar.gz pasta/
descompactar          tar -zxvf compactada.tar.gz
listar                tar -ztvf compactada.tar.gz
comp. separadamente   tar -zcvf compactada.tar.gz pasta/arquivos-{1,2}.txt outra-coisa/
Desc. p/ pasta        tar -zxvf compactada.tar.gz -C caminho/da/pasta/

Apenas adicione um “-z” no comando e a extensão .gz, já estará comprimindo os arquivos.

Compactar e descompactar arquivos .tar.bz2

Este é o bzip2, apesar de utilizar mais recursos do computador, tem um fato de compressão excelente. Para compactar / descompactar arquivos .tar.bz2 siga as instruções abaixo:

compactar             tar -jcvf compactada.tar.bz2 pasta/
descompactar          tar -jxvf compactada.tar.bz2
listar                tar -jtvf compactada.tar.bz2
comp. separadamente   tar -jcvf compactada.tar.bz2 pasta/arquivo-{1,2}.txt
Desc. p/ pasta        tar -jxvf compactada.tar.bz2 -C caminho/

Troque o “z” por um “j” e já estará utilizando bzip2. Não se esqueça de adicionar a extensão .bz2.

Compactar e descompactar arquivos .zip

ZIP é um formato bastante conhecido por usuários Windows, tanto que você pode compactar e descompactar pastas no sistema da Microsoft sem instalar nada caso tal arquivo esteja no formato .zip.

Muitas versões do Linux já trazem o zip e unzip instalados, mas caso precise instalar manualmente, utilize o gerenciador de pacotes da seguinte maneira:

sudo apt-get install zip unzip

O comando acima serve para Debian, Ubuntu, Linux Mint e outras versões baseadas em Debian, utilize o gerenciador de pacotes da sua distro não esteja utilizando Debian.

Para compactar e descompactar arquivos .zip, siga as instruções abaixo:

compactar             zip -r compactada.zip pasta/
descompactar          unzip compactada.zip
listar                unzip -l compactada.zip
comp. separadamente   zip compactada.zip pasta/arquivo-{1,2,3}.txt
Desc. p/ pasta        unzip compactada.zip -d caminho/
compactar c/ senha    zip -P senha -r compactada.zip pasta/

Bem simples, não?

Compactar e descompactar arquivos .rar

Se você estiver lidando com o formato “RAR”, é praticamente certeza de que este pacote veio de um Windão da vida. De qualquer maneira, existe a possibilidade de utilizar “rar” e “unrar” no Linux também. Mas será necessário instalar esses pacotes.

Para realizar a instalação no Debian, digite o seguinte:

sudo apt-get install rar unrar

Utilize o gerenciador de pacotes de sua distro, caso não utilize Debian.

Para utilizar rar e unrar, siga os passos abaixo:

compactar               rar a compactada.rar pasta/
descompactar            unrar x compactada.rar
listar                  unrar l compactada.rar
comp. separadamente     rar a compactada.rar pasta/arquivo-{1,2,3}.txt
Desc. p/ pasta          unrar x compactada.rar caminho/
compactar c/ senha      rar a compactada.rar pasta/ -p

Tudo simples assim!

Vídeo tutorial

O vídeo tutorial abaixo é um complemento ao texto acima:

Link do vídeo: https://www.youtube.com/watch?v=vIQrGhW3Ee0

Espero que tenha gostado!

Encontrar arquivos no Linux com o find é, sem sombra de dúvidas, a maneira mais simples e útil para quem precisa procurar coisas dentre milhares de arquivos e pastas diferentes. Além de realizar pesquisas simples, find pode ser bastante complexo em alguns casos, para que você possa encontrar algo bastante específico.

Find não faz apenas pesquisas, este comando pode até mesmo executar outros comandos com os arquivos encontrados, como apagar, renomear, listar permissões ou qualquer tipo de comando que você possa desejar executar em todos os arquivos encontrados.

Lembra daquela foto que você estava procurando e nunca encontrou por causa da bagunça das pastas antigas do seu PC? Find encontra pra você! Lembra aquela música que você só sabe o nome do cantor mas não lembra o nome do arquivo? Find encontra pra você também. Você só vai precisar indicar algumas coisas simples e, dependendo da sua criatividade, find irá fazer todo o trabalho duro que seria necessário para encontrar o que você estava procurando.

Observação: Este artigo trará apenas alguns exemplos sobre a utilização do find, porém, caso não encontre o que deseja, digite o seguinte dentro do terminal do Linux:

man find

E verá um manual completo sobre o comando. Então vamos ao que interessa, que é a procura de arquivos e pastas!

Listando todos os arquivos de um diretório

Se você quiser exibir todos os arquivos de um diretório, acesso o mesmo via terminal e digite somente o comando “find”:

find

Você verá todos os arquivos, incluindo arquivos ocultos que estão presentes no diretório.

Caso a lista seja muito grande e você precise percorrer todos os arquivos encontrados, digite:

find | less

Pressione qualquer tecla para passar linha por linha, ou espaço para pular de página. Quando terminar, pressione “q” para sair.

Se precisar listar todos os arquivos dentro de outro diretório, digite:

find /caminho/do/diretorio/

Utilize ” | less” conforme descrito anteriormente para listar todos os arquivos de maneira que você possa navegar por eles.

Encontrar arquivos específicos

Se você precisa encontrar um arquivo específico dentro de um diretório qualquer, digite:

find /caminho/do/diretorio/ -name "nome-do-arquivo.extensao"

O comando “find” diferencia letras maiúsculas e minúsculas, portanto, caso não queira este comportamento, digite:

find /caminho/do/diretorio/ -iname "nome-do-arquivo.extensao"

Agora o comando deverá encontrar tanto arquivos com letras maiúsculas quanto com letras minúsculas que contenham a expressão indicada.

Utilizando metacaracteres

O comando find também suporta metacaracteres, que formam uma espécie de expressão regular caso você não saiba especificamente o nome do arquivo que deseja. Por exemplo, suponhamos que você queira encontrar todas as fotos com extensão .jpg ou .JPG dentro de um diretório. Para isso digite:

find /diretorio/ -iname "*.jpg"

Perceba que o metacaractere “*” (asterisco) significa “qualquer coisa”. Você também pode utilizar o metacaractere “?” (interrogação) para representar um único caractere, veja:

find /diretorio/ -iname "???2015*.jp?"

No trecho acima, find irá encontrar aquivos que contenham qualquer caractere no lugar dos metacaracteres “?”, o número 2015, qualquer coisa depois de 2015, .jp qualquer caractere.

Listagem invertida

Pode ser que você queira fazer uma pesquisa apenas excluindo algo que você não queira, por exemplo, todos menos os que contém o número 2015, veja:

find /diretorio/ ! -iname "*2015*"

O “!” (exclamação), significa “não”. Ele pode ser substituído por “-not” e você terá o mesmo resultado.

Combinando valores

Você também pode combinar valores com “AND” e “OR” (não especificamente utilizando essas palavras). Para utilizar find com “AND”, ou seja, arquivos que contenham um valor “E” outro valor, simplesmente digite:

find /diretorio/ -iname "valor1*" -iname "*valor2*"

Agora somente arquivos que contenham ambos os valores serão encontrados.

Caso queira encontrar arquivos que contenham um valor “OU” (OR) outro valor, digite:

find /diretorio/ -iname "*valor1*" -o -iname "*valor2*"

Agora serão encontrados arquivos com ambos os valores. Note que com “OR” não é necessário que os dois valores estejam presentes no nome do mesmo arquivo.

Diretórios ou arquivos?

Com o find você também pode especificar se deseja encontrar apenas diretórios (pastas) ou apenas arquivos (files), veja:

# Apenas arquivos
find /diretorio/ -iname "valor*" -type f

# Apenas pastas
find /diretorio/ -iname "valor*" -type d

Para pesquisar em várias pastas de uma vez, digite:

find /diretorio1/ /diretorio2/ -iname "valor*"

Encontrando arquivos por permissão

Se você quiser ver arquivos que têm determinada combinação de permissões, digite:

find /diretorio/ -perm 0777

Você pode pesquisar qualquer combinação de permissões que desejar, conforme o chmod. Como exemplo, você poderia procurar por arquivos executáveis com:

find /bin -perm /a=x

Procurar arquivos de usuários e grupos

Quer encontrar arquivos de um usuário ou grupo específico? Digite:

find /diretorio/ -user usuario -group grupo

Você pode utilizar ambas as opções separadamente.

Procurar arquivos baseando-se em tempo

Caso queira encontrar arquivos baseando-se em tempo, siga os exemplos abaixo:

# Encontra arquivos alterados 10 dias atrás 
find / -mtime 10

# Encontra arquivos acessados 10 dias atrás
find / -atime 10

# Para um range, digite
find / -mtime +10 -mtime -10

Procure arquivos por tamanho

Para encontrar arquivos de 50MB, digite:

find / -size 50M

Maiores que 50M:

find / -size +50M

Menores que 50M:

find / -size -50M

Entre 50M e 100M:

find / -size +50M -size -100M

Executando comandos nos arquivos encontrados

Com o “find” você também pode executar comandos nos arquivos encontrados, para isso simplesmente digite:

find / -name "arquivo*" -exec ls -l {} \;

Perceba que o {} significa o caminho do arquivo, e o que vem após “-exec” é o comando a ser executado. Por exemplo, para copiar arquivos, digite:

find /diretorio/ -iname "*arquivo*" -exec cp {} /destino/ \;

Executando como super user

Se você quiser pesquisar pastas das quais você não tem permissões, utilize “sudo”, exemplo:

sudo find / "*.jpg"

Simples assim!

Vídeo tutorial

O vídeo abaixo é um complemento do texto acima:

Link do vídeo: https://youtu.be/VPiNq0jda7Y

Você sabe o que são e para que servem as variáveis de ambiente no Linux? Se não, vou detalhar de maneira bem simples para que você compreenda melhor. Se você já sabe, lembre-se que conhecimento nunca é demais!

De modo geral, variáveis (em linguagens de programação) são espaços de memória que armazenam valores. Esses valores podem conter vários tipos de dados, que vão depender da linguagem que você está utilizando.

No Linux também podemos utilizar variáveis, chamadas de variáveis de ambiente, diretamente no shell. Elas podem conter valores que podem então ser utilizados por aplicações ou para seu próprio benefício.

Você pode criar suas próprias variáveis de ambiente ou utilizar as que já existem no sistema. Além disso, você pode criar variáveis temporárias, apenas para utilização em determinado shell, sem salvar nada permanentemente e/ou afetar o funcionamento normal do sistema.

Se você precisa ver agora mesmo quais variáveis de ambiente estão definidas no seu computador, simplesmente utilize um dos comandos abaixo.

  • set – Exibe basicamente tudo o que está definido para o ambiente em que você está. Por exemplo, se você definir uma variável de ambiente local, ela será exibida apenas no shell em que você a definiu. Também exibe variáveis globais e funções. Para facilitar a visualização, é comum utilizarmos “set | grep NOME_DA_VARIAVEL”.
  • env – Exibe todas as variáveis de ambiente globais, ou seja, as variáveis de ambiente definidas para todo o ambiente do sistema e que podem ser utilizadas em qualquer aplicação ou shell. “env” também exibe variáveis locais de ambiente locais que foram exportadas com o comando “export”.

Observação: Perceba que não estamos falando em funções aqui, o conceito de variável local e global descrito aqui é para indicar que uma variável está disponível apenas no shell em que ela foi criada (local) ou para todo o sistema como um todo (global).

Criando variáveis de ambiente no Linux

Para criar uma variável de ambiente, digite o seguinte:

export VARIAVEL="VALOR"

Perceba que a palavra “export” é exatamente o que torna a variável criada, uma variável de ambiente. Você pode utilizar uma variável de ambiente da seguinte maneira:

echo $VARIAVEL

O comando “echo” exibe o valor da variável.

Veja um exemplo onde uma variável de ambiente é bastante útil:

~$ export UTIL="/media/luizotavio/Externo/hd_antigo/Backup/Utilitarios/" 
~$ cd $UTIL
/media/luizotavio/Externo/hd_antigo/Backup/Utilitarios$

Perceba que no comando acima, defini o valor da variável “UTIL” como um caminho bastante longo. Tal caminho agora pode ser acessado utilizando apenas o valor de $UTIL, que neste caso é “/media/luizotavio/Externo/hd_antigo/Backup/Utilitarios/”.

Visualizando variáveis de ambiente no Linux

Se você quiser saber se uma variável de ambiente está disponíveis no seu Linux, simplesmente digite:

env | grep UTIL

Neste caso estou buscando pela variável “UTIL” dentro das variáveis de ambiente do meu Linux, como eu havia definido essa variável anteriormente e ainda não fechei o terminal, o valor obtido será:

$ env | grep UTIL
UTIL=/media/luizotavio/Externo/hd_antigo/Backup/Utilitarios/
$ 

Se eu fechar o terminal, essa variável de ambiente deixará de existir e eu terei que criá-la novamente. Isso caracteriza uma variável de ambiente local, pois ela pertence apenas ao shell que a criou e não afeta o sistema como um todo, nem poderá ser utilizada por outro shell.

Tornando variáveis de ambiente permanentes

Existem vários locais onde você pode salvar suas variáveis de ambiente para torná-las permanentes, cada um afeta algo diferente. Por exemplo, se você pretende que todos os usuários do sistema também tenham acesso à variável de ambiente que vai criar, edite o seguinte arquivo:

sudo nano /etc/bash.bashrc

Se quiser que criar uma variável de ambiente apenas para você, edite o arquivo:

nano .bashrc

O arquivo .bashrc fica na sua $HOME e também funciona com aliás e outras coisas relacionadas ao bash.

Vídeo tutorial

O vídeo tutorial abaixo descreve o mesmo que o artigo acima:

Link do vídeo: https://www.youtube.com/watch?v=i2VKOyf0PmU

Espero que tenha gostado.

Alias para comandos no terminal do Linux são uma espécie de atalho ou apelido que você da para comandos maiores afim de agilizar a utilização do terminal. Isso pode ser muito útil para aqueles que matem servidores ou que costumam digitar comandos grandes sem uma interface gráfica.

O histórico do terminal juntamente com o complemento de comandos apenas pressionando a tecla “TAB” já ajudam bastante, porém, nada mais conveniente do que trocar dez palavras complicadas de comandos por apenas uma palavra que já é de seu conhecimento e que é simples para ser lembrada.

Por exemplo, usuários de várias distros do Linux costumam digitar comandos para atualizar pacotes do sistema com apt-get, dnf/yum ou pacman. Apesar de comandos pequenos, algumas vezes é preciso utilizar mais de um comando e apenas uma linha, por exemplo:

sudo apt-get update && sudo apt-get upgrade

Você poderia utilizar um alias chamado de “atualiza” para resumir tudo o que foi escrito acima. Vamos ver como.

Criando um alias temporário no terminal do Linux

Para criar um alias temporário, simplesmente digite:

alias atualiza='sudo apt-get update && sudo apt-get upgrade'

Agora toda vez que você digitar a palavra “atualiza”, o comando descrito acima será executado e os pacotes necessários serão atualizados.

Um problema com o alias acima é que ele não será permanente, assim que você fechar o terminal, o mesmo deixará de existir. Vamos ver como criar aliases permanentes.

Criando aliases permanentes

Para criar um alias permanente, podemos editar tanto o arquivo “.bashrc” quanto criar um arquivo específico chamado de “.bash_aliases” (que é o mais recomendado). Ambos os arquivos estão presentes na nosso “home” do sistema.

Vamos criar o mesmo alias descrito anteriormente, porém dessa vez vamos torna-lo permanente.

echo "alias atualiza='sudo apt-get update && sudo apt-get upgrade'" >> $HOME/.bash_aliases
bash

Pronto, agora este arquivo é permanente e sempre que você digitar “atualiza”, o comando acima será executado.

Caso tenha digitado algo de maneira incorreta, você pode utilizar o nano para editar o arquivo .bash_aliases. Veja:

nano .bash_aliases

Edite conforme precisar, pressione “CTRL” + “O” para salvar, “CTRL” + “X” para sair. Se preferir adicionar mais aliases utilizando o próprio nano, simplesmente vá adicionando quantos aliases quiser, linha por linha no arquivo .bash_aliases.

Exemplo:

Mais de um alias criado

Mais de um alias criado

Sempre que você adicionar um alias, digite “bash” para que ele entre em ação sem que você precise fechar nada.

Vídeo tutorial

Link do vídeo: http://youtu.be/cvsHuAHtWBQ