Linux - freeCodeCamp.org

Como instalar o Ubuntu no VirtualBox

Daniel Rosa — Fri, 27 Sep 2024 11:37:37 +0000

Artigo original: How to install Ubuntu on VirtualBox

Escrito por: Thanoshan MV

O que é o VirtualBox?

A máquina virtual (VM) VirtualBox da Oracle é uma aplicação de virtualização multiplataforma desenvolvida pela Oracle Corporation. Ela permite aos usuários instalar sistemas operacionais, como Windows, macOS, Solaris e Linux, em discos rígidos virtuais.

Como exemplo, você pode rodar Windows e Linux em seu Mac, rodar um servidor Windows em seu servidor Linux ou rodar o Linux em seu PC com Windows enquanto executa suas outras aplicações existentes.

Espaço em disco e memória são os únicos problemas que você enfrentará ao instalar várias máquinas virtuais.

Por que você vai precisar dele

O VirtualBox da Oracle é fácil de instalar e usar
É grátis
Você pode rodar e experimentar qualquer sistema operacional de maneira segura
Se você é um desenvolvedor, o VirtualBox pode ser usado como uma ferramenta para testar seus próprios projetos de desenvolvimento em diversos ambientes de SO de maneira segura
Ele pode rodar desde pequenos sistemas embarcados até laptops
É bom para testes e recuperação de desastres, pois pode ser facilmente copiado, e transportado entre hosts, além de ser fácil de fazer o back-up dele

Instalação do VirtualBox

O VirtualBox pode ser baixado aqui: downloads do VirtualBox

Por que o Ubuntu?

É grátis
Personalização fácil: o ambiente de desktop GNOME ajuda você a personalizar facilmente
É seguro
O Ubuntu é open-source
Tem uma comunidade amigável e que dá muito suporte
Requisitos de sistema baixos
De acordo com a FOSSBYTES (edição de 2019), o Ubuntu é a segunda melhor distro do Linux para programação e desenvolvedores
É amigável para iniciantes

Configuração do Ubuntu

Primeiro, abra o VirtualBox, depois clique em "New" (Novo, em português) para criar uma máquina virtual.

Digite "Ubuntu" como nome, selecione "Linux" como tipo e selecione Ubuntu (64-bit) como versão.

Observação: selecione a quantidade de memória que desejar, mas não adicione mais que 50% da sua RAM total.

Marque a opção "Create a virtual hard disk now" (Criar um disco rígido virtual agora, em português) para que possamos definir mais tarde o tamanho do disco rígido virtual do Ubuntu OS.

Agora, selecionamos "VHD (Virtual Hard Disk)" (Disco rígido virtual, em português).

Em seguida, vamos alocar dinamicamente o armazenamento em nosso disco rígido físico.

Queremos especificar o tamanho do Ubuntu OS. O tamanho recomendado é, pelo menos, 10 GB, mas você pode aumentar se desejar.

Depois de criar um disco rígido virtual, você verá o Ubuntu no seu painel.

Agora, precisamos configurar o arquivo de imagem de disco do Ubuntu (.iso).

O arquivo de imagem de disco do Ubuntu pode ser baixado aqui: download do Ubuntu

Para configurar o arquivo de imagem de disco do Ubuntu, vá em Settings e siga estes passos:

Clique em "Storage" (Armazenamento, em português)
Em Storage Devices (Dispositivos de armazenamento, em português), clique em "Empty" (Vazio, em português)
Em Attributes (Atributos, em português), clique na figura do disco e "Select Virtual Optical Drive File" (Selecionar arquivo de disco óptico virtual, em português)
Selecione o arquivo de imagem de disco do Ubuntu e abra-o

Clique em OK.

Seu Ubuntu está pronto para ser instalado no VirtualBox. Vamos começar!

Observação: a instalação do Ubuntu no VirtualBox e a instalação real do sistema operacional podem variar. Este guia ajuda você a instalar o Ubuntu no VirtualBox apenas.

Vamos instalar o Ubuntu!

Clique em Install Ubuntu (Instalar o Ubuntu, em português).

Selecione seu layout de teclado.

Na seção "Updates and other software" (Atualizações e software de terceiros, em português), marque "Normal installation" (Instalação normal, em português) e clique em Continue.

Em "Installation type" (Tipo de instalação, em português), marque "Erase disk and install Ubuntu" (Apagar o disco e instalar o Ubuntu, em português).

Clique em "Continue".

Escolha sua localização atual.

Agora, configure seu perfil.

Você verá o Ubuntu sendo instalado.

Após a instalação, reinicie.

Após fazer login, você verá a área de trabalho do Ubuntu.

Instalamos com sucesso o Ubuntu no VirtualBox. Ele está pronto para uso em seus futuros projetos de desenvolvimento.

Vamos verificar a instalação

Abra o seu terminal (Pressione Ctrl+Alt+T) e digite os comandos abaixo para verificar se funcionam.

pwd: este comando imprimirá o diretório de trabalho atual
ls: este comando listará todos os itens no seu diretório atual

Depois de verificar esses comandos, desligue a sua máquina usando o seguinte comando.

poweroff

Conclusão

O VirtualBox é gratuito e uma ótima ferramenta para executar vários sistemas operacionais em um único sistema operacional. O Ubuntu tem muitos benefícios. Se você é um iniciante em Linux, eu recomendaria usar o Ubuntu, pois é amigável para iniciantes.

Sinta-se à vontade para entrar em contato com o autor se tiver alguma pergunta. Você pode contatar o autor e se conectar com ele pelo X e pelo Medium.

Agradecemos pela leitura.

Boa programação para você!

O manual de comandos do Linux – aprenda comandos do Linux para iniciantes

Sabrina — Wed, 26 Jun 2024 21:00:00 +0000

Artigo original: The Linux Command Handbook – Learn Linux Commands for Beginners

Este manual de comandos do Linux apresentará os 60 comandos principais que você precisará como desenvolvedor. Cada comando inclui código de exemplo e dicas sobre quando usá-lo.

Este Manual de Comando do Linux segue a regra 80/20: você aprenderá 80% de um tópico em cerca de 20% do tempo gasto estudando-o.

Acho que essa abordagem oferece uma visão geral completa.

Este manual não tenta cobrir tudo relacionado ao Linux e seus comandos. Ele se concentra nos pequenos comandos principais que você usará 80% ou 90% do tempo e tenta simplificar o uso dos mais complexos.

Todos esses comandos funcionam em Linux, macOS, WSL e em qualquer lugar onde você tenha um ambiente UNIX.

Espero que o conteúdo deste manual o ajude a alcançar o que deseja: familiarizar-se com o Linux.

Você pode marcar esta página em seu navegador para poder consultar este manual no futuro.

Você pode fazer o download deste manual em PDF/ePUB/Mobi gratuitamente.

Aproveite!

Índice

Introdução ao Linux e shells

O que é Linux?

Linux é um sistema operacional, como o macOS ou Windows.

É também o sistema operacional de código aberto mais popular, oferecendo muita liberdade.

Ele alimenta a grande maioria dos servidores que compõem a Internet. É a base sobre a qual tudo é construído, mas não apenas isso. O Android é baseado em (uma versão modificada do) Linux.

O "núcleo" do Linux (chamado de kernel) nasceu em 1991 na Finlândia e percorreu um longo caminho desde seu início humilde. Passou a ser o kernel do Sistema Operacional GNU, criando a dupla GNU/Linux.

Há uma coisa no Linux que empresas como Microsoft, Apple e Google nunca poderão oferecer: a liberdade de fazer o que quiser com seu computador.

Na verdade, elas estão indo na direção oposta, construindo jardins murados, especialmente no lado dos dispositivos móveis.

Linux é a liberdade definitiva.

É desenvolvido por voluntários, alguns pagos por empresas que dependem dele, outros de maneira independente. Não existe, porém, uma única empresa comercial que possa ditar o que acontece no Linux ou as prioridades do projeto.

Você também pode usar o Linux como seu computador diário. Eu uso o macOS porque gosto muito das aplicações e do design (e também fui desenvolvedor de aplicações para iOS e Mac). Antes de usar o macOS, no entanto, eu usei o Linux como sistema operacional principal do meu computador.

Ninguém pode ditar quais aplicações você pode executar ou "ligar para casa" com aplicações que rastreiam você, sua posição e muito mais.

O Linux também é especial porque não existe apenas "um Linux", como é o caso do Windows ou do macOS. Em vez disso, temos distribuições.

Uma "distro" é feita por uma empresa ou organização e empacota o núcleo do Linux com programas e ferramentas adicionais.

Por exemplo, você tem o Debian, o Red Hat e o Ubuntu, provavelmente as distribuições mais populares.

Existem, porém, muitas, muitas mais. Você também pode criar sua própria distribuição, mas, provavelmente, usará uma popular que tenha muitos usuários e uma comunidade de pessoas ao seu redor. Isso permite que você faça o que precisa sem perder muito tempo reinventando a roda e descobrindo respostas para problemas comuns.

Alguns computadores desktop e laptops vêm com Linux pré-instalado. Você também pode instalá-lo em seu computador Windows ou Mac.

Você, no entanto, não precisa interromper seu computador existente apenas para ter uma ideia de como o Linux funciona.

Eu não tenho um computador Linux.

Se você usa um Mac, você só precisa saber que o macOS é um sistema operacional UNIX. Ele compartilha muitas das mesmas ideias e software que um sistema GNU/Linux usa, porque GNU/Linux é uma alternativa gratuita ao UNIX.

UNIX é um termo genérico que agrupa muitos sistemas operacionais usados em grandes corporações e instituições, a partir da década de 1970

O terminal do macOS dá acesso exatamente aos mesmos comandos que descreverei no restante deste manual.

A Microsoft tem um subsistema oficial do Windows para Linux que você pode (e deve!) instalar no Windows. Isso dará a você a capacidade de executar o Linux de uma maneira muito fácil em seu PC.

Na grande maioria das vezes, porém, você executará um computador Linux na nuvem por meio de um VPS (Virtual Private Server) como o DigitalOcean.

O que é um shell Linux?

Um shell é um interpretador de comandos que expõe uma interface para o usuário trabalhar com o sistema operacional subjacente.

Ele permite executar operações usando texto e comandos e fornece aos usuários recursos avançados, como a capacidade de criar scripts.

Isso é importante: os shells permitem que você execute as coisas de uma maneira mais otimizada do que uma GUI (Interface Gráfica do Usuário) poderia permitir. As ferramentas de linha de comando podem oferecer muitas opções de configuração diferentes sem serem muito complexas de usar.

Existem muitos tipos diferentes de shells. Este artigo se concentra em shells Unix, aqueles que você encontrará comumente em computadores Linux e macOS.

Muitos tipos diferentes de shells foram criados para esses sistemas ao longo do tempo. Alguns deles dominam o espaço: Bash, Csh, Zsh, Fish e muitos mais!

Todas os shells são originários de Bourne Shell, chamada sh. "Bourne" porque seu criador foi Steve Bourne.

Bash significa Bourne-again shell. O sh era proprietário e não de código aberto, e o Bash foi criado em 1989 para criar uma alternativa livre para o projeto GNU e a Free Software Foundation. Como os projetos tinham que pagar para usar o shell Bourne, o Bash se tornou muito popular.

Se você usa um Mac, tente abrir o terminal Mac. Por padrão, ele executa ZSH (ou, pré-Catalina, o Bash).

Você pode configurar seu sistema para executar qualquer tipo de shell – por exemplo, eu uso o shell Fish.

Cada shell tem seus próprios recursos exclusivos e uso avançado, mas todos compartilham uma funcionalidade comum: permitem executar programas e podem ser programados.

No restante deste manual, veremos em detalhes os comandos mais comuns que você utilizará.

O comando `man` no Linux

‌‌O primeiro comando que apresentarei ajudará você a entender todos os outros comandos.

Toda vez que não sei como usar um comando, digito man para obter o manual:

Esta é uma página man (de manual). As páginas de manual são uma ferramenta essencial para aprender como desenvolvedor. Elas contêm tanta informação que, às vezes, é quase demais. A captura de tela acima é apenas uma das 14 telas de explicação do comando ls .

Na maioria das vezes, quando preciso aprender um comando rapidamente, uso este site chamado páginas tldr: https://tldr.sh. É um comando que você pode instalar e executar assim: tldr . Ele fornece uma visão geral muito rápida de um comando, com alguns exemplos úteis de cenários de uso comuns:

Ele não é um substituto para o man, mas uma ferramenta útil para evitar de se perder na enorme quantidade de informações presentes em uma página man. Em seguida, você pode usar a página man para explorar todas as diferentes opções e parâmetros que você pode usar em um comando.

O comando `ls` no Linux

Dentro de uma pasta você pode listar todos os arquivos que a pasta contém usando o comando ls :

ls

‌Se você adicionar um nome ou caminho de pasta, o conteúdo dessa pasta será impresso:

ls /bin

O ls aceita muitas opções. Uma das minhas combinações favoritas é a -al. Tente:

ls -al /bin

Comparado ao comando ls simples, ele retorna muito mais informações.

Você tem, da esquerda para a direita:

as permissões de arquivo (e se o seu sistema suportar ACLs, você também receberá um sinalizador de ACL)
o número de links para esse arquivo
o dono do arquivo
o grupo do arquivo
o tamanho do arquivo em bytes
a data e hora da última modificação do arquivo
o nome do arquivo

Esse conjunto de dados é gerado pela opção l. A opção a também mostra os arquivos ocultos.

Arquivos ocultos são arquivos que começam com um ponto (.).

O comando `cd` no Linux

Depois de ter uma pasta, você pode movê-la usando o comando cd. cd significa alterar diretório (do inglês, change directory). Você o invoca especificando uma pasta para a qual mover. Você pode especificar um nome de pasta ou um caminho completo.

Exemplo:

mkdir fruits
cd fruits

‌ Agora, você está na pasta fruits.

Você pode usar o caminho especial .. para indicar a pasta pai:

cd .. #retorno à pasta pai

O caractere # indica o início do comentário, que dura toda a linha após ser encontrado.

Você pode usar o comando cd junto do caminho especial para formar um caminho:

mkdir fruits
mkdir cars
cd fruits
cd ../cars

Existe outro indicador de caminho especial, que é o ., que indica a pasta atual.

Você também pode usar caminhos absolutos, que começam na pasta raiz /:

cd /etc

O comando `pwd` no Linux

Sempre que você se sentir perdido no sistema de arquivos, chame o comando pwd para saber onde você está:

pwd

Ele imprimirá o caminho da pasta atual.

O comando `mkdir` no Linux

Você pode criar pastas usando o comando mkdir:

mkdir fruits

Você pode criar várias pastas com um comando:

mkdir dogs cars

Você também pode criar várias pastas aninhadas adicionando a opção -p:

mkdir -p fruits/apples

As opções nos comandos UNIX geralmente assumem esse formato. Você os adiciona logo após o nome do comando e eles mudam o comportamento do comando. Muitas vezes, você também pode combinar várias opções.

Você pode descobrir quais opções um comando suporta digitando man . Tente agora com man mkdir, por exemplo, (pressione a tecla q para sair da página de manual). As páginas de manual são a incrível ajuda integrada para UNIX.

O comando `rmdir` no Linux

Assim como você pode criar uma pasta usando mkdir, você pode excluir uma pasta usando rmdir:

mkdir fruits
rmdir fruits

Você também pode excluir várias pastas de uma vez:

mkdir fruits cars
rmdir fruits cars

‌ A pasta que você exclui deve estar vazia.

Para excluir pastas com arquivos, usaremos o comando rm mais genérico, que exclui arquivos e pastas, usando a opção -rf:

rm -rf fruits cars

Tenha cuidado, pois esse comando não pede confirmação e removerá imediatamente tudo o que você solicitar.

Não há bin ao remover arquivos da linha de comando e recuperar arquivos perdidos pode ser difícil.

O comando `mv` no Linux

Depois de ter um arquivo, você pode movê-lo usando o comando mv. Você especifica o caminho atual do arquivo e seu novo caminho:

touch test
mv pear new_pear

O arquivo pear é movido para new_pear. É assim que você renomeia arquivos e pastas.

Se o último parâmetro for uma pasta, o arquivo localizado no caminho do primeiro parâmetro será movido para essa pasta. Nesse caso, você pode especificar uma lista de arquivos e todos eles serão movidos no caminho da pasta identificado pelo último parâmetro:

touch pear
touch apple
mkdir fruits
mv pear apple fruits #pear e apple são movidos para a pasta fruits

O comando `cp` no Linux

Você pode copiar um arquivo usando o comando cp:

touch test
cp apple another_apple

Para copiar pastas você precisa adicionar a opção -r para copiar recursivamente todo o conteúdo da pasta:

mkdir fruits
cp -r fruits cars

‌O comando `open` no Linux

O comando open permite abrir um arquivo usando esta sintaxe:‌

open

Você também pode abrir um diretório, que no macOS abre o aplicativo Finder com o diretório atual aberto:

open

‌ Eu uso isso o tempo todo para abrir o diretório atual:

open .

O símbolo especial . aponta para o diretório atual, enquanto .. aponta para o diretório pai

O mesmo comando também pode ser usado para executar uma aplicação:

open

‌O comando `touch` no Linux

Você pode criar um arquivo vazio usando o comando touch:

touch apple

‌Se o arquivo já existir, ele será aberto no modo de gravação e o carimbo de data/hora do arquivo será atualizado.

O comando `find` no Linux

O comando find pode ser usado para localizar arquivos ou pastas que correspondam a um padrão de pesquisa específico. Ele pesquisa recursivamente.

Vamos aprender como usá-lo por meio de um exemplo.

Encontre todos os arquivos na árvore atual que possuem a extensão .js e imprima o caminho relativo de cada arquivo correspondente:

find . -name '*.js'

É importante usar aspas em torno de caracteres especiais como * para evitar que o shell os interprete.

Encontre diretórios na árvore atual que correspondam ao nome "src":

find . -type d -name src

Use -type f para pesquisar apenas arquivos ou -type l para pesquisar apenas links simbólicos.

-name diferencia maiúsculas de minúsculas. Use -iname para realizar uma pesquisa sem distinção entre maiúsculas e minúsculas.

Você pode pesquisar em várias árvores raiz:

find folder1 folder2 -name filename.txt

Encontre diretórios na árvore atual que correspondam ao nome "node_modules" ou 'public':

find . -type d -name node_modules -or -name public

Você também pode excluir um caminho da pesquisa usando -not -path:

find . -type d -name '*.md' -not -path 'node_modules/*'

Você pode pesquisar arquivos que contenham mais de 100 caracteres (bytes):

find . -type f -size +100c

Pesquise arquivos maiores que 100 KB, mas menores que 1 MB:

find . -type f -size +100k -size -1M

Pesquise arquivos editados há mais de 3 dias:

find . -type f -mtime +3

Pesquise arquivos editados nas últimas 24 horas:

find . -type f -mtime -1

Você pode excluir todos os arquivos que correspondem a uma pesquisa adicionando a opção -delete. Isso exclui todos os arquivos editados nas últimas 24 horas:

find . -type f -mtime -1 -delete

Você pode executar um comando em cada resultado da pesquisa. No exemplo, executamos cat para imprimir o conteúdo do arquivo:

find . -type f -exec cat {} \;

Observe a terminação \;. {} é preenchido com o nome do arquivo em tempo de execução.

O comando `ln` no Linux

O comando ln faz parte dos comandos do sistema de arquivos Linux.

É usado para criar links. O que é um link? É como um ponteiro para outro arquivo ou um arquivo que aponta para outro arquivo. Você deve estar familiarizado com os atalhos do Windows. Eles são semelhantes.

Temos 2 tipos de links: hard links e soft links.

Hard links

Hard links raramente são usados. Eles têm algumas limitações: você não pode vincular a diretórios e não pode vincular a sistemas de arquivos externos (discos).

Um hard link é criado usando a seguinte sintaxe:

ln

Por exemplo, digamos que você tenha um arquivo chamado recipes.txt (um arquivo de texto com receitas). Você pode criar um hard link para ele usando:

ln recipes.txt newrecipes.txt

O novo hard link que você criou é indistinguível de um arquivo normal:

Agora, sempre que você editar qualquer um desses arquivos, o conteúdo será atualizado para ambos.

Se você excluir o arquivo original, o link ainda conterá o conteúdo do arquivo original, pois ele não será removido até que haja um hard link apontando para ele.

Soft links

Soft links são diferentes. Eles são mais poderosos porque você pode vincular a outros sistemas de arquivos e diretórios. Lembre-se, porém, de que, quando o original for removido, o link será quebrado.

Você cria links virtuais usando a opção -s de ln:

ln -s

Por exemplo, digamos que você tenha um arquivo chamado recipes.txt. Você pode criar um soft link para ele usando:

ln -s recipes.txt newrecipes.txt

Nesse caso, você pode ver que há um sinalizador l especial ao listar o arquivo usando ls -al. O nome do arquivo tem um @ no final e também tem uma cor diferente se você tiver as cores ativadas:

‌‌Agora, se você excluir o arquivo original, os links serão quebrados e o shell informará "Esse arquivo ou diretório não existe" se você tentar acessá-lo:

O comando `gzip` no Linux

Você pode compactar um arquivo usando o protocolo de compactação gzip denominado LZ77 usando o comando gzip .

Aqui está o uso mais simples:

gzip filename

Isso compactará o arquivo e acrescentará uma extensão .gz a ele. O arquivo original é excluído.

Para evitar isso, você pode usar a opção -c e usar o redirecionamento de saída para gravar a saída no arquivo filename.gz :

gzip -c filename > filename.gz

‌A opção -c especifica que a saída estará no fluxo de saída padrão, deixando o arquivo original intacto.

Você também pode usar a opção -k:

gzip -k filename

Existem vários níveis de compressão. Quanto maior a compactação, mais tempo levará para compactar (e descompactar). Os níveis variam de 1 (compactação mais rápida e pior) a 9 (compactação mais lenta e melhor) e o padrão é 6.

Você pode escolher um nível específico com a opção: -:‌

gzip -1 filename

Você pode compactar vários arquivos listando-os:

gzip filename1 filename2

Você pode compactar todos os arquivos em um diretório, recursivamente, usando a opção -r :

gzip -r a_folder

A opção -v imprime as informações de porcentagem de compactação. Aqui está um exemplo de uso junto com a opção -k (keep):

gzip também pode ser usado para descompactar um arquivo, usando a opção -d :

gzip -d filename.gz

O comando `gunzip` no Linux

O comando gunzip basicamente equivalente ao comando gzip, exceto que a opção -d está sempre habilitada por padrão.

O comando pode ser invocado desta maneira:‌

gunzip filename.gz

Isso compactará e removerá a extensão .gz colocando o resultado no arquivo com filename . Se esse arquivo existir, ele será sobrescrito.

Você pode extrair para um nome de arquivo diferente usando o redirecionamento de saída usando a opção -c :

gunzip -c filename.gz > anotherfilename

O comando `tar` no Linux

O comando tar é usado para criar um arquivo, agrupando vários arquivos em um único arquivo.

Seu nome vem do passado e significa arquivo em fita (na época em que os arquivos eram armazenados em fitas – em inglês, Tape ARchive).

Este comando cria um arquivo chamado archive.tar com o conteúdo de file1 e file2:

tar -cf archive.tar file1 file2

‌ A opção c significa criar. A opção f é usada para gravar no arquivo.

Para extrair arquivos de um arquivo na pasta atual, use:

tar -xf archive.tar

A opção x significa extrair.

Para extraí-los para um diretório específico, use:

tar -xf archive.tar -C nome_do_diretório

Você também pode simplesmente listar os arquivos contidos em um arquivo:

tar é frequentemente usado para criar um arquivo compactado, compactando o arquivo.

Isso é feito usando a opção z :

tar -czf archive.tar.gz file1 file2

É como criar um arquivo tar e executar gzip nele.

Para desarquivar um arquivo compactado com gzip, você pode usar gunzip, ou gzip -d, e depois desarquivá-lo. tar -xf, no entanto, reconhecerá que é um arquivo compactado e fará isso por você:

tar -xf archive.tar.gz

O comando `alias` no Linux

É comum sempre executar um programa com um conjunto de opções que você gosta de usar.

Por exemplo, pegue o comando ls. Por padrão, imprime muito pouca informação:

‌ Se, no entanto, você usar a opção -al, imprimirá algo mais útil, incluindo a data de modificação do arquivo, o tamanho, o proprietário e as permissões. Ele também listará os arquivos ocultos (arquivos que começam com .):

Você pode criar um outro comando – por exemplo, gosto de chamá-lo de ll, que é um alias para ls -al.

Você faz assim:

alias ll='ls -al'

Depois de fazer isso, você pode chamar ll como se fosse um comando normal do UNIX:

Chamar alias sem qualquer opção listará os aliases definidos:

‌O alias funcionará até que a sessão do terminal seja fechada.

Para torná-lo permanente, você precisa adicioná-lo à configuração do shell. Pode ser ~/.bashrc ou ~/.profile ou ~/.bash_profile se você usar o shell Bash, dependendo do caso de uso.

Tenha cuidado com aspas se você tiver variáveis no comando: se você usar aspas duplas, a variável será resolvida no momento da definição. Se você usar aspas simples, ela será resolvida no momento da invocação. Os dois comandos abaixo são diferentes:

alias lsthis="ls $PWD"
alias lscurrent='ls $PWD'

$PWD refere-se à pasta atual em que o shell está. Se você navegar para uma nova pasta, lscurrent listará os arquivos na nova pasta, enquanto lsthis ainda listará os arquivos na pasta onde você estava quando definiu o alias.

O comando `cat` no Linux

Semelhante a tail em alguns aspectos, temos o cat. A diferença está no fato de que cat também pode adicionar conteúdo a um arquivo. Isso o torna superpoderoso.

Em seu uso mais simples, cat imprime o conteúdo de um arquivo na saída padrão:

cat file

Você pode imprimir o conteúdo de vários arquivos:

cat file1 file2

Usando o operador de redirecionamento de saída >, você pode concatenar o conteúdo de vários arquivos em um novo arquivo:

cat file1 file2 > file3

Usando >>, você pode anexar o conteúdo de vários arquivos em um novo arquivo, criando-o se ele não existir:

cat file1 file2 >> file3

Ao visualizar arquivos de código-fonte, é útil ver os números das linhas. Você pode fazer com que o cat os imprima usando a opção -n :

cat -n file1

Você só pode adicionar um número a linhas que não estejam em branco usando -b, ou também pode remover todas as múltiplas linhas vazias usando -s.

cat é frequentemente usado em combinação com o operador | para alimentar o conteúdo de um arquivo como entrada para outro comando: cat file1 | outro_comando.

O comando `less` no Linux

O comando less é um que eu uso muito. Ele mostra o conteúdo armazenado dentro de um arquivo, em uma interface de usuário agradável e interativa.

Use: less .

Quando estiver dentro de uma sessão less, você pode sair dela pressionando q.

Você pode navegar pelo conteúdo do arquivo usando as teclas das setas para cima e para baixo, ou usando a barra de espaço e b para navegar página por página. Você também pode pular para o final do arquivo pressionando G e voltar ao início pressionando g.

Você pode pesquisar o conteúdo do arquivo pressionando / digitando uma palavra para pesquisar. Isso busca adiante. Você pode pesquisar para trás usando o símbolo ? e digitando uma palavra.

Esse comando apenas visualiza o conteúdo do arquivo. Você pode abrir um editor diretamente pressionando v. Ele usará o editor do sistema, que, na maioria dos casos, é o vim.

Pressionar a tecla F entra no modo de acompanhamento ou modo de observação. Quando o arquivo é alterado por outra pessoa, como outro programa, você pode ver as alterações ao vivo.

Isso não acontece por padrão e você só vê a versão do arquivo no momento em que o abre. Você precisa pressionar ctrl-C para sair deste modo. Nesse caso, o comportamento é semelhante à execução do comando tail -f .

Você pode abrir vários arquivos e navegar por eles usando :n (para ir para o próximo arquivo) e :p (para ir para o anterior).

O comando `tail` no Linux

O melhor caso de uso de tail, na minha opinião, é quando chamado com a opção -f. Ele abre o arquivo no final e observa as alterações no arquivo.

Sempre que houver novo conteúdo no arquivo, ele será impresso na janela. Isso é ótimo para observar arquivos de log, por exemplo:

tail -f /var/log/system.log

Para sair, pressione a tecla ctrl-C.

Você pode imprimir as últimas 10 linhas de um arquivo:

tail -n 10

Você pode imprimir todo o conteúdo do arquivo começando em uma linha específica usando + antes do número da linha:

tail -n +10

tail pode fazer muito mais e, como sempre, meu conselho é verificar o man tail.

O comando `wc` no Linux

O comando wc nos fornece informações úteis sobre um arquivo ou entrada que ele recebe por meio de pipes.

echo test >> test.txt
wc test.txt
1       1       5 test.txt

‌Como exemplo por meio de pipes, podemos contar a saída da execução do comando ls -al :

ls -al | wc
6      47     284

A primeira coluna retornada é o número de linhas. O segundo é o número de palavras. O terceiro é o número de bytes.

Podemos dizer para apenas contar as linhas:

wc -l test.txt

ou apenas as palavras:

wc -w test.txt

apenas os bytes:

wc -c test.txt

Bytes em conjuntos de caracteres ASCII equivalem a caracteres. Com conjuntos de caracteres que não sejam ASCII, o número de caracteres pode ser diferente porque alguns caracteres podem ocupar vários bytes (por exemplo, isso acontece em Unicode).

Nesse caso, o sinalizador -m ajudará você a obter o valor correto:

wc -m test.txt

O comando `grep` no Linux

O comando grep é uma ferramenta muito útil. Quando você dominá-lo, ele o ajudará tremendamente na programação do dia a dia.

Se você está se perguntando, grep significa impressão de expressão regular global.

Você pode usar grep para pesquisar arquivos ou combiná-lo com pipes para filtrar a saída de outro comando.

Por exemplo, aqui está como podemos encontrar as ocorrências da linha document.getElementById no arquivo index.md:

grep -n document.getElementById index.md

‌ Usar a opção -n mostrará os números das linhas:‌

grep -n document.getElementById index.md

Uma coisa muito útil é dizer ao grep para imprimir 2 linhas antes e 2 linhas depois da linha correspondente para dar a ele mais contexto. Isso é feito usando a opção -C, que aceita várias linhas:

grep -nC 2 document.getElementById index.md

A pesquisa diferencia maiúsculas de minúsculas por padrão. Use o sinalizador -i para não diferenciar.

Conforme mencionado, você pode usar grep para filtrar a saída de outro comando. Podemos replicar a mesma funcionalidade acima usando:

less index.md | grep -n document.getElementById

A string de pesquisa pode ser uma expressão regular e isso torna o grep muito poderoso.

Outra coisa que você pode achar muito útil é inverter o resultado, excluindo as linhas que correspondem a uma string específica, usando a opção -v :

O comando `sort` no Linux

Suponha que você tenha um arquivo de texto que contém nomes de cachorros:

Essa lista não está ordenada.

O comando sort ajuda você a classificá-los por nome:

Use a opção r para reverter a ordem:

A classificação por padrão diferencia maiúsculas de minúsculas e é alfabética. Use a opção --ignore-case para classificar sem distinção entre maiúsculas e minúsculas e a opção -n para classificar usando uma ordem numérica.

Se o arquivo tiver linhas duplicadas:

Você pode usar a opção -u para removê-los:

sort não funciona apenas em arquivos, como muitos comandos UNIX fazem – ele também funciona com pipes. Portanto, você pode usá-lo na saída de outro comando. Por exemplo, você pode ordenar os arquivos retornados por ls com:

ls | sort

sort é muito poderoso e tem muito mais opções, que você pode explorar chamando man sort.

O comando `uniq` no Linux

uniq é um comando que ajuda a classificar linhas de texto.

Você pode obter essas linhas de um arquivo ou usar pipes da saída de outro comando:

uniq dogs.txt

ls | uniq

Você precisa considerar este ponto importante: o uniq detectará apenas linhas duplicadas adjacentes.

Isso implica que você provavelmente o usará junto com sort:

sort dogs.txt | uniq

O comando sort tem sua própria maneira de remover duplicatas com a opção -u (unique). Mas uniq tem mais poder.

Por padrão, ele remove linhas duplicadas:

Você pode instruí-lo para exibir apenas linhas duplicadas, por exemplo, com a opção -d :

sort dogs.txt | uniq -d

Você pode usar o comando -u para exibir apenas linhas não duplicadas:

Você pode contar as ocorrências de cada linha com a opção -c :

Use a combinação especial:

sort dogs.txt | uniq -c | sort -nr

Assim, você classificará essas linhas pelas mais frequentes:

O comando `diff` no Linux

diff é um comando útil. Suponha que você tenha 2 arquivos que contêm quase as mesmas informações, mas não consegue encontrar a diferença entre os dois.

diff processará os arquivos e dirá qual é a diferença.

Suponha que você tem dois arquivos: dogs.txt e moredogs.txt. A diferença é que moredogs.txt contêm mais um nome de cachorro:

diff dogs.txt moredogs.txt dirá que o segundo arquivo tem mais uma linha, a linha 3 com o nome Vanille:

Se você inverter a ordem dos arquivos, será informado que falta a linha 3 no segundo arquivo, cujo conteúdo é Vanille:

Usar a opção -y vai comparar os 2 arquivos linha por linha:

A opção -u entretanto, será mais familiar para você, porque é a mesma usada pelo sistema de controle de versão Git para exibir diferenças entre versões:

A comparação de diretórios funciona da mesma maneira. Você deve usar a opção -r para comparar recursivamente (entrando em subdiretórios):

Caso você esteja interessado em quais arquivos diferem, e não no conteúdo, use as opções r e q :

Existem muitas outras opções que você pode explorar na página de manual executando man diff:

O comando `echo` no Linux

O comando echo faz um trabalho simples: imprime na saída o argumento passado para ele.

Esse exemplo:

echo "hello"

Isso imprimirá hello no terminal.

Podemos anexar a saída a um arquivo:

echo "hello" >> output.txt

Podemos interpolar variáveis de ambiente:

echo "The path variable is $PATH"

Cuidado, pois os caracteres especiais precisam ser escapados com uma barra invertida \. $ por exemplo:

Este é apenas o começo. Podemos fazer algumas coisas legais quando se trata de interagir com os recursos do shell.

Podemos repetir os arquivos na pasta atual:

echo *

Podemos repetir os arquivos da pasta atual que começam com a letra o:

echo o*

Qualquer comando e recurso válido do Bash (ou qualquer shell que você esteja usando) pode ser usado aqui.

Você pode imprimir o caminho da sua pasta pessoal:

echo ~

Você também pode executar comandos e imprimir o resultado na saída padrão (ou em arquivo, como você viu):

echo $(ls -al)

Observe que os espaços em branco não são preservados por padrão. Você precisa colocar o comando entre aspas duplas para fazer isso:

Você pode gerar uma lista de strings, por exemplo, intervalos:

echo {1..5}

O comando `chown` no Linux

Cada arquivo/diretório em um sistema operacional como Linux ou macOS (e todo sistema UNIX em geral) tem um proprietário.

O proprietário de um arquivo pode fazer tudo com ele. Pode decidir o destino desse arquivo.

O proprietário (e o usuário root ) também pode alterar o proprietário para outro usuário, usando o comando chown:

chown

Assim:

chown flavio test.txt

‌Por exemplo, se você tiver um arquivo que pertence ao root, você não poderá escrever nele como outro usuário:

Você pode usar chown para transferir a propriedade para você:

É bastante comum precisar alterar a propriedade de um diretório e recursivamente de todos os arquivos contidos, além de todos os subdiretórios e arquivos contidos neles também.

Você pode fazer isso usando o sinalizador -R :

chown -R

Arquivos/diretórios não têm apenas um proprietário. Eles também têm um grupo. Através deste comando, você pode alterar isso simultaneamente enquanto altera o proprietário:

chown :

Exemplo:

chown flavio:users test.txt

Você também pode alterar o grupo de um arquivo usando o comando chgrp:

chgrp

O comando `chmod` no Linux

Cada arquivo nos sistemas operacionais Linux/macOS (e sistemas UNIX em geral) possui 3 permissões: leitura, gravação e execução.

Vá para uma pasta e execute o comando ls -al.

As strings estranhas que você vê em cada linha de arquivo, como drwxr-xr-x, definem as permissões do arquivo ou pasta.

Vamos dissecá-lo.

A primeira letra indica o tipo de arquivo:

- significa que é um arquivo normal
d significa que é um diretório
l significa que é um link

Então você tem 3 conjuntos de valores:

O primeiro conjunto representa as permissões do proprietário do arquivo
O segundo conjunto representa as permissões dos membros do grupo ao qual o arquivo está associado
O terceiro conjunto representa as permissões de todos os outros

Esses conjuntos são compostos por 3 valores. rwx significa que uma pessoa específica tem acesso de leitura (r, de read em inglês), gravação (w, de write em inglês) e execução (de eXecute em inglês). Qualquer coisa removida é trocada por -, que permite formar várias combinações de valores e permissões relativas: rw-, r--, r-x, e assim por diante.

Você pode alterar as permissões concedidas a um arquivo usando o comando chmod.

chmod pode ser usado de 2 maneiras. O primeiro usa argumentos simbólicos, o segundo usa argumentos numéricos. Vamos começar primeiro com os símbolos, o que é mais intuitivo.

Você digita chmod seguido por um espaço e uma letra:

a significa tudo
u significa usuário
g significa grupo
o significa outros

Em seguida, você digita + ou - para adicionar uma permissão ou removê-la. Em seguida, você insere um ou mais símbolos de permissão (r, w, x).

Tudo seguido do nome do arquivo ou pasta.

Aqui estão alguns exemplos:

chmod a+r nome_do_arquivo #todos podem ler
chmod a+rw nome_do_arquivo #todos podem ler e gravar
chmod o-rwx nome_do_arquivo #outros (que não sejam o proprietário, que não estejam no mesmo grupo do arquivo) não têm permissão de ler, gravar ou executar o arquivo

‌ Você pode aplicar as mesmas permissões a várias personas adicionando várias letras antes do +/-:

chmod og-r nome_do_arquivo #outros e grupo não podem mais ler

‌Caso esteja editando uma pasta, você pode aplicar as permissões a todos os arquivos contidos nessa pasta usando o sinalizador -r (recursivo).

Argumentos numéricos são mais rápidos, mas acho difícil lembrá-los quando você não os usa no dia a dia. Você usa um algarismo que representa as permissões da persona. Este valor numérico pode ser no máximo 7 e é calculado da seguinte forma:

1 se tiver permissão de execução
2 se tiver permissão de gravação
4 se tiver permissão de leitura

Isso nos dá 4 combinações:

0 Nenhuma permissão
1 pode executar
2 pode escrever
3 pode escrever, executar
4 pode ler
5 pode ler, executar
6 pode ler e escrever
7 pode ler, escrever e executar

Nós os usamos em grupos de 3, para definir as permissões de todos os 3 grupos ao todo:

chmod 777 nome_do_arquivo
chmod 755 nome_do_arquivo
chmod 644 nome_do_arquivo

O comando `umask` no Linux

Ao criar um arquivo, você não precisa decidir as permissões antecipadamente. As permissões têm padrões.

Esses padrões podem ser controlados e modificados usando o comando umask .

Digitar umask sem argumentos mostrará o umask, atual, neste caso 0022:

O que 0022 significa? Esse é um valor octal que representa as permissões.

Outro valor comum é 0002.

Use umask -S para ver uma notação legível por humanos:

Neste caso, o usuário (u), proprietário do arquivo, possui permissões de leitura, escrita e execução nos arquivos.

Os demais usuários pertencentes ao mesmo grupo (g) possuem permissão de leitura e execução, igual a todos os demais usuários (o).

Na notação numérica, normalmente alteramos os últimos 3 dígitos.

Aqui está uma lista que dá um significado ao número:

0 ler, escrever, executar
1 ler e escrever
2 ler e executar
3 somente leitura
4 escrever e executar
5 escrever apenas
6 executar apenas
7 nenhuma permissão

Observe que esta notação numérica difere daquela que usamos em chmod.

Podemos definir um novo valor para a máscara definindo o valor em formato numérico:

umask 002

ou você pode alterar a permissão de uma função específica:

umask g+r

O comando `du` no Linux

O comando du calculará o tamanho de um diretório como um todo:

du

O número 32 aqui é um valor expresso em bytes.

Rodar du * calculará o tamanho de cada arquivo individualmente:

Você pode definir du para exibir valores em MegaBytes, usando du -m, e GigaBytes, usando du -g.

A opção -h mostrará uma notação legível para tamanhos, adaptando-se ao tamanho:

Adicionar a opção -a também imprimirá o tamanho de cada arquivo nos diretórios:

Uma coisa útil é classificar os diretórios por tamanho:

du -h  | sort -nr

‌Em seguida, use head para obter apenas os 10 primeiros resultados:

O comando `df` no Linux

O comando df é usado para obter informações de uso do disco.

Em sua forma básica, ele imprimirá informações sobre os volumes montados:

Usar a opção -h (df -h) mostrará esses valores em um formato legível:

Você também pode especificar um nome de arquivo ou diretório para obter informações sobre o volume específico em que ele reside:

O comando `basename` no Linux

Suponha que você tenha um caminho para um arquivo, por exemplo /Users/flavio/test.txt.

Rodar

basename /Users/flavio/test.txt

retornará a string test.txt:

Se você executar basename em uma string de caminho que aponta para um diretório, obterá o último segmento do caminho. Neste exemplo, /Users/flavio é um diretório:

O comando `dirname` no Linux

Suponha que você tenha um caminho para um arquivo, por exemplo /Users/flavio/test.txt.

Rodar

dirname /Users/flavio/test.txt

retornará a string /Users/flavio:

O comando `ps` no Linux

Seu computador está executando vários processos diferentes o tempo todo.

Você pode inspecionar todos eles usando o comando ps:

Essa é a lista de processos iniciados pelo usuário em execução na sessão atual.

Aqui eu tenho algumas instâncias de fish shell, a maioria abertas pelo VS Code dentro do editor, e uma instância de Hugo executando a visualização de desenvolvimento de um site.

Esses são apenas os comandos atribuídos ao usuário atual. Para listar todos os processos precisamos passar algumas opções para os ps.

O mais comum que eu uso é o ps ax:

O opção a também é usada para listar os processos de outros usuários, não apenas os seus. x mostra processos não vinculados a nenhum terminal (não iniciados pelos usuários através de um terminal).

Como você pode ver, os comandos mais longos são cortados. Use o comando ps axww para continuar a listagem de comandos em uma nova linha em vez de cortá-la:

Precisamos especificar w 2 vezes para aplicar esta configuração (não é um erro de digitação).

Você pode procurar um processo específico combinando grep com um pipe, assim:

ps axww | grep "Visual Studio Code"

As colunas retornadas por ps representam algumas informações importantes.

A primeira informação é o PID, o ID do processo. Isso é fundamental quando você deseja fazer referência a esse processo em outro comando, por exemplo, para eliminá-lo.

Então temos TT que nos informa o ID do terminal usado.

Então STAT nos informa o estado do processo:

I um processo que está ocioso (suspenso por mais de 20 segundos)‌‌R um processo executável‌‌S um processo que está dormindo por menos de 20 segundos‌‌T um processo parado‌‌U um processo em espera ininterrupto‌‌Z um processo morto (um zumbi)

Se você tiver mais de uma carta, a segunda representa mais informações, que podem ser muito técnicas.

É comum ter + que indica que o processo está em primeiro plano no seu terminal. s significa que o processo é um líder de sessão.

TIME nos diz há quanto tempo o processo está em execução.

O comando `top` no Linux

O comando top é usado para exibir informações dinâmicas em tempo real sobre os processos em execução no sistema.

É muito útil entender o que está acontecendo.

Seu uso é simples – basta digitar top e o terminal ficará totalmente imerso nesta nova visualização:

O processo é demorado. Para sair, você pode digitar a letra q ou ctrl-C.

Muitas informações nos são fornecidas: o número de processos, quantos estão em execução ou em suspensão, a carga do sistema, o uso da CPU e muito mais.

Abaixo, a lista de processos que ocupam mais memória e CPU é constantemente atualizada.

Por padrão, como você pode ver na coluna %CPU destacada, eles são classificados pela CPU usada

Você pode adicionar um sinalizador para classificar os processos pela memória utilizada:

top -o mem

O comando `kill` no Linux

Os processos do Linux podem receber sinais e reagir a eles.

Essa é uma maneira de interagirmos com programas em execução.

O programa kill pode enviar uma variedade de sinais para um programa.

Não é usado apenas para encerrar um programa, como o nome sugere, mas essa é sua função principal.

Nós o usamos desta maneira:

kill

Por padrão, isso envia o sinal TERM para o ID do processo especificado.

Podemos usar sinalizadores para enviar outros sinais, incluindo:

kill -HUP 
kill -INT 
kill -KILL 
kill -TERM 
kill -CONT 
kill -STOP

‌HUP significa desligar. É enviado automaticamente quando uma janela de terminal que iniciou um processo é fechada antes de encerrar o processo.

INT significa interrupção e envia o mesmo sinal usado quando pressionamos ctrl-C no terminal, o que geralmente encerra o processo.

KILL não é enviado para o processo, mas para o kernel do sistema operacional, que imediatamente interrompe e finaliza o processo.

TERM significa terminar. O processo vai receber esse sinal e terminar sozinho. É o sinal padrão enviado por kill.

CONT significa continuar. Pode ser usado para retomar um processo interrompido.

STOP não é enviado para o processo, mas para o kernel do sistema operacional, que interrompe imediatamente (mas não encerra) o processo.

Você pode ver números usados, como kill -1 . Nesse caso,

1 corresponde ao HUP.‌‌2 corresponde ao INT.‌‌9 corresponde ao KILL.‌‌15 corresponde ao TERM.‌‌18 corresponde ao CONT.‌‌15 corresponde ao STOP.

O comando `killall` no Linux

Semelhante ao comando kill, killall enviará o sinal para vários processos ao mesmo tempo, em vez de enviar um sinal para um ID de processo específico.

Essa é a sintaxe:‌

killall

Aqui, nome é o nome de um programa. Por exemplo, você pode ter várias instâncias do programa top em execução. killall top encerrará todas elas.

Você pode especificar o sinal, como acontece com kill (e verifique o tutorial kill para ler mais sobre os tipos específicos de sinais que podemos enviar), por exemplo:

killall -HUP top

O comando `jobs` no Linux

Quando executamos um comando no Linux/macOS, podemos configurá-lo para execução em segundo plano usando o símbolo & após o comando.

Por exemplo, podemos executar top em segundo plano:

top &

Isso é muito útil para programas de longa duração.

Podemos voltar a esse programa usando o comando fg. Isso funciona bem se tivermos apenas um trabalho em segundo plano, caso contrário, precisaremos usar o número do trabalho: fg 1, fg 2 e assim por diante.

Para obter o número do trabalho, usamos o comando jobs.

Digamos que executemos top & e então top -o mem &. Temos 2 instâncias principais em execução. jobs nos mostrará isso:

Agora, podemos voltar para um daqueles que usam fg . Para parar o programa novamente podemos clicar em cmd-Z.

Executar jobs -l também imprimirá o ID do processo de cada trabalho.

O comando `bg` no Linux

Quando um comando está em execução, você pode suspendê-lo usando ctrl-Z.

O comando interromperá imediatamente e você retornará ao terminal shell.

Você pode retomar a execução do comando em segundo plano, para que ele continue em execução, mas não o impeça de realizar outros trabalhos no terminal.

Neste exemplo, tenho 2 comandos parados:

Posso executar o bg 1 para retomar em segundo plano a execução do job nº 1.

Eu também poderia ter dito bg sem nenhuma opção, pois o padrão é escolher job nº 1 da lista.

O comando `fg` no Linux

Quando um comando está sendo executado em segundo plano, porque você o iniciou com & no final (exemplo: top &) ou porque você o colocou em segundo plano (com o comando bg), você pode colocá-lo em primeiro plano usando fg.

Executar

fg

retomará em primeiro plano o último trabalho que foi suspenso.

Você também pode especificar qual trabalho deseja retomar para primeiro plano passando o número do trabalho, que pode ser obtido usando o comando jobs.

Executar fg 2 retomará o job nº 2:

O comando `type` no Linux

Um comando pode ser um destes 4 tipos:

um executável
um programa embutido no shell
uma função shell
um apelido

O comando type pode ajudar a descobrir isso, caso queiramos saber ou estejamos apenas curiosos. Ele dirá como o comando será interpretado.

A saída dependerá do shell usado. Este é o Bash:

Este é o Zsh:

Este é o Fish:

Uma das coisas mais interessantes aqui é que, para aliases, ele dirá para que serve o alias. Você pode ver o ll alias, no caso de Bash e Zsh, mas o Fish o fornece por padrão, então ele dirá que é uma função interna do shell.

O comando `which` no Linux

Suponha que você tenha um comando que pode executar porque está no caminho do shell, mas deseja saber onde ele está localizado.

Você pode fazer isso usando which. O comando retornará o caminho para o comando especificado:

which funcionará apenas para executáveis armazenados em disco, não para aliases ou funções de shell integradas.

O comando `nohup` no Linux

Às vezes, você precisa executar um processo de longa duração em uma máquina remota e depois desconectar.

Ou você, simplesmente, deseja evitar que o comando seja interrompido se houver algum problema de rede entre você e o servidor.

A maneira de executar um comando mesmo depois de efetuar logout ou fechar a sessão em um servidor é usar o comando nohup.

Use nohup para permitir que o processo continue funcionando mesmo depois de você sair.

O comando `xargs` no Linux

O comando xargs é usado em um shell UNIX para converter a entrada padrão em argumentos para um comando.

Em outras palavras, através do uso de xargs, a saída de um comando é usada como entrada de outro comando.

Aqui está a sintaxe que você usará:

comando1 | xargs comando2

Usamos um pipe (|) para passar a saída para xargs. Isso cuidará da execução do comando comando2, usando a saída de comando1 como seu(s) argumento(s).

Vamos fazer um exemplo simples. Você deseja remover alguns arquivos específicos de um diretório. Esses arquivos estão listados dentro de um arquivo de texto.

Temos 3 arquivos: file1, file2, file3.

No todelete.txt temos uma lista de arquivos que queremos excluir, neste exemplo file1 e file3:

Vamos canalizar a saída de cat todelete.txt para o comando rm, através de xargs, assim:

cat todelete.txt | xargs rm

Esse é o resultado, os arquivos que listamos agora foram excluídos:

A forma como funciona é que xargs executará rm 2 vezes, uma para cada linha retornada por cat.

Este é o uso mais simples de xargs. Existem várias opções que podemos usar.

Um dos mais úteis, na minha opinião (especialmente quando se começa a aprender xargs), é -p. Usar esta opção fará com que o xargs imprima um prompt de confirmação com a ação que será executada:

A opção -n permite que você diga ao xargs para realizar uma iteração por vez, para que você possa confirmá-las individualmente com -p. Aqui dizemos ao xargs para realizar uma iteração por vez com -n1:

A opção -I é outra amplamente utilizada. Ela permite que você coloque a saída em um espaço reservado e, então, você pode fazer várias coisas.

Uma delas é executar vários comandos:

comando1 | xargs -I % /bin/bash -c 'comando2 %; comando3 %

Você pode trocar o símbolo % que usei acima por qualquer outra coisa – é uma variável.

O comando do editor `vim` no Linux

vim é um editor de arquivos muito popular, especialmente entre programadores. Ele é desenvolvido ativamente e atualizado com frequência, e há uma grande comunidade em torno dele. Há até uma conferência sobre o Vim!

vi em sistemas modernos é apenas um apelido para vim, que significa que vim melhorou.

Você inicia executando o vi na linha de comando.

Você pode especificar um nome de arquivo no momento da chamada para editar esse arquivo específico:

vi test.txt

Você deve saber que o Vim possui 2 modos principais:

modo de comando (ou normal)
modo de inserção

Ao iniciar o editor, você está no modo de comando. Você não pode inserir texto como espera de um editor baseado em GUI. Você tem que entrar no modo de inserção.

Você pode fazer isso pressionando a tecla i. Depois de fazer isso, a palavra -- INSERT -- aparece na parte inferior do editor:

Agora, você pode começar a digitar e preencher a tela com o conteúdo do arquivo:

Você pode mover-se pelo arquivo com as teclas de seta ou usando as teclas h - j - k - l. h-l para esquerda e direita, j-k para baixo e para cima.

Quando terminar de editar, você pode pressionar a tecla esc para sair do modo de inserção e voltar ao modo de comando.

Neste ponto, você pode navegar no arquivo, mas não pode adicionar conteúdo a ele (e tome cuidado com as teclas que você pressiona, pois podem ser comandos).

Uma coisa que você pode querer fazer agora é salvar o arquivo. Você pode fazer isso pressionando: (dois pontos) e w.

Você pode salvar e sair pressionando :, w e q: :wq

Você pode sair sem salvar pressionando :, q e !: :q!

Você pode desfazer e editar acessando o modo de comando e pressionando u. Você pode refazer (cancelar um desfazer) pressionando ctrl-r.

Esses são os princípios básicos para trabalhar com o Vim. A partir daqui começa uma infinitude de informações na qual não podemos entrar nesta pequena introdução.

Mencionarei apenas os comandos que ajudarão você a começar a editar com o Vim:

pressionar a tecla x exclui o caractere atualmente destacado
pressionar A vai para o final da linha atualmente selecionada
pressionar 0 para ir para o início da linha
ir para o primeiro caractere de uma palavra e pressionar d seguido de w para excluir essa palavra. Se você seguir com e em vez de w, o espaço em branco antes da próxima palavra será preservado
usar um número entre d e w para excluir mais de 1 palavra – por exemplo, usar d3w para excluir 3 palavras adiante
pressionar d seguido de d para excluir uma linha inteira. Pressionar d seguido de $ para deletar toda a linha de onde está o cursor, até o final

Para saber mais sobre o Vim, recomendo o FAQ do Vim (em inglês). Você também pode executar o comando vimtutor, que já deve estar instalado em seu sistema e o ajudará muito a iniciar a exploração do vim.

O comando do editor `emacs` no Linux

emacs é um editor incrível e é historicamente considerado o editor de sistemas UNIX. Notoriamente, as guerras violentas entre vi e emacs e discussões acaloradas causaram muitas horas improdutivas para desenvolvedores em todo o mundo.

emacs é muito poderoso. Algumas pessoas usam esse editor o dia todo como uma espécie de sistema operacional (https://news.ycombinator.com/item?id=19127258). Falaremos apenas sobre o básico aqui.

Você pode abrir uma nova sessão do emacs simplesmente invocando emacs:

Usuários do macOS, parem um segundo agora. Se você estiver no Linux, não há problemas, mas o macOS não fornece aplicativos que usam GPLv3 e todos os comandos integrados do UNIX que foram atualizados para GPLv3 não foram atualizados.‌‌‌‌Embora haja um pequeno problema com os comandos que listei até agora, neste caso, usar uma versão do emacs de 2007 não é exatamente o mesmo que usar uma versão com 12 anos de melhorias e mudanças.‌‌‌‌Esse não é um problema com o Vim, que está atualizado. Para corrigir isso, execute brew install emacs e a execução do emacs usará a nova versão do Homebrew (certifique-se de ter o Homebrew instalado).

Você também pode editar um arquivo existente chamando emacs :

Agora, você pode começar a editar. Quando terminar, pressione ctrl-x seguido de ctrl-w. Você confirma a pasta:

O Emacs informa que o arquivo existe, perguntando se ele deve ser sobrescrito:

Responda y e você receberá uma confirmação de sucesso:

Você pode sair do Emacs pressionando ctrl-x seguido de ctrl-c.‌‌Como opção, use ctrl-x seguido de c (mantenha ctrl pressionado).

Há muito para saber sobre o Emacs, certamente mais do que sou capaz de escrever nesta pequena introdução. Eu encorajo você a abrir o Emacs e pressionar ctrl-h r para abrir o manual integrado e ctrl-h t para abrir o tutorial oficial.

O comando do editor `nano` no Linux

nano é um editor amigável para iniciantes.

Execute-o usando nano .

Você pode digitar caracteres diretamente no arquivo sem se preocupar com os modos.

Você pode sair sem editar usando ctrl-X. Se você editou o buffer do arquivo, o editor solicitará sua confirmação e você poderá salvar as edições ou descartá-las.

A ajuda na parte inferior mostra os comandos do teclado que permitem trabalhar com o arquivo:

pico é mais ou menos igual, embora nano é a versão GNU do pico que em algum momento da história não era de código aberto. O nano clone foi feito para satisfazer os requisitos de licença do sistema operacional GNU.

O comando `whoami` no Linux

Digite whoami para imprimir o nome do usuário atualmente conectado à sessão do terminal:

Observação: esse comando é diferente do comando who am i, que imprime mais informações

O comando `who` no Linux

O comando who exibe os usuários logados no sistema.

A menos que você esteja usando um servidor ao qual várias pessoas têm acesso, é provável que você seja o único usuário conectado, várias vezes:

Por que várias vezes? Porque cada shell aberto contará como um acesso.

Você pode ver o nome do terminal utilizado e a hora/dia em que a sessão foi iniciada.

Os sinalizadores -aH dirão who exibirá mais informações, incluindo o tempo ocioso e o ID do processo do terminal:

O comando especial who am i listará os detalhes atuais da sessão do terminal:

O comando `su` no Linux

Enquanto você estiver conectado ao shell do terminal com um usuário, pode ser necessário mudar para outro usuário.

Por exemplo, você está logado como root para realizar alguma manutenção, mas deseja mudar para uma conta de usuário.

Você pode fazer isso com o comando su:

su

Por exemplo: su flavio.

Se você estiver logado como usuário, executar su sem mais nada solicitará que você insira a senha do usuário root, pois esse é o comportamento padrão.

su iniciará um novo shell como outro usuário.

Quando terminar, digitar exit no shell fechará esse shell e retornará ao shell do usuário atual.

O comando `sudo` no Linux

sudo é comumente usado para executar um comando como root.

Você deve estar habilitado para usar o sudo e, quando estiver, poderá executar comandos como root digitando a senha do seu usuário (não a senha do usuário root).

As permissões são altamente configuráveis, o que é ótimo especialmente em um ambiente de servidor multiusuário. Alguns usuários podem ter acesso para executar comandos específicos por meio de sudo.

Por exemplo, você pode editar um arquivo de configuração do sistema:

sudo nano /etc/hosts

De outra forma, isso não seria salvo, pois você não tem a permissão para isso.

Você pode executar sudo -i para iniciar um shell como root:

Você pode usar sudo para executar comandos como qualquer usuário. root é o padrão, mas use a opção -u para especificar outro usuário:

sudo -u flavio ls /Users/flavio

O comando `passwd` no Linux

Os usuários do Linux têm uma senha atribuída. Você pode alterar a senha usando o comando passwd.

Existem duas situações aqui.

A primeira é quando você deseja alterar sua senha. Neste caso, você digita:

passwd

e um prompt interativo solicitará a senha antiga e, em seguida, solicitará a nova:

Quando você é root (ou tem privilégios de superusuário), você pode definir o nome de usuário para o qual deseja alterar a senha:

passwd

Neste caso, você não precisa inserir a antiga.

O comando `ping` no Linux

O comando ping faz ping em um host de rede específico, na rede local ou na Internet.

Você o usa com a sintaxe ping , onde pode ser um nome de domínio ou um endereço IP.

Aqui está um exemplo de ping google.com:

O comando envia uma solicitação ao servidor e o servidor retorna uma resposta.

ping continua enviando a solicitação a cada segundo, por padrão. Ele continuará funcionando até você pará-lo com ctrl-C, a menos que você passe o número de vezes que deseja tentar com a opção -c: ping -c 2 google.com.

Assim que o ping for interrompido, ele imprimirá algumas estatísticas sobre os resultados: a porcentagem de pacotes perdidos e estatísticas sobre o desempenho da rede.

Como você pode ver, a tela imprime o endereço IP do host e o tempo que levou para obter a resposta.

Nem todos os servidores suportam ping, caso a solicitação expire:

Às vezes isso, é feito propositalmente, para "ocultar" o servidor ou apenas para reduzir a carga. Os pacotes de ping também podem ser filtrados por firewalls.

ping funciona usando o protocolo ICMP (Internet Control Message Protocol), um protocolo de camada de rede como TCP ou UDP.

A solicitação envia um pacote ao servidor com a mensagem ECHO_REQUEST e o servidor retorna uma mensagem ECHO_REPLY. Não vou entrar em detalhes, mas esse é o conceito básico.

Fazer ping em um host é útil para saber se o host está acessível (supondo que ele implemente o ping), assim como a distância que ele está em termos de quanto tempo leva para retornar para você.

Normalmente, quanto mais próximo o servidor estiver geograficamente, menos tempo levará para retornar para você. Leis físicas simples fazem com que uma distância maior introduza mais atraso nos cabos.

O comando `traceroute` no Linux

Ao tentar acessar um host na Internet, você passa pelo roteador doméstico. Então você chega à rede do seu ISP, que por sua vez passa por seu próprio roteador de rede upstream e assim por diante, até finalmente chegar ao host.

Você já quis saber quais etapas seus pacotes passam para fazer isso?

O comando traceroute é feito para isso.

Você chama

traceroute

Ele vai reunir (lentamente) todas as informações enquanto o pacote viaja.

Neste exemplo, tentei acessar meu blog com traceroute flaviocopes.com:

Nem todo roteador percorrido nos retorna informações. Neste caso, traceroute imprime * * *. Caso contrário, podemos ver o nome do host, o endereço IP e alguns indicadores de desempenho.

Para cada roteador, podemos ver 3 amostras, o que significa que o traceroute tenta, por padrão, 3 vezes obter uma boa indicação do tempo necessário para alcançá-lo.

É por isso que leva tanto tempo para executar o traceroute em comparação com simplesmente fazer um ping naquele host.

Você pode personalizar esse número com a opção -q:

traceroute -q 1 flaviocopes.com

O comando `clear` no Linux

Digite clear para limpar todos os comandos anteriores que foram executados no terminal atual.

A tela será limpa e você verá apenas o prompt na parte superior:

Observação: este comando possui um atalho útil: ctrl-L

Depois de fazer isso, você perderá o acesso à rolagem para ver a saída dos comandos inseridos anteriormente.

Portanto, você pode querer usar clear -x que ainda limpa a tela, mas permite voltar para ver o trabalho anterior rolando para cima.

O comando `history` no Linux

Cada vez que você executa um comando, ele é memorizado no histórico.

Você pode exibir todo o histórico usando:

history

Isso mostra a história com números:

Você pode usar a sintaxe ! para repetir um comando armazenado no histórico. No exemplo acima, digitar !121 repetirá ls -al | wc -l.

Normalmente, os últimos 500 comandos são armazenados no histórico.

Você pode combinar isso com grep para encontrar um comando que você executou

history | grep docker

Para limpar o histórico, execute history -c.

O comando `export` no Linux

O comando export é usado para exportar variáveis para processos filhos.

O que isso significa?

Suponha que você tenha uma variável TEST definida assim:

TEST="test"

Você pode imprimir seu valor usando echo $TEST:

No entanto, você pode tentar definir um script Bash em um arquivo script.sh com o comando acima:

Ao definir chmod u+x script.sh e executar este script com ./script.sh, a linha echo $TEST não imprimirá nada!

Isso ocorre porque, no Bash, a variável TEST foi definida localmente no shell. Ao executar um script de shell ou outro comando, um subshell é iniciado para executá-lo, que não contém as variáveis locais do shell atuais.

Para disponibilizar a variável ali precisamos definir TEST não assim:

TEST="test"

Defina-o assim:

export TEST="test"

Tente isso e execute ./script.sh. Agora, ele deve imprimir "test":

Às vezes, você precisa acrescentar algo a uma variável. Geralmente, isso é feito com a variável PATH. Você usa esta sintaxe:

export PATH=$PATH:/new/path

É comum usar export quando você cria variáveis dessa maneira. Você, contudo, também pode usá-lo ao criar variáveis nos arquivos de configuração .bash_profile ou .bashrc com Bash, ou em .zshenv com Zsh.

Para remover uma variável, use a opção -n:

export -n TEST

Chamar export sem qualquer opção listará todas as variáveis exportadas.

O comando `crontab` no Linux

Cron jobs são jobs agendados para execução em intervalos específicos. Você pode fazer com que um comando execute algo a cada hora, todos os dias, a cada 2 semanas ou nos finais de semana.

Eles são muito poderosos, principalmente quando usados em servidores para realizar manutenções e automações.

O comando crontab é o ponto de entrada para trabalhar com tarefas cron.

A primeira coisa que você pode fazer é explorar quais cron jobs são definidos por você:

crontab -l

Você pode não ter nenhum, como eu:

Execute

crontab -e

para editar os cron jobs e adicionar novos.

Por padrão, isso abre com o editor padrão, que geralmente é o vim. Eu gosto mais do nano. Você pode usar esta linha para usar um editor diferente:

EDITOR=nano crontab -e

Agora, você pode adicionar uma linha para cada cron job.

A sintaxe para definir cron jobs é meio assustadora. É por isso que costumo usar um site para me ajudar a gerá-los sem erros: https://crontab-generator.org/

Você escolhe um intervalo de tempo para o cron job e digita o comando a ser executado.

Optei por executar um script localizado em /Users/flavio/test.sh a cada 12 horas. Esta é a linha crontab que preciso executar:

* */12 * * * /Users/flavio/test.sh >/dev/null 2>&1

Eu executo crontab -e:

EDITOR=nano crontab -e

e adiciono essa linha. Então, pressiono ctrl-X e pressiono y para salvar.

Se tudo correr bem, o cron job está configurado:

Feito isso, você pode ver a lista de cron jobs ativos executando:

crontab -l

Você pode remover um cron job executando crontab -e novamente, removendo a linha e saindo do editor:

O comando `uname` no Linux

Chamar uname sem nenhuma opção retornará o codinome do sistema operacional:

A opção m mostra o nome do hardware (x86_64 neste exemplo) e a opção p imprime o nome da arquitetura do processador (i386 neste exemplo):

A opção s imprime o nome do sistema operacional. r imprime o lançamento e v imprime a versão:

A opção n imprime o nome da rede do nó:

A opção a imprime todas as informações disponíveis:

No macOS, você também pode usar o comando sw_vers para imprimir mais informações sobre o sistema operacional macOS. Observe que isso difere da versão Darwin (o Kernel), que acima é 19.6.0.

Darwin é o nome do kernel do macOS. O kernel é o "núcleo" do sistema operacional, enquanto o sistema operacional como um todo é chamado de macOS. No Linux, Linux é o kernel, e GNU/Linux seria o nome do sistema operacional (embora todos nos refiramos a ele como "Linux").

O comando `env` no Linux

O comando env pode ser usado para passar variáveis de ambiente sem configurá-las no ambiente externo (o shell atual).

Suponha que você queira executar uma aplicação do Node.js e definir a variável USER para ele.

Você pode executar

env USER=flavio node app.js

e a variável de ambiente USER estará acessível na aplicação do Node.js por meio da interface Node process.env.

Você também pode executar o comando limpando todas as variáveis de ambiente já definidas, usando a opção -i:

env -i node app.js

Nesse caso, você receberá um erro dizendo env: node: No such file or directory porque o comando node não está acessível, pois a variável PATH usada pelo shell para procurar comandos nos caminhos comuns não está definida.

Então, você precisa passar o caminho completo para o programa node:

env -i /usr/local/bin/node app.js

Experimente com um arquivo app.js simples com este conteúdo:

console.log(process.env.NAME)
console.log(process.env.PATH)

Você verá a saída como

undefined
undefined

Você pode passar uma variável env:

env -i NAME=flavio node app.js

e a saída será

flavio
undefined

A remoção da opção-i tornará o PATH disponível novamente dentro do programa:

O comando env também pode ser usado para imprimir todas as variáveis de ambiente. Se executado sem opções:

env

Ele retornará uma lista das variáveis de ambiente definidas, por exemplo:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

Você também pode tornar uma variável inacessível dentro do programa que você executa, usando a opção -u. Por exemplo, este código remove a variável HOME do ambiente de comando:

env -u HOME node app.js

O comando `printenv` no Linux

Aqui está um guia rápido para o comando printenv, usado para imprimir os valores das variáveis de ambiente

Em qualquer shell, há um bom número de variáveis de ambiente, definidas pelo sistema ou por seus próprios scripts e configurações de shell.

Você pode imprimir todos eles no terminal usando o comando printenv. A saída será algo assim:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

com mais algumas linhas, geralmente.

Você pode anexar um nome de variável como parâmetro, para mostrar apenas o valor dessa variável:

printenv PATH

Conclusão

Muito obrigado por ler este manual.

Espero que ele inspire você a aprender mais sobre o Linux e seus recursos. É um conhecimento perene que não ficará desatualizado tão cedo.

Lembre-se de que você pode fazer download deste manual em PDF/ePUB/Mobi se você quiser!

O autor publica tutoriais de programação diariamente em seu site, flaviocopes.com, se você quiser conferir mais conteúdos excelentes como este.

Você pode entrar em contato com o autor através do Twitter.

Tar no Linux – exemplos de tar GZ, arquivo tar, diretório tar e do comando tar para compressão

Daniel Rosa — Mon, 27 Nov 2023 23:43:01 +0000

Artigo original: Tar in Linux – Tar GZ, Tar File, Tar Directory, and Tar Compress Command Examples

Quer combinar alguns arquivos e diretórios em um único arquivo? O comando tar do Linux é o que você procurava!

O comando tar é usado para comprimir (ou compactar) um grupo de arquivos em um "grande arquivo". O comando também é usado para extrair, manter ou modificar grandes arquivos tar.

Arquivos comprimidos do tar combinam diversos arquivos e/ou diretórios em um único local. Os arquivos comprimidos tar não são necessariamente reduzidos em tamanho, mas podem ser. As permissões são mantidas e o comando dá suporte a vários formatos de compressão.

Aprenda a usar o comando tar com neste artigo.

Sintaxe

tar [opções] [nome_do_arquivo_compactado] [arquivo ou diretório a ser compactado em arquivo]

Options:
-c : cria o arquivo
-x : extrai o arquivo
-f : cria o arquivo com o nome de arquivo sugerido with given filename
-t : exibe ou lista arquivos em um arquivo compactado
-u : arquiva e adiciona a um arquivo compactado existente
-v : exibe informações extensas
-A : concatena os arquivos compactados
-z : comprime o arquivo tar usando gzip
-j : comprime o arquivo tar usando bzip2
-W : verifica um arquivo compactado
-r : atualiza ou adiciona um arquivo ou diretório em um arquivo .tar existente

Exemplos de uso

Extrair um arquivo:
tar xfv arquivo.tar
(opções: x = extrair, f = arquivo, v = com informações extensas)

Criar um arquivo com arquivos ou pastas:
tar cfv arquivo.tar arquivo1 arquivo2 arquivo3
(opções: c = criar)

Criar arquivos comprimidos (compactados):
tar cfzv arquivo.tar arquivo1 arquivo2 arquivo3
(opções: z = comprimir com gzip)

Mostrar todos os arquivos de um arquivo compactado:
tar tvf arquivo.tar

Criar um arquivo não comprimido de todos os arquivo .txt no diretório atual:
tar cfv arquivo.tar *.txt

Extrair arquivos do arquivo compactado arquivo.tar.gz:
tar xvzf arquivo.tar.gz

Criar um arquivo compactado usando o bzip2:
tar cvfj arquivo.tar.tbz exemplo.cpp
(opções: j = comprimir com bzip2, tamanho de arquivo menor, mas que leva mais tempo do que -z)

Atualizar o arquivo tar existente adicionando o arquivo lista_de_tarefas.txt ao arquivo compactado:
tar rvf arquivo.tar lista_de_tarefas.txt
(opções: r = adiciona o arquivo)

Listar o conteúdo do arquivo tar:
tar tf arquivo.tar
(opções: t = exibir, f = arquivo)

Criar um arquivo comprimido a partir do diretório atual, mas excluindo determinados diretórios:
tar --exclude='./pasta' --exclude='./upload/pasta2' cfzv arquivo.tar .("pasta" e "pasta2" são excluídos)

O comando Cat no Linux – como criar um arquivo de texto com Cat ou Touch

Daniel Rosa — Tue, 31 Oct 2023 14:15:03 +0000

Artigo original: The Cat Command in Linux – How to Create a Text File with Cat or Touch

O comando cat é bastante popular e versátil nos ecossistemas Unix e Linux. Existem quatro usos comuns do comando cat. Ele pode exibir um arquivo, concatenar (combinar) diversos arquivos, fazer o echo de texto em tela e criar um arquivo.

Exibição de um arquivo

O uso mais comum do comando cat é o de exibir o conteúdo de um arquivo. Abaixo vemos um exemplo que você pode experimentar.

echo "Dance, Dance" > cat_create #cria um arquivo
cat cat_create

Nesse exemplo simples, usamos uma combinação de echo e um redirecionador para criar um arquivo contendo "Dance, Dance". Em seguida, usamos o comando cat para exibir o conteúdo do arquivo cat_create.

O resultado é este:

O resultado dos comandos do exemplo

(Con)cat(enação)

O exemplo anterior é, de fato, um caso específico da função principal do comando cat, que é concatenar arquivos para exibição. Se usarmos o comado do mesmo modo, mas dando a ele dois ou mais arquivos, ele retorna o resultado da concatenação dos arquivos.

Se executarmos, por exemplo, o seguinte comando:

echo "This is how we do it" > test1 #Cria o primeiro arquivo
echo "*This is how we do it*" > test2 #Cria o segundo arquivo
cat test1 test2

O resultado é o conteúdo do primeiro arquivo, test1, seguido do conteúdo do segundo arquivo, test2. Você pode dar ao comando cat diversos arquivos. Ele concatenará (combinará) todos eles. Perceba, no entanto, que o comando cat vai inserir automaticamente uma quebra de linha entre os resultados.

O resultado dos dois arquivos concatenados

cat também fornece alguns switches para realizar ações como exibir caracteres não imprimíveis (-v) ou numerar as linhas (-n). Um detalhamento completo pode ser encontrado nas páginas do man (em inglês).

Uso de echo

Este é um uso menos comum de cat, mas é a base para a próxima seção. Se você executar o comando cat, simplesmente, ele será executado em modo interativo, fazendo echo (repetindo em tela) tudo o que você digitar até que você saia do comando.

Usando cat em modo interativo

Nesse exemplo, digitei uma única palavra por linha. Cada vez que eu pressionava Enter, a linha era repetida logo abaixo.

Também é possível fazer o pipe de texto com o cat. Nesse caso, o texto é reproduzido no echo. Por exemplo:

echo "Piping fun" | cat

O resultado será o seguinte:

Texto com piping no cat

Criação de arquivos

Nos exemplos anteriores, usamos o comando echo redirecionado para um arquivo para criar outros arquivos. cat pode ser usado de maneira similar. De fato, podemos usar a concatenação de cat e a funcionalidade de echo para criar arquivos.

Podemos criar um arquivo com a concatenação de diversos arquivos assim:

echo "File 1 Contents" > file1
echo "File 2 Contents" > file2
echo "File 3 Contents" > file3
cat file1 file2 file3 > combined_file
cat combined_file

No exemplo acima, criamos três arquivos usando echo, combinamos os três arquivos em um só usando cat e exibimos o arquivo combinado usando cat.

O resultado dos comandos acima. Criamos três arquivos e combinamos os três em um único arquivo usando o cat

Também podemos usar o modo interativo de cat para criar um arquivo com o texto que digitarmos no terminal.

Cada vez que você pressionar Enter, ele colocará o texto digitado no arquivo. Se você digitar algum texto, não pressionar Enter e sair, o texto digitado não será capturado no arquivo.

Esse é um modo incrível de criar um arquivo com a capacidade de inserir conteúdo nesse arquivo rapidamente.

**Uso de touch para criar arquivos**

Às vezes, é preciso apenas que um arquivo exista. Como alternativa ao uso de cat para criar arquivos, é possível usar o comando touch.

O comando touch foi criado para atualizar a timestamp modificada de um arquivo, mas é normalmente usado como um modo rápido de criar um arquivo vazio. Aqui, vemos um exemplo de uso:

touch nome_do_novo_arquivo

O comando touch pode criar diversos arquivos, atualizar a modificação e/ou a criação de timestamps e muitas outras coisas úteis. As páginas completas do man (em inglês) estão no link.

touch normalmente é usado para garantir que um arquivo exista. Ele é um ótimo comando para quando precisamos de um arquivo vazio rapidamente.

Resumo

cat é um comando muito útil. Você pode usá-lo para criar, exibir e combinar arquivos de texto fácil e rapidamente.

Se você apenas precisa que um arquivo exista, mas não se importa com o fato de que ele esteja vazio, usar touch é uma ótima alternativa.

Hughie Coles é um líder em desenvolvimento na Index Exchange. Ele escreve sobre arquitetura de software, escalabilidade, liderança e cultura. Para ver mais textos escritos por ele (em inglês), confira a página do autor no Medium.

O comando tar no Linux: Tar CVF e tar XVF explicados com comandos de exemplo

Daniel Rosa — Wed, 16 Aug 2023 01:34:13 +0000

Artigo original: The Tar Command in Linux: Tar CVF and Tar XVF Explained with Example Commands

O nome tar é, de acordo com a maior parte dos relatos, uma abreviação para tape archive (arquivo de fitas, em português). As "fitas" em questão seriam todas aquelas unidades de armazenamento magnético que eram populares na década de 1950.

Isso sugere que a ferramenta tar pode ser um pouco antiga e ter passado de seu auge. A verdade, porém, é que, ao longo de todos os anos e passando por todas as mudanças sísmicas que ocorreram no mundo da TI, o tar não perdeu em nada o seu poder e valor.

Neste artigo, com base no conteúdo do meu livro Linux in Action (em inglês), vou mostrar os conceitos básicos de criação, compactação e restauração de arquivos tar. Comecemos pelo início.

Criação de arquivos

Este exemplo pegará todos os arquivos e diretórios dentro e sob o diretório de trabalho atual e criará um arquivo que chamei, inteligentemente, de nomedoarquivo.tar.

Aqui eu uso três argumentos após o comando tar:

c diz ao tar para criar um arquivo,
v define o resultado em tela como extenso (do inglês, verbose) para que eu obtenha as atualizações, e
f aponta para o nome do arquivo que eu desejo dar ao arquivo.

O * informa ao tar que ele deve incluir todos os arquivos e diretórios locais de modo recursivo.

$ tar cvf nomedoarquivo.tar *
arquivo1
arquivo2
arquivo3
diretorio1
diretorio1/maiscoisas
diretorio1/maiscoisas/arquivo100
diretorio1/maiscoisas/arquivo101

O comando tar nunca moverá ou excluirá nenhum dos diretórios e arquivos originais com os quais você o alimentou – ele só faz cópias arquivadas.

Você também deve observar que o uso de um ponto (.) em vez de um asterisco (*) no comando anterior incluiria até mesmo arquivos ocultos (cujos nomes de arquivos começam com um ponto) no arquivo.

Se você estiver acompanhando em seu próprio computador (como você definitivamente deveria estar fazendo), verá um novo arquivo chamado nomedoarquivo.tar. A extensão de nome de arquivo .tar não é necessária, mas é sempre uma boa ideia comunicar claramente o propósito de um arquivo de tantas maneiras quantas possível.

Extrair seu arquivo para restaurar os arquivos é fácil: basta usar xvf em vez de cvf. Isso, no exemplo, salvará novas cópias dos arquivos e diretórios originais no local atual.

$ tar xvf nomedoarquivo.tar
arquivo1
arquivo2
arquivo3
diretorio1
diretorio1/maiscoisas
diretorio1/maiscoisas/arquivo100
diretorio1/maiscoisas/arquivo101

Claro, você também pode pedir ao tar que envie seus arquivos extraídos para outro lugar usando o argumento -C, seguido do local de destino:

$ tar xvf nomedoarquivo.tar -C /home/meusdados/arquivosantigos/

Nem sempre você vai querer incluir todos os arquivos de uma árvore de diretório em seu arquivo.

Suponha que você tenha produzido alguns vídeos, mas eles são atualmente mantidos em diretórios junto com todos os tipos de arquivos gráficos, de áudio e de texto (contendo suas notas). Os únicos arquivos de que você precisa fazer o back-up são os clipes do vídeo final usando a extensão de nome de arquivo .mp4.

Fazemos isso assim:

$ tar cvf nomedoarquivo.tar *.mp4

Fantástico. Esses arquivos de vídeo, no entanto, são enormes. Não seria bom tornar esse arquivo um pouco menor usando a compactação?

Seu pedido é uma ordem! Basta executar o comando anterior com o argumento z (zip). Isso dirá ao programa gzip para compactar o arquivo.

Se você quiser seguir a convenção, também pode adicionar uma extensão .gz, além da extensão .tar, que já está lá. Lembre-se: clareza.

Seria assim:

$ tar czvf nomedoarquivo.tar.gz *.mp4

Se você tentar isso em seus próprios arquivos .mp4 e se, em seguida, executar ls -l no diretório que contém os novos arquivos, você pode notar que o arquivo .tar.gz não é muito menor do que o arquivo .tar, talvez 10% ou mais. Para que fazer isso, então?

Bem, o formato de arquivo .mp4 é compactado. Assim, há muito menos espaço para o gzip fazer sua mágica.

Como o tar está totalmente ciente de seu ambiente Linux, você pode usá-lo para selecionar arquivos e diretórios que vivem fora do diretório de trabalho atual. Este exemplo adiciona todos os arquivos .mp4 no diretório /home/meuusuario/Videos/:

$ tar czvf nomedoarquivo.tar.gz /home/meuusuario/Videos/*.mp4

Como os arquivos podem ficar grandes, às vezes, pode fazer sentido dividi-los em vários arquivos menores, transferi-los para sua nova casa e, em seguida, recriar o arquivo original na outra extremidade. A ferramenta de divisão é feita para este fim.

Neste exemplo, -b diz ao Linux para dividir o arquivo nomedoarquivo.tar.gz em partes de 1 GB. Em seguida, a operação nomeia cada uma das partes — nomedoarquivo.tar.gz.partaa, nomedoarquivo.tar.gz.partab, nomedoarquivo.tar.gz.partac e assim por diante:

$ split -b 1G nomedoarquivo.tar.gz "nomedoarquivo.tar.gz.part"

Por outro lado, você recria o arquivo lendo cada uma das partes em sequência (cat nomedoarquivo.tar.gz.part*) e, em seguida, redireciona a saída para um novo arquivo chamado nomedoarquivo.tar.gz:

$ cat nomedoarquivo.tar.gz.part* > nomedoarquivo.tar.gz

Utilizando a stream de arquivos do sistema de arquivos

É aqui que a parte boa começa. Vou mostrar como criar uma imagem de arquivo a partir de uma instalação do Linux em funcionamento e transmiti-la para um local de armazenamento remoto — tudo dentro de um único comando. Aqui está o comando:

# tar czvf - --one-file-system / /usr /var \
  --exclude=/home/andy/ | ssh username@10.0.3.141 \
  "cat > /home/nomedousuario/workstation-backup-Apr-10.tar.gz"

Em vez de tentar explicar tudo isso imediatamente, vou usar exemplos menores para explorar o comando aos poucos.

Vamos criar um arquivo de conteúdo de um diretório chamado coisasimportantes que está cheio de, você adivinhou, coisas realmente importantes:

$ tar czvf - coisasimportantes/ | ssh nomedousuario@10.0.3.141 "cat > /home/nomedousuario/meusarquivos.tar.gz"
coisasimportantes/arquivo1
coisasimportantes/arquivo2
[...]
nomedousuario@10.0.3.141's password:

Vamos explicar esse exemplo. Em vez de digitar o nome do arquivo logo após os argumentos de comando (da maneira que você fez até agora), usei um traço (czvf -).

O traço gera dados para a saída padrão. Ele permite que você envie os detalhes do nome do arquivo de volta para o final do comando e diz ao tar para esperar o conteúdo de origem para o arquivo.

Em seguida, usei um pipe (|) para enviar o arquivo compactado e sem nome para um login de ssh em um servidor remoto onde me foi pedida a minha senha.

O comando entre aspas executou cat no stream de dados do arquivo, que gravou o conteúdo do fluxo (do inglês, stream) em um arquivo chamado meusarquivos.tar.gz no meu diretório home no host remoto.

Uma vantagem de gerar arquivos dessa maneira é que você evita a sobrecarga de uma etapa intermediária. Não há necessidade de salvar temporariamente uma cópia do arquivo na máquina local. Imagine fazer back-up de uma instalação que ocupa 110 GB de seus 128 GB de espaço disponível. Para onde vai o arquivo?

Isso era apenas um diretório de arquivos. Suponha que você precise fazer o back-up de um sistema operacional Linux ativo em uma unidade USB para poder movê-lo para uma máquina separada e soltá-lo na unidade principal dessa máquina.

Supondo que já haja uma nova instalação da mesma versão do Linux na segunda máquina, a próxima operação de copiar/colar gerará uma réplica exata da primeira.

OBSERVAÇÃO: isso não funcionará em uma unidade de destino que não tenha um sistema de arquivos do Linux instalado. Para lidar com a situação, você precisará usar dd.

O próximo exemplo cria um arquivo compactado em uma unidade USB, conhecida como /dev/sdc1.

O argumento --one-file-system exclui todos os dados de qualquer sistema de arquivos que não seja o atual. Isso significa que as pseudopartições, como /sys/ e /dev/, não serão adicionadas ao arquivo. Se houver outras partições que você deseja incluir (como /usr/ e /var/, neste exemplo), elas devem ser adicionadas explicitamente.

Por fim, você pode excluir dados do sistema de arquivos atual usando o argumento --exclude:

# tar czvf /dev/sdc1/workstation-backup-Apr-10.tar.gz \
  --one-file-system \
  / /usr /var \
  --exclude=/home/andy/

Voltemos ao exemplo do comando de serviço completo. Usando o que você já aprendeu, arquive todos os diretórios importantes de um sistema de arquivos e copie o arquivo para uma unidade USB. Isso deve fazer sentido para você agora:

# tar czvf - --one-file-system / /usr /var \
  --exclude=/home/andy/ | ssh nomedousuario@10.0.3.141 \
  "cat > /home/nomedousuario/workstation-backup-Apr-10.tar.gz"

Há muito mais coisas interessantes em termos de administração do seu sistema, na forma de livros, cursos e artigos disponíveis no site do autor, bootstrap-it.com (em inglês).

O comando Chmod – como alterar permissões de arquivos no Linux

Daniel Rosa — Wed, 12 Jul 2023 21:00:00 +0000

Artigo original: Chmod Command – How to Change File Permissions in Linux

Um dos primeiros comandos que aprendi no Linux foi o comando touch, que cria um arquivo usando a linha de comando.

Se você tentar criar, por exemplo, um arquivo de texto, tudo o que você precisa fazer é digitar touch filename.txt e pressionar Enter. O arquivo será criado para você no diretório em que você está. Você pode, então, escrever o que quiser usando o editor de arquivos de sua escolha.

No entanto, quando se trata de criar scripts, as coisas podem ficar um pouco mais complicadas. Por quê?

Vou tentar demonstrar isso com outro exemplo. Suponha que você queira criar um script usando o touch. Digite touch example.sh, pressione Enter e pronto. Mais uma vez, você pode escrever nele usando um editor de arquivos.

Com tudo pronto, só falta testá-lo. Você digita ./sample.sh e pressiona Enter para ver seu script em ação e... o que essa mensagem está me dizendo?

Por que precisamos de permissões?

Espere aí. Eu sou o admin! Como assim eu não tenho permissão para executar um script que eu mesmo escrevi agora há pouco?

Na verdade, existe um motivo – e, para ser honesto, a maioria dos usuários deve ser grata por isso, já que não ser capaz de executar scripts sem saber o que você está fazendo, muitas vezes, impede que você coloque seu sistema em risco.

Vamos conversar rapidamente sobre permissões primeiro. Depois, vamos descobrir como mudá-las.

Para obter mais informações sobre seu arquivo, usaremos o comando que lista os arquivos em um diretório: ls.

Depois de digitar ls e pressionar Enter, isto é o que obtemos na linha de comando:

O que ele faz é listar todos os arquivos visíveis no diretório que você está no momento. Ao adicionar a flag -l a ele, ele fornece mais informações sobre os arquivos no diretório. Este é o resultado quando digitamos ls -l e pressionamos Enter:

Vemos o(s) mesmo(s) arquivo(s), mas com muitas informações antes dele(s). Para começar, temos uma sequência de dez traços e letras que podem parecer sem sentido no início. Este é, na verdade, o mapeamento de permissões que seu arquivo tem.

O primeiro caractere pode ser um traço (-, para um arquivo comum), um d (para um diretório) ou um l (para um soft link). Por uma questão de simplicidade, vou me concentrar nos arquivos simples, embora as permissões sejam válidas para todos esses tipos de arquivos/pastas.

Após o primeiro caractere, os outros 9 podem ser divididos em grupos de três. O primeiro trio mostra as permissões para o usuário atual. A seguir, temos as permissões para esse grupo. Os três últimos caracteres são as permissões para todos os usuários que não se encaixam nessas categorias.

Para nossa explicação, vamos nos concentrar nas três primeiras permissões, já que não vamos mudar de grupo ou algo do tipo.

O primeiro trio diz rw-.

Hora de entender o que isso significa. Há três coisas que você normalmente pode fazer com um arquivo: lê-lo, gravá-lo e executá-lo. Ou seja, basicamente, o que essas letras significam.

O primeiro r significa a permissão de leitura (do inglês, read). Então, temos w para a permissão de escrita (do inglês, write). Finalmente, um traço, ou seja, que aquilo que deveria estar ali, não está. O que deveria estar ali é um x, que significa eXecutável (do inglês, executable).

Então, falando sobre o usuário atual (eu), as permissões que tenho para esse arquivo são as permissões de leitura e gravação. No entanto, não consigo executar o arquivo sample.sh. É por isso que, ao tentar executar o arquivo, recebi a mensagem 'Permission denied' (em português, permissão negada).

Como posso então executar este arquivo? É aí que o comando chmod entra em jogo.

**O que faz o chmod?**

Bem, eu venho mencionando "permissões" desde o início do artigo. Vamos estender um pouco essa explicação para dizer que elas são 'permissões para acessar um arquivo em um determinado modo. Isso significa que r denota a permissão para acessar o arquivo no modo de leitura, w denota a permissão para acessar o arquivo no modo de gravação e x denota a permissão para acessar o arquivo no modo executável.

Por que estou dizendo isso? Em função do comando deste artigo. chmod significa 'change mode' (em português, alterar o modo). Em outras palavras, ao usar esse comando, você está alterando o modo de um arquivo para o(s) modo(s) que deseja usar.

Como usar operadores com o `chmod`

É necessário usar um operador com o comando chmod. Ele serve para especificar o tipo de alteração que você deseja fazer nas permissões.

Por exemplo, + é o operador que você usa para adicionar uma permissão àquelas que o arquivo já tem. - remove uma permissão da lista. Há também o operador =, que redefine as permissões para que você possa defini-las novamente.

No nosso caso, ao digitar chmod -w sample.sh, o que estou pedindo ao comando é que remova a permissão de escrita. Então, o que eu teria que fazer para adicionar a permissão de execução do arquivo é digitar chmod +x sample.sh.

Se eu tentar executar o arquivo, o que eu colocar no script agora poderá ser executado.

Usando ls -l, isso é o que eu teria agora:

Quem recebe as permissões?

Outra coisa que vale a pena ressaltar é quem está recebendo essa permissão. Você verá que o 'x' é dado a todos os usuários, ao proprietário do arquivo, ao grupo e a outros. Se isso não é o que você quer, talvez seja uma coisa boa remover a permissão de execução novamente com chmod -x sample.sh.

Para habilitar a permissão apenas para o proprietário do arquivo (eu, nesse caso), devemos adicionar um 'u' antes do '+x', assim:

chmod u+x sample.sh

Ao digitar ls -l, eis o que temos:

Se você quisesse dar a permissão para o proprietário e seu grupo, então o comando seria chmod ug+x sample.sh.

Bem, acho que isso cobre o que eu gostaria de mostrar a vocês. Há outras coisas que podem ser de seu interesse, como usar chmod com valores octais ou binários para representar as permissões. Esses, porém, são modos que usamos para ter os mesmos resultados e acredito que as letras são uma maneira mais fácil de alcançá-los.

Caso você queira mais informações sobre o comando, uma coisa que você pode fazer é digitar chmod --help, que dará a você uma versão resumida sobre o que o comando pode fazer. Uma descrição ainda mais detalhada pode ser obtida digitando man chmod.

Espero que este artigo tenha sido útil. Para ver mais artigos sobre comandos no Linux em português, confira o editorial do freeCodeCamp em português.

Uma ótima programação para você! 😃

Lista de processos do Linux – como verificar os processos em execução

Giálisson Rocha — Sun, 07 May 2023 21:00:00 +0000

Artigo original: Linux List Processes – How to Check Running Processes

Todos os dias, os desenvolvedores usam várias aplicações e executam comandos no terminal. Essas aplicações podem incluir um navegador, editor de código, terminal, aplicação de videochamada ou reprodutor de música.

Para cada uma dessas aplicações de software que você abre ou comando que executa, ele cria um processo ou tarefa.

Uma bela característica do sistema operacional Linux e dos computadores modernos em geral é que eles fornecem suporte para multitarefas. Assim, vários programas podem ser executados simultaneamente.

Você já se perguntou como você pode verificar todos os programas em execução na sua máquina? Se já fez isso, este artigo é para você, pois vou mostrar aqui como listar, gerenciar e eliminar todos os processos em execução em sua máquina Linux.

Pré-requisitos

Uma distro Linux instalada.
Conhecimento básico em navegação pela linha de comando.
Um sorriso no rosto 😀

Uma introdução rápida aos processos no Linux

Um processo é uma instância de um programa de computador em execução que você pode encontrar em um programa de software ou comando.

Por exemplo, se você abrir o editor do Visual Studio Code, isso criará um processo que somente será finalizado uma vez que você termine ou feche o Visual Studio Code.

Da mesma forma, quando você executa um comando no terminal (tipo curl ifconfig.me), ele cria um processo que só vai parar quando o comando terminar de executar ou for finalizado.

Como listar os processos em execução no Linux com o comando `ps`

Você pode listar os processos em execução usando o comando ps (ps significa process status). O comando ps exibe seus processos em execução no momento e em tempo real.

Para testar isso, basta abrir o terminal e executar o comando ps, assim:

Isto mostrará o processo que está em execução em quatro colunas:

PID retorna o ID exclusivo do processo
TTY retorna o tipo de terminal em que você está logado
TIME retorna a quantidade total de uso da CPU
CMD retorna o nome do comando que iniciou o processo.

Você pode escolher exibir um determinado conjunto de processos usando qualquer combinação das opções (como -A -a, -C, -c, -d, -E, -e, -u, -X, -x, entre outros).

Se você especificar mais de uma dessas opções, todos os processos que forem combinados por, pelo menos, uma das opções indicadas serão exibidas.

A página do manual do comando ps.

Digite man ps no seu terminal para ler o manual do comando ps, que tem uma referência completa para todas as opções e suas utilizações.

Para mostrar todos os processos em execução para todos os usuários na sua máquina, incluindo os seus nomes de usuário, e para mostrar processos não conectados ao seu terminal, é possível usar o comando abaixo:

ps aux

Aqui está uma descrição do comando:

ps: é o comando de status do processo.
a: exibe informações sobre os processos de outros usuários, bem como os seus.
u: exibe os processos pertencentes aos nomes de usuário especificados.
x: inclui processos que não possuem terminal de controle.

Isso exibirá o processo para o shell atual em onze colunas:

USER retorna o nome de usuário de quem está executando o processo
PID retorna o ID de processo exclusivo
%CPU retorna a porcentagem de uso da CPU
%MEM retorna a porcentagem de uso da memória
VSV retorna o tamanho virtual em Kbytes
RSS retorna o tamanho do conjunto residente
TT retorna o nome do terminal de controle
STAT retorna o estado do processo simbólico
STARTED retorna a hora de início
CMD retorna o comando que iniciou o processo.

Como listar processos em execução no Linux usando os comandos `top` e `htop`

Você também pode usar o comando top do gerenciador de tarefas no Linux para ver uma lista ordenada em tempo real dos processos principais que usam mais memória ou CPU.

Digite top em seu terminal e você terá um resultado como o que você vê na captura de tela abaixo:

Você pode digitar q para sair da sessão.

Uma alternativa ao top é o htop que fornece um monitor de sistema interativo para visualizar e gerenciar processos. Ele também exibe uma lista ordenada em tempo real de processos com base em seu uso de CPU. Você pode facilmente pesquisar, filtrar e matar processos em execução.

O htop não está instalado no Linux por padrão. Então, você precisa instalá-lo usando o comando abaixo ou baixar os binários para sua distro Linux preferida.

sudo apt update && sudo apt install htop

Basta digitar htop em seu terminal e você terá um resultado como o que você vê na captura de tela abaixo:

Como encerrar processos em execução no Linux

Encerrar um processo significa que você termina uma aplicação ou comando em execução. Você pode encerrar um processo executando o comando kill com o ID do processo ou o comando pkill juntamente ao nome do processo, assim:

kill [PID]

pkill [COMMAND]

Para encontrar o ID de um processo em execução, você pode usar o comando pgrep seguido do nome do processo, deste modo:

pgrep iTerm2

Para encerrar o processo iTerm2 na captura de tela acima, usaremos qualquer um dos comandos abaixo. Isto terminará e fechará automaticamente o processo iTerm2 (aplicação).

kill 25781

kill iTerm2

Conclusão

Quando você lista processos em execução, geralmente é uma lista longa e agrupada. Você pode canalizá-la através de poucas palavras para exibir a saída do comando uma página de cada vez em seu terminal assim:

ps aux | less

Também é possível exibir apenas um processo específico que corresponda a um nome específico, assim:

ps aux | grep Chrome

Espero que, agora, você entenda o que são processos no Linux e como gerenciá-los usando os comandos ps, top e htop. Certifique-se de verificar o manual para cada comando, executando man ps, man top ou man htop, respectivamente. O manual inclui uma referência abrangente que você pode verificar se precisar de mais ajuda em qualquer ponto.

Obrigado pela leitura! Tudo de bom! 💙

Linux: como adicionar e criar usuários com useradd

Daniel Rosa — Sun, 08 May 2022 21:39:52 +0000

Artigo original: Linux: How to Add Users and Create Users with useradd

Se mais de uma pessoa estiver usando sua máquina com Linux em casa ou se você estiver gerenciando um servidor que fornece acesso a diversos usuários, o comando useradd é essencial para a criação de usuários.

Além disso, muitos serviços que você utiliza como desenvolvedor podem exigir suas próprias contas de usuário para funcionarem. Assim, mesmo como um desenvolvedor sozinho em sua própria máquina, você pode se encontrar buscando esses comandos ao instalar o MySQL ou algo semelhante.

Você pode obter uma visão geral completa das várias opções disponíveis visualizando a página de manual (man) para o utilitário: man useradd

Se, no entanto, isso for demais para você assimilar, aqui temos uma análise de algumas das opções mais comuns e que você pode encontrar ao criar um usuário.

Criar um usuário

O formato simples desse comando é useradd [opções] NOME_DE_USUARIO.

Por exemplo, useradd teste (como usuário root - insira sudo antes se não estiver registrado como root).

Esse comando criará um usuário chamado teste, mas é uma operação limitada e não criará outras coisas úteis, como seu diretório home ou sua senha!

Adicionar uma senha

Você, então, deve adicionar a senha para o usuário teste usando o comando passwd: passwd teste. Isso solicitará que você insira uma senha para o usuário.

Existe uma opção para adicionar uma senha criptografada por meio da opção -p de useradd, mas ela não é recomendada por razões de segurança.

Observe que a opção -p não permite que você insira uma senha de texto simples. Ela espera que você a criptografe primeiro. Isso é difícil de propósito, pois você não deve fazê-lo! Simplesmente use o comando passwd.

Outras opções comuns

Diretório home

Para criar um usuário com o diretório home padrão, use a opção abaixo:

useradd -m teste

Esse usuário agora terá um diretório /home/teste.

Você pode passar uma opção adicional para alterar um diretório home, por exemplo:

useradd -m -d /alternate teste

Shell

Por padrão, seus usuários criados provavelmente terão o shell de login padrão bin/bash ou bin/sh, que serão definidos em /etc/default/useradd.

Você pode sobrescrever esse padrão com a opção -s:

useradd -s usr/bin/zsh teste

Unir todas as opções

Para construir o comando inteiro, coloque as opções uma após a outra - a ordem não é importante - e encerre com o nome de usuário que você quer criar.

Assim, para criar um usuário chamado user com um diretório home e um shell personalizado, seu comando teria a seguinte aparência:

useradd -m -s /usr/bin/zsh user

Depois, você adicionaria uma senha para o usuário: passwd user

Não se esqueça de ler o manual

Agora que você já viu o básico sobre o que pode fazer essa ferramenta, espero que a página do manual (man) seja mais navegável.

man useradd mostrará para você como adicionar coisas como datas de validade na conta, atribuir grupos e assim por diante.

O processo de inicialização do Linux - 6 etapas descritas em detalhes

Fernando Mota Freitas — Thu, 03 Feb 2022 14:34:06 +0000

Artigo original: The Linux Booting Process - 6 Steps Described in Detail

Um sistema operacional (SO) é o software de baixo nível que gerencia recursos, controla periféricos e fornece serviços básicos para outros softwares. No Linux, existem 6 estágios distintos no processo de inicialização típico.

1. BIOS

BIOS significa Basic Input/Output System. Em termos simples, o BIOS carrega e executa o carregador de inicialização Master Boot Record (MBR).

Quando você liga o computador pela primeira vez, a primeira coisa que o BIOS faz é executar algumas verificações de integridade do HDD ou SSD.

Em seguida, o BIOS procura, carrega e executa o programa carregador de inicialização, que pode ser encontrado no Master Boot Record (MBR). O MBR às vezes está em um pendrive ou CD-ROM, como em uma instalação em formato live-USB do Linux.

Uma vez que o programa carregador de inicialização é detectado, ele é carregado na memória e o BIOS dá o controle do sistema a ele.

2. MBR

MBR significa Master Boot Record e é responsável por carregar e executar o carregador de inicialização GRUB.

O MBR está localizado no 1º setor do disco inicializável, que normalmente é /dev/hda ou /dev/sda, dependendo do seu hardware. O MBR também contém informações sobre o GRUB, ou LILO em sistemas muito antigos.

3. GRUB

Às vezes chamado de GNU GRUB, que é a abreviação de GNU GR e Unified Bootloader, é o carregador de inicialização típico para a maioria dos sistemas Linux modernos.

A tela inicial do GRUB geralmente é a primeira coisa que você vê quando inicializa seu computador. Tem um menu simples onde você pode selecionar algumas opções. Se você tiver várias imagens de kernel instaladas, poderá usar o teclado para selecionar aquela com a qual deseja que seu sistema inicialize. Por padrão, a imagem do kernel mais recente é selecionada.

A tela inicial aguarda alguns segundos para você selecionar uma opção. Se você não fizer isso, ele carregará a imagem padrão do kernel.

Em muitos sistemas, você pode encontrar o arquivo de configuração do GRUB em /boot/grub/grub.conf ou /etc/grub.conf. Aqui está um exemplo de um arquivo grub.conf simples:

#boot=/dev/sda
default=0
timeout=5
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
hiddenmenu
title CentOS (2.6.18-194.el5PAE)
      root (hd0,0)
      kernel /boot/vmlinuz-2.6.18-194.el5PAE ro root=LABEL=/
      initrd /boot/initrd-2.6.18-194.el5PAE.img

4. Núcleo

O kernel é muitas vezes referido como o núcleo de qualquer sistema operacional, incluindo o Linux. Ele tem controle total sobre tudo em seu sistema.

Neste estágio do processo de inicialização, o kernel que foi selecionado pelo GRUB primeiro monta o sistema de arquivos raiz especificado no arquivo grub.conf. Em seguida, executa o programa /sbin/init, que é sempre o primeiro programa a ser executado. Você pode confirmar isso com seu ID de processo (PID), que deve ser sempre 1.

O kernel então estabelece um sistema de arquivos raiz temporário usando o disco RAM inicial (initrd) até que o sistema de arquivos real seja montado.

5. Iniciar

Neste ponto, seu sistema executa programas de nível de execução. Em um ponto, ele procuraria um arquivo init, geralmente encontrado em /etc/inittabpara decidir o nível de execução do Linux.

Os sistemas Linux modernos usam o systemd para escolher um nível de execução. De acordo com a TecMint , estes são os níveis de execução disponíveis:

O nível de execução 0 é correspondido por poweroff.target (e runlevel0.target é um link simbólico para poweroff.target ).

O nível de execução 1 é correspondido por rescue.target (e runlevel1.target é um link simbólico para rescue.target ).

O nível de execução 3 é emulado por multi-user.target (e runlevel3.target é um link simbólico para multi-user.target ).

O nível de execução 5 é emulado por graphical.target(e runlevel5.target é um link simbólico para graphical.target ).

O nível de execução 6 é emulado por reboot.target (e runlevel6.target é um link simbólico para reboot.target ).

Emergency é correspondido por Emergency.target .

O systemd então começará a executar programas de nível de execução.

6. Programas de nível de execução

Dependendo de qual distribuição Linux você instalou, você poderá ver diferentes serviços sendo iniciados. Por exemplo, você pode pegar starting sendmail …. OK.

Eles são conhecidos como programas de nível de execução e são executados a partir de diretórios diferentes, dependendo do nível de execução. Cada um dos 6 níveis de execução descritos acima tem seu próprio diretório:

Nível de execução 0 –/etc/rc0.d/
Nível de execução 1 –/etc/rc1.d/
Nível de execução 2 –/etc/rc2.d/
Nível de execução 3 –/etc/rc3.d/
Nível de execução 4 –/etc/rc4.d/
Nível de execução 5 –/etc/rc5.d/
Nível de execução 6 –/etc/rc6.d/

Observe que a localização exata desses diretórios varia de distribuição para distribuição.

Se você procurar nos diferentes diretórios de nível de execução, encontrará programas que começam com "S" ou "K" para inicialização e eliminação, respectivamente. Os programas de inicialização são executados durante a inicialização do sistema e eliminam os programas durante o desligamento.

Isso é tudo que você precisa saber sobre o processo de inicialização do Linux. Agora vá lá e deixe Tux orgulhoso.

Tutorial de symlink no Linux – Como criar e remover um link simbólico

Daniel Rosa — Tue, 23 Nov 2021 01:16:25 +0000

Artigo original: Symlink Tutorial in Linux – How to Create and Remove a Symbolic Link

Um symlink (também chamado de link simbólico) é um tipo de arquivo no Linux que aponta para outro arquivo ou diretório em seu computador. Os symlinks são semelhantes aos atalhos no Windows.

Alguns chamam os symlinks de "soft links" – um tipo de link nos sistemas Linux/UNIX – em oposição aos "hard links."

Diferença entre um soft link e um hard link

Os soft links lembram os atalhos, podendo apontar para outro arquivo ou diretório em qualquer sistema de arquivos.

Os hard links também são atalhos para pastas e diretórios, mas um hard link não pode ser criado para um arquivo ou diretório em um sistema de arquivos diferente.

Vamos ver os passos envolvidos na criação e remoção de um symlink. Também veremos o que são links quebrados e como excluí-los.

Como criar um symlink

A sintaxe para a criação de um symlink é:

ln -s

ln é o comando para links. A flag -s especifica que o link tem de ser um soft link. O -s também pode ser inserido como -symbolic.

Por padrão, o comando ln cria hard links. O próximo argumento é o caminho para o arquivo ou diretório para onde você quer fazer um link (ou seja, o arquivo ou diretório para o qual você quer criar um atalho).

O último argumento é o caminho para o link em si (o atalho).

Como criar um symlink para um arquivo – comando de exemplo

ln -s /home/james/transactions.txt trans.txt

Após executar esse comando, você poderá acessar o arquivo /home/james/transactions.txt usando trans.txt. Qualquer modificação feita em trans.txt será refletida no arquivo original.

Observe que esse comando acima criará o arquivo de link trans.txt em seu diretório atual. Também é possível criar um arquivo vinculado em um diretório assim:

ln -s /home/james/transactions.txt my-stuff/trans.txt

Deve haver um diretório chamado "my-stuff" no seu diretório atual – do contrário, o comando lançará um erro.

Como criar um symlink para um diretório – comando de exemplo

Da mesma forma que acima, podemos usar:

ln -s /home/james james

Isso criaria um diretório vinculado por symlink chamado 'james', que teria o conteúdo de /home/james. Quaisquer mudanças a este diretório vinculado também afetarão o diretório original.

Como remover um symlink

Antes de querer remover um symlink, confirme se o arquivo ou o diretório é um symlink, para não bagunçar seus arquivos.

Uma maneira de fazer isso é:

ls -l

Ao executar esse comando no seu terminal, serão exibidas as propriedades do arquivo. No resultado, se o primeiro caractere for uma letra L minúscula ('l'), significa que o arquivo/diretório é um symlink.

Você também verá uma seta (->) ao final indicando o arquivo/diretório para o qual o symlink aponta.

Há dois métodos de remover um symlink:

Como usar unlink para remover um symlink

A sintaxe é:

unlink

Isso exclui o symlink se o processo tiver êxito.

Mesmo se o symlink estiver na forma de um diretório, não inclua '/', pois o Linux assumirá que é um diretório e unlink não pode excluí-los.

Como usar rm para remover um symlink

Como vimos, um symlink é apenas outro arquivo ou diretório que aponta para um arquivo ou diretório original. Para remover essa relação, é possível remover o arquivo vinculado.

Assim, a sintaxe é:

rm

Por exemplo:

rm trans.txt
rm james

Observe que tentar executar rm james/ resultaria em um erro, pois o Linux assumirá que 'james/' é um diretório, o que exigiria outras opções, como r e f. No entanto, não é isso que queremos. Um symlink pode ser um diretório, mas estamos interessados apenas no nome.

O benefício principal de rm com relação a unlink é o fato de você poder remover diversos symlinks ao mesmo tempo, do mesmo jeito que você remove arquivos.

Como encontrar e excluir links quebrados

Links quebrados ocorrem quando o arquivo ou o diretório para o qual um symlink aponta muda de caminho ou é excluído.

Por exemplo, se 'transactions.txt' mudasse de /home/james para /home/james/personal, o link 'trans.txt' estaria quebrado. Qualquer tentativa de acessar o arquivo resultaria em um erro 'No such file or directory' (O arquivo ou diretório não existe). Isso ocorre porque o link não tem conteúdo próprio.

Ao descobrir links quebrados, você pode excluir o arquivo com facilidade. Um modo fácil de excluir symlinks quebrados é:

find /home/james -xtype l

Isso listará todos os symlinks quebrados no diretório james – de arquivos, diretórios e subdiretórios.

Ao passar a opção -delete, você os excluirá, dessa forma:

find /home/james -xtype l -delete

Para concluir

Os links simbólicos são um recurso interessante dos sistemas Linux e UNIX.

Você pode criar symlinks facilmente acessíveis para que eles façam referência a um arquivo ou diretório que, do contrário, não seria de fácil acesso. Com um pouco de prática, você entenderá como eles funcionam em um nível mais intuitivo e eles o deixarão ser muito mais eficiente no gerenciamento de sistemas de arquivos.

O comando LS do Linux – Como listar arquivos em um diretório e flags de opções

Daniel Rosa — Tue, 12 Oct 2021 05:11:08 +0000

Artigo original: The Linux LS Command – How to List Files in a Directory + Option Flags

Desde a criação do Unix, na década de 1970, muitos sistemas operacionais o utilizaram em sua base. Muitos desses sistemas não deram certo, enquanto outros tiveram sucesso.

O Linux é um dos sistemas operacionais baseados no Unix de mais sucesso. Ele tem o código aberto e é utilizado no mundo todo e por vários setores.

Um recurso incrível do sistema operacional Linux é a Command Line Interface (CLI), ou interface de linha de comando, que permite aos usuários interagirem com o computador por meio de um shell. O shell do Linux é um ambiente REPL (de Read, Evaluate, Print, Loop, em inglês), onde os usuários podem inserir um comando e o shell o executa e retorna um resultado.

O comando ls é um dos vários comandos do Linux que permite que o usuário liste arquivos ou diretórios a partir da CLI.

Neste artigo, analisarei em detalhes o comando ls e algumas das flags mais importantes de que você precisará diariamente.

Pré-requisitos

Um computador com diretórios e arquivos
Ter instalada uma das distros do Linux
Conhecimento básico sobre como navegar na CLI
Um sorriso no rosto :)

O comando ls do Linux

O comando ls é usado para listar arquivos ou diretórios no Linux e em outros sistemas operacionais baseados no Unix.

Da mesma forma que você navegaria no seu Explorador de arquivos (no Windows) ou no Finder (no Mac) em uma interface gráfica, o comando ls permite que você liste todos os arquivos ou diretórios no diretório atual por padrão, permitindo uma maior interação com eles pela linha de comando.

Inicie seu terminal, digite ls e pressione Enter para ver o comando em ação:

Como listar arquivos em um diretório com opções

O comando ls também aceita algumas flags (também conhecidas como opções), que são informações adicionais que mudam como os arquivos ou diretórios são listados no seu terminal.

Em outras palavras, as flags mudam a maneira como o comando ls funciona:

 ls [flags] [diretório]

Observação: a palavra conteúdo usada no decorrer do artigo se refere aos arquivos e diretórios que estão sendo listados, não ao conteúdo dos arquivos/diretórios de fato.

Listar arquivos no diretório de trabalho atual

Digite o comando ls para listar o conteúdo do diretório de trabalho atual:

Listar arquivos em outro diretório

Digite o comando ls [caminho do diretório aqui] para listar o conteúdo de outro diretório:

Listar os arquivos no diretório root

Digite o comando ls / para listar o conteúdo do diretório root:

Listar arquivos no diretório pai

Digite o comando ls .. para listar o conteúdo do diretório pai, um nível acima. Use ls ../.. para o conteúdo que está dois níveis acima:

Listar arquivos no diretório home do usuário (/home/user)

Digite o comando ls ~ para listar o conteúdo do diretório home do usuário:

Listar somente diretórios

Digite o comando ls -d */ para listar somente diretórios:

Listar arquivos com subdiretórios

Digite o comando ls * para listar o conteúdo do diretórios com seus subdiretórios:

Listar arquivos recursivamente

Digite o comando ls -R para listar todos os arquivos e diretórios com seus subdiretórios correspondentes até o último arquivo:

Se você tiver muitos arquivos, isso pode levar muito tempo para terminar, já que cada arquivo em cada diretório será exibido. Você pode, em vez disso, especificar um diretório no qual deseja executar esse comando, como ls Downloads -R

Listar arquivos e seus tamanhos

Digite o comando ls -s (com s minúsculo) para listar arquivos e diretórios e seus tamanhos:

Listar arquivos em formato longo

Digite o comando ls -l para listar o conteúdo do diretório em formato tabela com colunas que incluem:

permissões do conteúdo
número de links do conteúdo
proprietário do conteúdo
proprietário do grupo do conteúdo
tamanho do conteúdo em bytes
última data/hora de modificação do conteúdo
nome do arquivo ou diretório

Listar arquivos em formato longo com tamanhos de arquivo legíveis

Digite o comando ls -lh para listar os arquivos ou diretórios no mesmo formato de tabela acima, mas com outra coluna representando o tamanho de cada arquivo/diretório:

Observe que os tamanhos estão listados em bytes (B), megabytes (MB), gigabytes (GB) ou terabytes (TB) quando o tamanho do arquivo ou diretório for maior do que 1024 bytes.

Listar arquivos incluindo arquivos ocultos

Digite o comando ls -a para listar arquivos ou diretórios incluindo arquivos ou diretórios ocultos. No Linux, tudo o que começa com um . é considerado um arquivo oculto:

Listar arquivos em formato longo incluindo arquivos ocultos

Digite o comando ls -l -a, ls -a -l, ls -la ou ls -al para listar os arquivos ou diretórios em formato de tabela com informações adicionais que incluem os arquivos ou diretórios ocultos:

Listar arquivos e ordená-los por data e hora

Digite o comando ls -t para listar os arquivos ou diretórios e ordená-los pela última data e hora de modificação em ordem descendente (do maior para o menor).

Você também pode adicionar uma flag -r para inverter a ordenação, dessa forma: ls -tr:

Listar arquivos e ordená-los por tamanho de arquivo

Digite o comando ls -S (com S maiúsculo) para listar arquivos ou diretórios e ordená-los por tamanho de arquivo em ordem descendente (do maior para o menor).

Você também pode adicionar uma flag -r para inverter a ordenação, dessa forma: ls -Sr:

Listar arquivos e gerar o resultado em um arquivo

Digite o comando ls > output.txt para imprimir o resultado do comando em um arquivo output.txt. Você pode usar qualquer uma das flags discutidas anteriormente, como -la, por exemplo. O ponto importante aqui está no resultado, que será registrado em um arquivo, em vez de exibido na linha de comando.

Assim, você pode usar o arquivo da maneira que achar interessante, ou ainda registrar o conteúdo do arquivo, com cat output.txt:

Conclusão

Há milhares de outros comandos e combinações que você pode explorar para listar arquivos e diretórios com base em suas necessidades. Algo de que você deve se lembrar é da capacidade de combinar diversos comandos em um só.

Imagine que você deseja uma lista em formato longo, incluindo arquivos ocultos, e que deseja ordená-los por tamanho de arquivo. O comando seria ls -alS, que é uma combinação de ls -l, ls -a e ls -S.

Se você se esquecer de qualquer um desses comandos ou se não tiver certeza sobre o que fazer, você pode executar o comando ls --help ou man ls, que exibirão um manual com todas as opções possíveis para o comando ls:

Obrigado por ter lido este artigo!

Linux - freeCodeCamp.org

Como instalar o Ubuntu no VirtualBox

O que é o VirtualBox?

Por que você vai precisar dele

Instalação do VirtualBox

Por que o Ubuntu?

Configuração do Ubuntu

Vamos instalar o Ubuntu!

Vamos verificar a instalação

Conclusão

O manual de comandos do Linux – aprenda comandos do Linux para iniciantes

Índice

Introdução ao Linux e shells

O que é Linux?

O que é um shell Linux?

O comando man no Linux

O comando ls no Linux

O comando cd no Linux

O comando pwd no Linux

O comando mkdir no Linux

O comando rmdir no Linux

O comando mv no Linux

O comando cp no Linux

‌O comando open no Linux

‌O comando touch no Linux

O comando find no Linux

O comando ln no Linux

Hard links

Soft links

O comando gzip no Linux

O comando gunzip no Linux

O comando tar no Linux

O comando alias no Linux

O comando cat no Linux

O comando less no Linux

O comando tail no Linux

O comando wc no Linux

O comando grep no Linux

O comando sort no Linux

O comando uniq no Linux

O comando diff no Linux

O comando echo no Linux

O comando chown no Linux

O comando chmod no Linux

O comando umask no Linux

O comando du no Linux

O comando df no Linux

O comando basename no Linux

O comando dirname no Linux

O comando ps no Linux

O comando top no Linux

O comando kill no Linux

O comando killall no Linux

O comando jobs no Linux

O comando bg no Linux

O comando fg no Linux

O comando type no Linux

O comando which no Linux

O comando nohup no Linux

O comando xargs no Linux

O comando do editor vim no Linux

O comando do editor emacs no Linux

O comando do editor nano no Linux

O comando whoami no Linux

O comando who no Linux

O comando su no Linux

O comando sudo no Linux

O comando passwd no Linux

O comando ping no Linux

O comando traceroute no Linux

O comando clear no Linux

O comando history no Linux

O comando export no Linux

O comando crontab no Linux

O comando uname no Linux

O comando env no Linux

O comando printenv no Linux

Conclusão

Tar no Linux – exemplos de tar GZ, arquivo tar, diretório tar e do comando tar para compressão

Sintaxe

O comando `man` no Linux

O comando `ls` no Linux

O comando `cd` no Linux

O comando `pwd` no Linux

O comando `mkdir` no Linux

O comando `rmdir` no Linux

O comando `mv` no Linux

O comando `cp` no Linux

‌O comando `open` no Linux

‌O comando `touch` no Linux

O comando `find` no Linux

O comando `ln` no Linux

O comando `gzip` no Linux

O comando `gunzip` no Linux

O comando `tar` no Linux

O comando `alias` no Linux

O comando `cat` no Linux

O comando `less` no Linux

O comando `tail` no Linux

O comando `wc` no Linux

O comando `grep` no Linux

O comando `sort` no Linux

O comando `uniq` no Linux

O comando `diff` no Linux

O comando `echo` no Linux

O comando `chown` no Linux

O comando `chmod` no Linux

O comando `umask` no Linux

O comando `du` no Linux

O comando `df` no Linux

O comando `basename` no Linux

O comando `dirname` no Linux

O comando `ps` no Linux

O comando `top` no Linux

O comando `kill` no Linux

O comando `killall` no Linux

O comando `jobs` no Linux

O comando `bg` no Linux

O comando `fg` no Linux

O comando `type` no Linux

O comando `which` no Linux

O comando `nohup` no Linux

O comando `xargs` no Linux

O comando do editor `vim` no Linux

O comando do editor `emacs` no Linux

O comando do editor `nano` no Linux

O comando `whoami` no Linux

O comando `who` no Linux

O comando `su` no Linux

O comando `sudo` no Linux

O comando `passwd` no Linux

O comando `ping` no Linux

O comando `traceroute` no Linux

O comando `clear` no Linux

O comando `history` no Linux

O comando `export` no Linux

O comando `crontab` no Linux

O comando `uname` no Linux

O comando `env` no Linux

O comando `printenv` no Linux

**Uso de touch para criar arquivos**

**O que faz o chmod?**

Como usar operadores com o `chmod`

Como listar os processos em execução no Linux com o comando `ps`

Como listar processos em execução no Linux usando os comandos `top` e `htop`