Convidado.
Usuário Nível 1
Sem cadastro. Progresso salvo localmente. Exporte seu save code para jogar em outro aparelho.
EMBLEMAS CONQUISTADOS
AJUDA & LEGAL
Prática de Terminal Linux Online — Aprenda Fazendo na Prática.
Domine comandos essenciais de Linux e atinja objetivos claros através de um jogo gratuito e simulação de arquivos interativa.
Trilha de Aprendizado Interativa e Objetivos de Terminal.
Sua trilha completa de aprendizado Linux com objetivos estruturados. Clique em qualquer nó desbloqueado para abrir seu terminal interativo.
1. Fundamentos do Sistema de Arquivos
Quem sou eu e onde estou?
Imagine entrar em uma biblioteca enorme e escura com milhões de livros, mas você não tem nenhum mapa e nem consegue se lembrar do seu próprio crachá. Antes de pesquisar qualquer coisa, você precisa saber quem você é e onde está. No shell do Linux, começamos exatamente com as mesmas perguntas! - O comando `whoami` imprime o nome de usuário com o qual você está conectado no momento. - O comando `pwd` (imprimir diretório de trabalho) funciona como um GPS, mostrando o caminho exato da pasta onde você está atualmente.
Navegando e listando arquivos
Agora que você sabe onde está, como olhar ao redor e ir para uma sala diferente nesta biblioteca digital? No Linux, fazemos isso usando dois comandos simples: - `ls`: É como acender as luzes de uma sala para ver todos os arquivos e pastas dentro dela. - `cd <path>`: Abreviação de "alterar diretório", permite que você passe por uma porta para outra pasta. Para especificar onde você deseja ir, você pode usar caminhos **absolutos** (começando na raiz `/` do sistema, como `/var/log`) ou caminhos **relativos** (com base em onde você está agora, como usar `..` para voltar para a pasta pai).
Estrutura de diretórios Linux e FHS
Todo sistema Linux segue uma hierarquia de sistema de arquivos padrão começando no diretório raiz `/`. Ao contrário do Windows (que usa letras de unidade como `C:` ou `D:`), o Linux unifica todos os arquivos e armazenamento em `/`. Aqui estão os principais diretórios do sistema que todo usuário Linux deve conhecer: - `/` (Root): A pasta pai de nível superior de todo o sistema. - `/etc`: contém configurações do sistema (por exemplo, `/etc/hosts`, `/etc/passwd`). - `/var`: contém dados variáveis que mudam com o tempo (logs, spool, caches como `/var/log`). - `/home`: Pastas pessoais do usuário (por exemplo, `/home/learner`). - `/tmp`: Área de armazenamento temporário para arquivos transitórios. - `/usr`: Utilitários de usuário, aplicativos e bibliotecas de sistema.
Criando diretórios
Imagine que sua mesa está cheia de papéis soltos e você precisa de pastas físicas para manter as coisas organizadas. No Linux, organizamos arquivos criando pastas (diretórios) usando o comando `mkdir` (criar diretório). A execução de `mkdir code` cria uma pasta totalmente nova chamada "código" exatamente onde você está. Você pode criar pastas em qualquer lugar do sistema de arquivos fornecendo ao `mkdir` um caminho relativo ou absoluto.
Diretórios e opções aninhados
Imagine tentar construir um conjunto de bonecos aninhados, mas você precisa construir os mais externos antes de poder construir o minúsculo que está dentro. Por padrão, `mkdir` é assim – ele se recusa a criar uma pasta dentro de pastas que ainda não existem. Para evitar o incômodo de criar pastas uma por uma, usamos uma opção: - A opção `-p` (ou `--parents`) diz ao `mkdir` para construir automaticamente quaisquer pastas pai ausentes no caminho para a pasta final. Por exemplo, `mkdir -p workspace/src/utils` cria `workspace`, `workspace/src` e `workspace/src/utils`, tudo em um único comando. **Por que isso é importante**: se você executar `mkdir workspace/src/utils` sem `-p` e `workspace` e `workspace/src` ainda não existirem, você obterá: `mkdir: cannot create directory 'workspace/src/utils': No such file or directory`. O sinalizador `-p` corrige isso criando automaticamente todas as pastas pai ausentes.
Limpando a tela
Você já ficou sobrecarregado quando sua mesa está coberta de anotações e papéis bagunçados? Seu terminal pode ficar igualmente confuso. Quando isso acontecer, você pode varrer todo o texto antigo e começar do zero. - O comando `clear` limpa a tela visível, deslizando a saída anterior para fora da vista para que você tenha uma tela em branco na parte superior do terminal.
Encontrando ajuda do Shell
Quando você compra um novo jogo de tabuleiro, geralmente dá uma olhada no livro de regras ou no cartão de referência para ver quais movimentos são permitidos. Em nosso emulador de terminal, você tem uma folha de dicas integrada! - O comando `help` lista todos os comandos que este simulador suporta, juntamente com detalhes sobre se ele suporta tubulação ou redirecionamento de saídas.
2. Manipulação de Arquivos
Criando arquivos vazios
Imagine querer começar a escrever um novo lançamento no diário, mas primeiro você precisa de um pedaço de papel em branco. No Linux, pegamos um arquivo de texto novo e vazio usando o comando `touch`. - O comando `touch` cria um arquivo totalmente novo e vazio se ele ainda não existir (como executar `touch draft.txt` para criar `draft.txt`). Se o arquivo já existir, ele simplesmente atualiza o carimbo de data/hora da "última modificação" do arquivo sem alterar seu conteúdo. Vamos colocar um arquivo em nossa nova pasta de projetos.
Lendo o conteúdo do arquivo
Pense em abrir uma pasta, retirar uma página de texto e segurá-la para ler. No Linux, lemos arquivos instantaneamente sem abrir um editor de texto pesado usando o comando `cat` (concatenar). - O comando `cat` imprime todo o conteúdo de um arquivo diretamente na tela do seu terminal. Por exemplo, executar `cat notes.txt` permite ver imediatamente o que está escrito dentro de `notes.txt`.
Espiando arquivos (cabeçalho e final)
Agora que você pode ler um arquivo inteiro com `cat`, e se o arquivo tiver milhares de linhas e você quiser ver apenas a parte superior ou inferior? Despejar um arquivo enorme com `cat` inunda sua tela. Em vez disso, usamos `head` e `tail` para espiar as bordas. - O comando `head` exibe as primeiras 10 linhas de um arquivo por padrão. Você pode alterar isso usando `-n <number>` (por exemplo, `head -n 5 log.txt` para as primeiras 5 linhas). - O comando `tail` exibe as últimas 10 linhas por padrão, suportando a mesma opção `-n`. - Crucialmente, `tail -f` (seguir) monitora um arquivo em tempo real, mostrando novas linhas à medida que são escritas pelo sistema. Esta é a ferramenta favorita do administrador de sistema para assistir logs ao vivo.
Rolagem interativa de arquivos (menos e mais)
Espiar a parte superior e inferior de um arquivo com `head` e `tail` é ótimo, mas e se você precisar navegar em um arquivo de configuração longo, página por página? É para isso que servem pagers como `less` e `more`. - Os pagers carregam arquivos de forma interativa, mostrando uma página de texto por vez para evitar lentidão do sistema em arquivos grandes. - `less` é a escolha moderna, permitindo rolar para frente e para trás usando as teclas de seta, pesquisar texto com `/` e sair pressionando `q`. - `more` é um pager mais antigo e simples que apenas rola para frente.
Manipulando espaços em nomes de arquivos
Se você disser a um robô para "pintar meu quarto de azul", ele precisará saber se "meu quarto" é um único lugar ou se "meu" e "quarto" são duas instruções diferentes. O Linux usa espaços para separar comandos de seus argumentos. Portanto, se você executar `mkdir my folder`, o Linux pensará que você deseja criar duas pastas separadas: uma chamada “my” e outra chamada “folder”! - Para dizer ao Linux que um nome com espaços é um item único, devemos colocá-lo entre aspas (`"my folder"` ou `'my folder'`) ou usar uma barra invertida para escapar do espaço (`my\ folder`).
Escrevendo e sobrescrevendo arquivos
Se você quiser escrever uma mensagem em um quadro-negro, primeiro limpe o quadro completamente e depois escreva suas novas palavras. No Linux, escrevemos mensagens em arquivos usando o operador `>` (redirecionamento de saída). - O comando `echo "message"` normalmente imprime texto na tela. - Ao adicionar o símbolo `>`, redirecionamos esse texto para um arquivo. Por exemplo, `echo "Hi" > greeting.txt` escreve "Oi" em `greeting.txt`. Se o arquivo já contiver texto, `>` o substituirá completamente pela nova mensagem.
Anexando aos arquivos
Em vez de limpar o quadro-negro, e se você quiser apenas adicionar uma nova linha na parte inferior? No Linux, adicionamos texto ao final de um arquivo sem tocar no conteúdo existente usando o operador `>>` (redirecionamento de acréscimo). - O operador `>>` anexa seu novo texto no final do arquivo. Por exemplo, `echo "New Line" >> logs.txt` adiciona "Nova linha" ao final de `logs.txt` enquanto mantém todos os seus logs antigos seguros.
Copiando e movendo arquivos
Imagine reorganizar sua sala: às vezes você quer fazer uma fotocópia de um documento para guardar em outra gaveta, e outras vezes você só quer pegar uma pasta e colocá-la em uma nova prateleira ou mudar seu rótulo. Fazemos isso no Linux com comandos simples: - `cp <source> <destination>` cria uma duplicata idêntica de um arquivo em um novo local. - `mv <source> <destination>` move um arquivo para uma nova pasta ou renomeia o arquivo se você o mantiver na mesma pasta (por exemplo, `mv old.txt new.txt`).
Curingas e operações com vários arquivos
Imagine que você tem uma pilha de pastas denominadas "log_monday", "log_tuesday" e "log_wednesday" e deseja abrir e ler todas elas de uma vez, sem digitar todos os nomes. O Linux permite que você use **curingas** como atalhos de pesquisa! - O símbolo `*` corresponde a qualquer caractere de qualquer comprimento. Por exemplo, `cat log_*` lê todos os arquivos que começam com “log_”. - O símbolo `?` atua como um espaço reservado de um único caractere. Por exemplo, `log_?.txt` corresponde a `log_1.txt` mas irá ignorar `log_12.txt`.
Removendo arquivos e pastas
Ao limpar sua mesa física, você pode jogar papéis velhos em uma lixeira, onde poderá recuperá-los caso cometa um erro. No Linux, não há rede de segurança – quando você exclui algo do terminal, ele desaparece para sempre! - O comando `rm` exclui arquivos. - Como as pastas podem conter outros arquivos, `rm` não excluirá uma pasta por padrão. Você deve adicionar o sinalizador `-r` (recursivo) para dizer ao Linux para mergulhar e excluir a pasta junto com tudo dentro dela. **Por que isso é importante**: Se você executar `rm downloads` sem `-r` quando `downloads` for uma pasta, você obterá: `rm: cannot remove 'downloads': Is a directory`. O sinalizador `-r` diz ao Linux para excluir recursivamente a pasta e tudo dentro dela.
3. Pipes e Filtragem
Introdução a tubos e banheiros
Imagine uma linha de montagem onde um trabalhador embala um produto e imediatamente o entrega ao próximo trabalhador para embalá-lo em uma caixa – sem necessidade de armazenamento intermediário. No Linux, conectamos comandos exatamente assim usando um **pipe** (`|`). - Um canal (`|`) roteia a saída de um comando diretamente para a entrada do próximo comando. Por exemplo, `ls | wc -l` lista arquivos e imediatamente entrega essa lista para `wc -l` (contagem de palavras - linhas), que os conta dinamicamente sem a necessidade de arquivos temporários. **Por que isso é importante**: Se você executar `wc` sem `-l`, ele gerará três números separados: linhas, palavras e bytes (por exemplo, ` 5 10 85`). Isso dificulta o uso em pipelines ou scripts que precisam de uma contagem limpa e de um único número. O sinalizador `-l` limita a saída apenas à contagem de linhas.
Classificando e encontrando itens únicos
Imagine classificar um baralho de cartas onde as duplicatas estão espalhadas por toda parte. Para localizar e remover facilmente duplicatas, primeiro agrupe os cartões idênticos. No Linux, o comando `uniq` filtra linhas repetidas, mas tem um problema: ele **detecta apenas duplicatas que estão próximas umas das outras**! - Para remover todas as duplicatas de uma lista confusa, você deve primeiro ordenar as linhas usando `sort` e depois passar o resultado para `uniq`. Por exemplo, `sort raw.txt | uniq` organiza e limpa a lista de uma só vez.
Filtrando com grep
Imagine examinar um enorme diário de bordo de mil páginas para descobrir sempre que ocorreu um erro no sistema. Fazer isso manualmente levaria horas! No Linux, usamos `grep` como nossa lupa digital para pesquisar instantaneamente palavras ou padrões específicos. - O comando `grep` filtra arquivos ou texto canalizado, imprimindo apenas as linhas que correspondem à palavra pesquisada. Por exemplo, executar `grep "ERROR" logs.txt` verifica o arquivo e extrai apenas as linhas que contêm “ERROR”.
4. Redirecionamento e Segurança
Alterando permissões de arquivos
Imagine administrar uma empresa onde apenas os gerentes podem assinar cheques, os funcionários podem ler horários e os visitantes só podem olhar a placa da loja. No Linux, controlamos quem pode ler, escrever ou executar arquivos usando um sistema de segurança de números (chamado de representação octal): - `7` = Acesso total: Ler + Escrever + Executar (`rwx`) - `6` = Modificar acesso: Leitura + Gravação (`rw-`) - `5` = Acesso de leitura e execução: Leitura + Execução (`r-x`) - `4` = Acesso somente leitura: Leitura (`r--`) Aplicamos essas configurações com `chmod <octal> <file>`. Por exemplo, `chmod 755 script.sh` permite executar o script, enquanto outros só podem lê-lo e executá-lo. Temos um script chamado `deploy.sh` que está atualmente bloqueado – vamos torná-lo executável!
Arquivos e configurações ocultos
Pense em uma gaveta secreta embaixo da sua mesa, onde você guarda as configurações do sistema para que não sobrecarreguem seu espaço de trabalho principal. No Linux, criamos arquivos ocultos simplesmente iniciando seus nomes com um ponto (`.`). - Esses dotfiles (como `.bashrc` ou `.config`) armazenam preferências do usuário e configurações nos bastidores. - Um comando `ls` padrão não os mostrará. Para espiar esses arquivos ocultos, você deve adicionar o sinalizador `-a` (todos), executando `ls -a`. **Por que isso é importante**: Se você executar `ls` sem `-a`, os arquivos ocultos (cujos nomes começam com `.`) serão completamente omitidos da saída. Você não verá arquivos importantes como `.config_names` e poderá pensar que eles estão faltando. O sinalizador `-a` diz ao `ls` para listar todos os arquivos, incluindo os ocultos.
Alteração da propriedade do arquivo
Imagine comprar uma casa e ter que registrar oficialmente a escritura com o nome de um novo proprietário. No Linux, cada arquivo e pasta possui um proprietário oficial e um grupo. Se você precisar transferir a propriedade de um arquivo para outra pessoa (como o administrador do sistema), use o comando `chown` (alterar proprietário). - Como alterar o proprietário de um arquivo é uma ação de segurança confidencial, você deve prefixá-lo com `sudo` para executá-lo com privilégios administrativos. Por exemplo, `sudo chown root reports.csv` atribui o arquivo ao usuário "root".
Firewalls Linux (ufw e iptables)
Imagine viver em um prédio de apartamentos seguro, onde um segurança fica na entrada, verificando identidades e bloqueando visitantes não autorizados. No Linux, um **firewall** atua como um guarda de segurança para suas portas de rede. - O comando `ufw` (Firewall Descomplicado) é uma interface amigável para gerenciar regras de firewall. A execução de `sudo ufw status` mostra se o firewall está ativo e quais portas (como a porta 22 para SSH ou a porta 80 para servidores web) estão abertas. - O comando `iptables` é a ferramenta Netfilter tradicional de baixo nível que realmente bloqueia ou redireciona pacotes. A execução de `sudo iptables -L` lista as cadeias de segurança ativas e as regras de correspondência de pacotes.
5. Superusuário e Pacotes
Privilégios de superusuário (sudo)
Imagine trabalhar em seu computador com uma conta padrão para evitar a exclusão acidental de arquivos críticos do sistema operacional. Quando você precisa instalar software ou modificar as configurações do sistema, seu computador solicita autorização de administrador. No Linux, usamos `sudo` (abreviação de “superuser do”) como nosso cartão-chave administrativo. - O usuário `root` é a conta de administrador mestre com controle total sobre o sistema. - Os usuários padrão são impedidos de ler arquivos confidenciais (como o banco de dados de senhas `/etc/shadow`). Ao digitar `sudo` antes de um comando, você o executa com poderes de administrador temporário para ignorar esses bloqueios.
Gerenciamento de Pacotes (apt)
Pense em instalar aplicativos no seu smartphone usando a App Store ou Google Play Store. É seguro, com curadoria e automatizado. No Linux, usamos uma loja de aplicativos de linha de comando chamada gerenciador de pacotes para buscar e instalar software com segurança. - Em sistemas Ubuntu/Debian, o gerenciador de pacotes padrão é `apt` (Advanced Packaging Tool). - A instalação do software altera as pastas de todo o sistema, portanto, você sempre precisa autorizá-lo usando `sudo`. Por exemplo, `sudo apt install tree` baixa e instala o visualizador de diretório "árvore".
Pesquisando Pacotes (apt search)
Antes de instalar software no Linux, como você descobre quais pacotes estão disponíveis no repositório? No Linux, usamos `apt search` para consultar o catálogo de software por palavra-chave. - O comando `apt search <keyword>` verifica as descrições do repositório e lista os pacotes de software correspondentes junto com suas versões. - Ao contrário de `apt install`, a pesquisa em repositórios de pacotes lê apenas arquivos de índice de catálogo local e **não** requer privilégios de superusuário (`sudo`).
Purgando pacotes (apt purge)
Ao desinstalar software no Linux, o `apt remove` padrão desinstala os binários do aplicativo, mas deixa os arquivos de configuração do sistema para trás, caso você reinstale mais tarde. Para eliminar completamente um pacote de software E apagar todos os arquivos de configuração associados, usamos `apt purge` (ou `apt remove --purge`). - O comando `sudo apt purge <package>` remove o aplicativo e apaga todos os arquivos de configuração restantes. - Como a limpeza modifica pastas e arquivos de configuração em todo o sistema, ela requer privilégios de superusuário (`sudo`).
Gerenciamento de pacotes Debian (dpkg)
Enquanto `apt` automatiza o download e resolve dependências de pacotes de repositórios, e se você já baixou um arquivo de pacote `.deb` manualmente e deseja inspecioná-lo ou instalá-lo? No Linux, usamos `dpkg` (Pacote Debian) para interagir diretamente com os pacotes. - O comando `dpkg -l` lista todos os pacotes atualmente instalados em seu sistema Debian/Ubuntu. - O comando `dpkg -s <package>` exibe informações de status, versão e arquitetura de um pacote específico.
Gerenciadores de pacotes RedHat (yum & dnf)
Nem todos os ambientes Linux são baseados em Debian/Ubuntu. Se você trabalha em sistemas RedHat, Fedora ou CentOS, não encontrará `apt` ou `dpkg`. Em vez disso, você gerenciará pacotes usando gerenciadores de pacotes `yum` mais antigos ou `dnf` (Dandified YUM) modernos. - O comando `dnf check-update` (ou `yum check-update`) se conecta aos repositórios RedHat para procurar atualizações de pacotes disponíveis. - O comando `dnf install <package>` busca e instala programas semelhantes a `apt install`.
6. Disco e Recursos do Sistema
Verificando espaço em disco (df)
Imagine tentar baixar um videogame enorme e receber um erro de “armazenamento cheio”, mas você não tem certeza de qual unidade de disco é o gargalo. No Linux, verificamos a capacidade de armazenamento do nosso sistema usando o comando `df` (disk free). - O comando `df` exibe o espaço total, usado e disponível em todas as unidades conectadas. - Ao executar `df -h` (adicionando o sinalizador `-h` para "legível por humanos"), você vê o armazenamento em gigabytes (G) e megabytes (M) amigáveis, em vez de confundir contagens de blocos, facilitando a identificação de qual unidade (como `/` ou `/home`) está cheia. **Por que isso é importante**: se você executar `df` sem `-h`, os tamanhos serão exibidos em números brutos de blocos de 1K (por exemplo, `49258284` em vez de `47G`), o que é extremamente difícil para um ser humano ler e calcular. O sinalizador `-h` formata esses tamanhos em gigabytes (G) e megabytes (M) amigáveis.
Encontrando tamanhos de diretório (du)
Depois de saber *qual* unidade está cheia, como encontrar a pasta específica que está acumulando todo o seu espaço? É a sua pasta de downloads ou talvez algum cache oculto? Resolvemos esse mistério usando o comando `du` (uso de disco). - `du <directory>` lista o tamanho de uma pasta e todas as subpastas dentro dela. - `du -sh <directory>` (onde `-s` significa "resumo" e `-h` significa "legível por humanos") calcula e imprime um tamanho total único e limpo para essa pasta específica. **Por que isso é importante**: Se você executar `du` sem `-s`, ele irá despejar uma enorme parede de texto listando cada subdiretório e arquivo individual recursivamente, em vez de fornecer um único resumo. O sinalizador `-s` resume o tamanho total da pasta e `-h` a torna legível por humanos.
Verificando o uso da memória (gratuito)
Imagine que seu laptop começa a ficar lento, as páginas da web congelam e a troca de aplicativos parece dolorosamente lenta. Isso geralmente significa que seu computador está sem memória ativa (RAM). No Linux, podemos verificar quanto espaço nosso sistema tem para respirar usando o comando `free`. - O comando `free` mostra a memória física (RAM) total, usada e disponível e o espaço de troca. - Adicionar o sinalizador `-h` (executando `free -h`) formata os tamanhos de memória em gigabytes (GB) e megabytes (MB) fáceis de ler para que você possa saber se um programa está consumindo todos os seus recursos. **Por que isso é importante**: Se você executar `free` sem `-h`, o uso de memória será impresso em quilobytes brutos (por exemplo, `16323456` em vez de `16G`), o que é difícil de interpretar rapidamente. O sinalizador `-h` dimensiona automaticamente os números para gigabytes (G) ou megabytes (M) para facilitar a leitura.
Detalhes do tempo de atividade do sistema e do kernel
Imagine solucionar problemas de um servidor que começou a se comportar mal e precisar saber se foi reinicializado recentemente ou verificar exatamente qual versão do sistema operacional está sendo executada nos bastidores. Podemos consultar esses detalhes do sistema em segundos: - O comando `uptime` informa exatamente há quanto tempo sua máquina está funcionando desde a última inicialização, juntamente com o quão ocupada ela esteve (carga do sistema). - O comando `uname -a` (nome unix) imprime um relatório completo do kernel do seu sistema, nome da plataforma e arquitetura da máquina. **Por que isso é importante**: Se você executar `uname` sem `-a`, ele exibirá apenas o nome básico do sistema operacional (por exemplo, `Linux`). Ele deixa de fora detalhes críticos como a versão do kernel, o nome da plataforma e a arquitetura do processador. O sinalizador `-a` imprime todos os detalhes disponíveis do sistema em um único relatório.
Visualizando detalhes da CPU (lscpu)
Ao solucionar problemas de desempenho do sistema ou implementar aplicativos de alta demanda, você precisa conhecer os recursos da CPU do seu sistema. No Linux, lemos informações detalhadas da arquitetura da CPU usando o comando `lscpu`. - O comando `lscpu` exibe detalhes do processador, como modelo de CPU, fornecedor, velocidade do clock, número de núcleos, detalhes de hyper-threading e tamanhos de cache, diretamente do sistema de arquivos do kernel.
Estatísticas de E/S e CPU (iostat)
Quando um banco de dados ou aplicativo da Web é executado lentamente, como determinar se o problema é um gargalo de CPU ou um disco rígido lento? No Linux, monitoramos as métricas de desempenho de saída/entrada do sistema usando `iostat`. - O comando `iostat` exibe estatísticas de relatório sobre o uso da CPU e a taxa de transferência de leitura/gravação do dispositivo ativo, ajudando a identificar o congestionamento do disco.
7. Gerenciamento de Processos
Listando processos em execução (ps)
Pense em seu sistema operacional como um escritório movimentado onde cada funcionário (ou programa em execução) recebe uma etiqueta de nome exclusiva chamada ID de processo (PID). No Linux, chamamos esses programas ativos de **processos** e os listamos usando o comando `ps`. - A execução de `ps` por si só mostra apenas os programas em execução dentro da janela do terminal atual. - A execução de `ps aux` atua como um registro mestre de escritório, listando cada programa ativo em execução em todo o sistema, quem o iniciou e quanta CPU e memória ele está usando. **Por que isso é importante**: Se você executar `ps` sem `aux`, verá apenas processos em execução na janela atual do terminal (geralmente apenas `bash` e o próprio `ps`). Você não verá serviços em segundo plano, processos do sistema ou programas executados por outros usuários. As opções `aux` revelam todos os processos em execução em todo o sistema.
Monitor de processo interativo (topo)
Imagine olhar para uma foto estática de uma rodovia em vez de assistir a uma transmissão ao vivo de uma câmera de trânsito. Enquanto `ps` fornece um instantâneo rápido do que está sendo executado no momento, `top` permite que você observe o desempenho do seu sistema ao vivo. - O comando `top` inicia um painel interativo em tempo real que é atualizado a cada poucos segundos. Ele exibe o uso da CPU, as médias de carga e classifica dinamicamente os processos com maior consumo de recursos em execução neste exato momento.
Listando arquivos abertos (lsof)
Em sistemas do tipo Unix, "tudo é um arquivo". Isso significa que não apenas arquivos e pastas de texto, mas também soquetes de rede, hardware do sistema e processos são tratados como arquivos. Para descobrir quais arquivos estão sendo acessados por quais programas em execução, usamos `lsof` (List Open Files). - A execução de `lsof` exibe uma lista abrangente de todos os arquivos abertos, junto com o ID do processo (PID) e o comando que os abriu. - Por exemplo, executar `lsof -i` lista todos os arquivos/soquetes da rede, o que é extremamente útil para descobrir qual processo está escutando em uma porta de rede específica (como a porta 80).
Parando processos não autorizados (matar)
Imagine que um aplicativo em seu telefone congela, bloqueando completamente sua tela, e você precisa fechá-lo à força para que tudo funcione perfeitamente novamente. No Linux, paramos de programas malcomportados ou congelados usando o comando `kill` seguido pelo ID do processo (PID) do programa. - A execução de `kill 1234` envia uma solicitação educada solicitando ao programa que salve seu trabalho e feche. - Se estiver congelado e ignorar a solicitação educada, `kill -9 1234` forçará o sistema operacional a desligá-lo instantaneamente. Temos um processo descontrolado com PID `9999` consumindo toda a nossa CPU agora – vamos desligá-lo!
Executando trabalhos em segundo plano
Imagine tentar copiar uma pasta enorme para uma unidade USB, mas enquanto ela copia, você deseja continuar trabalhando e digitando outros comandos na mesma janela. No Linux, podemos executar tarefas demoradas em “segundo plano” para que não bloqueiem nossa linha de comando. - Adicionar um e comercial `&` ao final de um comando (como `sleep 100 &`) informa ao terminal para executá-lo em segundo plano e devolver seu prompt imediatamente. - O comando `jobs` mostra o que está sendo executado em segundo plano. - O comando `fg` (primeiro plano) coloca uma tarefa em segundo plano de volta ao centro do palco.
Gentileza do processo (nice & renice)
Em um escritório movimentado, algumas tarefas de baixa prioridade (como arquivar recibos) podem esperar, enquanto solicitações de alta prioridade devem ser tratadas imediatamente. O Linux gerencia a prioridade do processo usando valores de **niceness** que variam de -20 (prioridade mais alta) a 19 (prioridade mais baixa). - O comando `nice` inicia um processo com prioridade personalizada. Por exemplo `nice -n 10 sleep 5` inicia um comando sleep com uma prioridade educada de 10. - O comando `renice` altera a prioridade de agendamento de um processo já em execução. Por exemplo, `sudo renice +5 9999` diminui a prioridade do processo 9999.
Retomando Jobs em Background (bg)
Já vimos como iniciar uma tarefa em background usando `&` e trazê-la de volta usando `fg`. Mas e se você iniciasse um comando sem `&` ou o suspendesse com `Ctrl+Z`? Você pode retomá-lo em segundo plano usando `bg`! - O comando `bg` retoma os trabalhos suspensos, permitindo que sejam executados em segundo plano sem bloquear o prompt do terminal.
8. Solução de Problemas de Rede
Testando conectividade (ping)
Imagine tentar carregar uma página da web, mas seu navegador gira sem parar, deixando você se perguntando se o Wi-Fi de sua casa está desconectado ou se o próprio site travou. No Linux, testamos nossa conexão de rede básica usando o comando `ping`. - O comando `ping` envia pequenos pacotes de dados para um servidor (como `google.com`) e mede quantos milissegundos leva para receber uma resposta. - No Linux, `ping` continuará rodando para sempre por padrão. Para fazê-lo parar após algumas tentativas, usamos o sinalizador `-c` (contagem), executando `ping -c 3 google.com`. **Por que isso é importante**: Se você executar `ping google.com` sem `-c`, ele continuará enviando pacotes e imprimindo resultados infinitamente. Você terá que interrompê-lo manualmente com `Ctrl+C` para executar qualquer outro comando. O sinalizador `-c 3` interrompe o comando automaticamente após enviar exatamente 3 pacotes.
Interfaces de rede e IP local
Imagine configurar uma impressora de rede ou compartilhar arquivos com o computador de um amigo no mesmo Wi-Fi e precisar saber o endereço IP local da sua máquina. No Linux, inspecionamos nosso hardware de rede e IPs usando o comando `ip`. - Executar `ip addr` (ou simplesmente `ip a`) imprime uma lista de todos os seus dispositivos de interface de rede (como `eth0` para Ethernet com fio ou `wlan0` para sem fio) junto com seus endereços IP locais atribuídos.
Verificando Interfaces (ifconfig)
Antes do moderno conjunto de comandos `ip` se tornar padrão, os administradores de sistema Linux dependiam do `ifconfig` (configurador de interface) para visualizar e gerenciar interfaces de rede. - O comando `ifconfig` exibe interfaces de rede ativas, configuração de IP local, detalhes da máscara de rede e endereços de hardware MAC. Embora obsoleto em algumas distribuições mais recentes, ele continua amplamente utilizado em servidores legados.
Conexões de rede (nmcli)
Em estações de trabalho e servidores Linux modernos, as interfaces de rede são gerenciadas por um daemon de sistema chamado NetworkManager. Em vez de editar manualmente os arquivos de configuração, configuramos os detalhes da rede usando `nmcli`. - O comando `nmcli` (NetworkManager CLI) permite inspecionar conexões de hardware, estados de dispositivos e redes Wi-Fi ativas.
Estatísticas de soquete e conexão (netstat e ss)
Ao configurar um banco de dados ou servidor web, você deve verificar se o serviço está rodando e escutando na porta correta e verificar se alguma conexão não autorizada foi estabelecida. Fazemos isso usando `netstat` ou `ss`. - O comando `netstat` (estatísticas de rede) é uma ferramenta clássica para mostrar conexões TCP e portas de escuta. Por exemplo `netstat -tuln` lista as portas de escuta TCP/UDP. - O comando `ss` (estatísticas de soquete) é a alternativa moderna e mais rápida ao `netstat` que exibe detalhes de conexão de soquete diretamente do namespace do kernel.
Rastreando rotas de pacotes (traceroute)
Quando uma página da web falha ao carregar, como você identifica se o problema está no seu roteador doméstico, no seu provedor de serviços de Internet (ISP) ou no servidor de destino? No Linux, rastreamos pacotes usando `traceroute`. - O comando `traceroute` lista cada gateway de roteador (salto) que um pacote atravessa em seu caminho para um servidor remoto, juntamente com a latência de resposta para cada salto.
Baixando arquivos da Web (curl)
Imagine querer baixar um arquivo ou obter o código de um script de configuração diretamente de um servidor web sem abrir um navegador e clicar no botão "Download". No Linux, buscamos dados da web usando `curl` (abreviação de "URL do cliente"). - Executar `curl <url>` baixa o conteúdo da página e o imprime diretamente na tela. - Para salvar o conteúdo baixado como um arquivo em vez de exibi-lo, emparelhamos-o com o redirecionamento `>` ou o sinalizador de saída `-o`.
9. Busca de Arquivos
Encontrando arquivos por nome (find)
Imagine perder um arquivo de texto importante em algum lugar da sua pasta de usuário e ter que pesquisar em dezenas de diretórios aninhados, um por um. No Linux, evitamos a escavação manual usando o utilitário `find` como um mecanismo de pesquisa extremamente rápido para todo o sistema. - O comando `find` pesquisa árvores de diretórios com base em nome, tamanho, tipo ou data. - A sintaxe é `find <where> -name "<pattern>"`. Por exemplo, `find . -name "*.txt"` pesquisa no diretório atual e em todas as subpastas arquivos que terminam em `.txt`. **Por que isso é importante**: Se você executar `find . "*.log"` sem `-name`, receberá o erro: `find: paths must precede expression: '*.log'`. O sinalizador `-name` é necessário para especificar que o padrão subsequente deve corresponder aos nomes dos arquivos.
Verificando o histórico de comandos
Imagine que você digitou um comando de diagnóstico de rede longo e complexo há dez minutos e agora precisa executá-lo novamente, mas não consegue se lembrar das opções ou sintaxe exatas. Em vez de coçar a cabeça ou digitar tudo, o Linux lembra para você! - O comando `history` exibe uma lista numerada de todos os comandos que você executou recentemente. - Você pode executar novamente qualquer item rapidamente digitando um ponto de exclamação seguido do número da lista (como `!42` para executar novamente o comando nº 42).
Consultando páginas do manual
Imagine tentar usar um novo comando, mas você não tem certeza de quais flags ele suporta ou como suas entradas devem ser formatadas. Em vez de pesquisar online, o Linux tem um manual do usuário oficial e abrangente integrado no terminal! - O comando `man` (manual) seguido por qualquer nome de utilitário (por exemplo, `man ls`) abre um guia de referência detalhado. - Dentro do guia, você rola com as teclas de seta, pesquisa com "/" e pressiona `q` para fechar o manual e retornar ao seu prompt.
10. Serviços e Systemd
Controlando serviços (systemctl)
Imagine hospedar um site em seu computador, mas os visitantes recebem um erro “o site não pode ser acessado” porque o programa do servidor web em segundo plano não está em execução. No Linux, os processos em segundo plano que iniciam automaticamente e são executados em segundo plano (como bancos de dados, firewalls ou servidores web) são chamados de **serviços** e nós os gerenciamos usando `systemctl`. - O comando `systemctl status <service>` verifica se um serviço está ativo ou parado. - Como iniciar ou interromper um serviço afeta todos os usuários e a segurança do sistema, você deve usar `sudo` para executar comandos como `sudo systemctl start <service>` ou `sudo systemctl stop <service>`.
Log do sistema (journalctl)
Agora que você pode iniciar e interromper serviços em segundo plano com `systemctl`, como solucioná-los quando eles falharem? O utilitário `journalctl` permite inspecionar logs do sistema gerados por serviços gerenciados pelo systemd. - Por padrão, `journalctl` mostra todos os logs do sistema. Como isso pode ser enorme, nós os filtramos para manter o foco. - A opção `-u <service>` filtra logs para mostrar apenas mensagens de um serviço específico (por exemplo, `journalctl -u apache2`). - A opção `-n <number>` exibe apenas as entradas mais recentes (por exemplo, `journalctl -n 5` para os últimos 5 logs). - O sinalizador `-f` (seguir) exibe os logs em tempo real à medida que são gravados.
11. Edição de Texto no Terminal
Editando arquivos de configuração (nano)
Imagine fazer SSH em um servidor de nuvem remoto onde você não tem uma área de trabalho gráfica ou cursor e precisa corrigir rapidamente uma linha em um arquivo de configuração. Nestes cenários, você deve usar um editor de texto de terminal como `nano`. - Executar `nano <filename>` carrega um editor de texto simples e leve diretamente dentro da janela do shell. - Os atalhos são sempre exibidos na parte inferior da tela: pressione `Ctrl+O` para escrever (salvar) suas alterações e `Ctrl+X` para sair do editor.
12. Scripts Shell e Automação
Escrevendo seu primeiro script Bash
Imagine ter uma lista de 20 tarefas que você deve executar todas as manhãs. Digitá-los manualmente é tedioso e deixa espaço para erros de digitação. No Linux, agrupamos comandos em um arquivo chamado shell script para que possamos executá-los todos de uma vez! - Todo script começa com um "shebang" (`#!/bin/bash`) na primeira linha para informar ao sistema qual interpretador de shell usar para executar o arquivo. - Depois de salvar seu script, você o torna executável concedendo permissão de execução via `chmod 755 script.sh` e depois executando-o com `./script.sh`.
Variáveis e argumentos ($1)
Imagine criar uma mensagem de boas-vindas personalizada para um site. Você não gostaria de escrever um script separado para o nome de cada cliente! Em vez disso, você escreve um script que recebe um nome como entrada ao executá-lo. - Em scripts bash, variáveis como `$1`, `$2` e assim por diante retêm os “argumentos” ou entradas que você passa na linha de comando. - Por exemplo, executar `./greet.sh Alice` significa que `$1` dentro do script conterá automaticamente o texto "Alice". Da mesma forma, `$#` controla quantas entradas o usuário forneceu.
Lógica Condicional (if/else)
Imagine construir um script que processe um relatório CSV, mas ele trava se o arquivo de relatório não existir realmente no disco. Para evitar erros, escrevemos scripts que tomam decisões usando a lógica condicional `if/else`. - Verificamos as condições usando colchetes: `if [ -f "$1" ]; then ... fi`. - A flag `-f` verifica se um caminho aponta para um arquivo, enquanto `-d` verifica se é um diretório. O script ramifica suas ações dependendo se a condição é avaliada como verdadeira ou falsa.
Automatizando com Loops
Imagine ter uma pasta com 100 arquivos de log e precisar fazer uma cópia de backup de cada um deles. Copiá-los individualmente seria exaustivo. No Linux, usamos loops `for` para repetir automaticamente a mesma ação em uma lista inteira de itens! - Um loop `for` (como `for file in *.txt; do ... done`) itera sobre cada item que corresponde a um padrão, processando-os um após o outro em uma fração de segundo.
Lógica Reutilizável (funções bash)
Você escreveu loops e condicionais para automatizar ações em scripts. Mas à medida que seus scripts crescem, copiar e colar a mesma lógica repetidamente torna-os difíceis de manter. No bash, podemos agrupar comandos em funções reutilizáveis. - Para definir uma função, declaramos ela pelo nome seguido de parênteses e chaves: `log_msg() { echo "msg"; }`. - As funções podem receber argumentos como scripts de shell, que são acessados usando os parâmetros de posição local `$1`, `$2`, etc. - Para chamar uma função, basta usar seu nome como qualquer outro comando: `log_msg "Backup started"`.
Agendando tarefas (crontab)
Agora que você escreveu scripts de shell robustos, você não gostaria de fazer login à meia-noite apenas para executar seu auxiliar de backup. O Linux fornece o serviço `cron` para executar comandos ou scripts automaticamente em horários específicos. - O serviço cron verifica uma tabela de agendamento chamada `crontab`. - Cada agendamento cron possui 5 campos que representam o tempo: `minute hour day-of-month month day-of-week` seguido do comando. - Por exemplo, `30 2 * * * /path/to/script.sh` executa um script todos os dias às 2h30. - Usamos `crontab -l` para listar nossos cron jobs ativos e `crontab <filename>` para carregar programações de um arquivo.
13. Processamento Avançado de Texto
Edição de fluxo com sed
Imagine que você tem um enorme arquivo de despejo de banco de dados e precisa substituir todas as ocorrências de um endereço IP de servidor antigo por um novo. Abri-lo em um editor pode congelar seu computador. No Linux, editamos fluxos de texto dinamicamente usando `sed` (abreviação de "editor de fluxo"). - A sintaxe básica é `sed "s/old/new/g" file.txt` para localizar e substituir texto. - Adicionar o sinalizador `-i` (no local) salva as substituições diretamente no próprio arquivo, em vez de apenas imprimir o texto modificado na tela. **Por que isso é importante**: Se você executar `sed "s/port=80/port=8080/g" server.conf` sem `-i`, ele imprimirá apenas o texto modificado na tela do seu terminal. O arquivo real permanece completamente inalterado. O sinalizador `-i` (no local) é necessário para salvar as alterações diretamente no arquivo.
Extração de dados com awk
Imagine receber uma grande planilha salva como texto simples, onde as colunas são separadas por vírgulas ou espaços, e você só precisa extrair a primeira coluna de dados. No Linux, analisamos colunas estruturadas de texto usando a linguagem poderosa `awk`. - Por padrão, `awk` divide as linhas por espaços em branco, atribuindo a coluna 1 a `$1`, a coluna 2 a `$2` e assim por diante. - O sinalizador `-F` permite especificar um separador personalizado (como `-F:` para dois pontos). Por exemplo, `awk -F: '{print $1}' /etc/passwd` extrai apenas os nomes de usuário de uma lista separada por dois pontos. **Por que isso é importante**: Se você executar `awk '{print $1}' /etc/shadow` sem `-F:`, `awk` dividirá as linhas por espaços em branco (o padrão) em vez de dois pontos. Como as linhas do arquivo shadow não possuem espaços, a linha inteira é tratada como um único campo, imprimindo os detalhes completos do hash de cada usuário. O sinalizador `-F:` força `awk` a dividir as colunas por dois pontos.
Traduzindo e cortando dados
Imagine trabalhar com uma planilha CSV de datas e nomes de transações. Você deseja extrair apenas a primeira coluna (datas) e converter todo o texto em letras maiúsculas para manter a consistência. No Linux, podemos combinar ferramentas de análise leves em um pipeline: - O comando `cut` separa colunas específicas do texto estruturado. Por exemplo, `cut -d, -f1` divide as linhas por vírgulas (`-d,`) e extrai a primeira coluna (`-f1`). - O comando `tr` (traduzir) transforma caracteres da entrada padrão, como trocar caracteres minúsculos por maiúsculos (`tr "a-z" "A-Z"`). **Por que isso é importante**: Se você executar `cut reports.csv` sem `-d,` e `-f1`, obterá: `cut: you must specify a list of bytes, characters, or fields`. Se você especificar `-f1` mas omitir `-d,`, o padrão será tabulações, o que significa que não dividirá um arquivo CSV e apenas imprimirá a linha inteira. O sinalizador `-d,` define a vírgula como separador de colunas e `-f1` diz para extrair apenas a primeira coluna.
14. Ambiente e Usuários
Gerenciando variáveis de ambiente
Imagine que você está implantando um aplicativo da Web e ele precisa saber se deve ser executado em uma sandbox de "desenvolvimento" local segura ou se conectar ao banco de dados de "produção" ativo. No Linux, passamos configurações como esta para programas em execução usando **variáveis de ambiente**. - Usamos o comando `export` para definir uma variável para que qualquer programa iniciado pelo nosso shell possa lê-la. Por exemplo, `export APP_ENV=production`. - Para verificar ou exibir o valor de uma variável, prefixamos seu nome com um cifrão: `echo $APP_ENV`.
Arquivos e compactação (tar)
Imagine que você tem uma pasta contendo 500 logs de servidor e deseja enviá-la por e-mail para um colega ou fazer backup dela em um armazenamento em nuvem. O envio de 500 arquivos individuais é lento e ineficiente. No Linux, nós os compactamos em um único arquivo compacto tipo zip usando `tar` (abreviação de "tape archive"). - Criamos arquivos compactados usando sinalizadores: `-c` (criar), `-z` (compactar com gzip), `-v` (lista detalhada de arquivos) e `-f` (especificar nome do arquivo). Por exemplo, `tar -czvf backup.tar.gz folder/` agrupa e compacta o diretório. **Por que isso é importante**: Se você executar `tar -cz logs.tar.gz logs` sem `-f`, obterá: `tar: Refusing to write archive contents to terminal`. O sinalizador `-f` é crítico porque diz ao `tar` para gravar a saída em um arquivo em vez de enviar dados brutos de arquivo binário diretamente para o seu terminal. Os sinalizadores `-c` e `-z` também são necessários para criar e compactar o arquivo, respectivamente.
Compactação de arquivos (gzip e gunzip)
Imagine que você tem um único arquivo de texto contendo um conjunto de dados enorme e deseja reduzir seu tamanho para economizar espaço em disco ou acelerar o compartilhamento. No Linux, compactamos arquivos individuais usando `gzip` e os restauramos usando `gunzip`. - O comando `gzip <filename>` compacta um arquivo, substituindo-o por uma versão compactada que termina em `.gz` (por exemplo, `backup.txt` passa a ser `backup.txt.gz`). - O comando `gunzip <filename.gz>` descompacta o arquivo, restaurando a versão original.
Arquivando com zip e descompacte
Embora `tar` e `gzip` sejam padrão no Linux, `zip` é o formato de arquivo mais comum no mundo de plataforma cruzada (Windows/macOS). No Linux, empacotamos e compactamos arquivos em arquivos zip usando `zip` e os extraímos usando `unzip`. - O comando `zip <archive.zip> <files>` cria um arquivo zip. - O comando `unzip <archive.zip>` extrai os arquivos do arquivo.
Compressão Alternativa (bzip2 & xz)
Além de `gzip` e `zip`, o Linux suporta outros formatos de compressão otimizados para taxas de compressão mais altas em detrimento da velocidade da CPU. Estes são `bzip2` (bz2) e `xz` (xz). - O comando `bzip2 <file>` compacta um arquivo, gerando `<file>.bz2`. - O comando `xz <file>` usa compactação LZMA sem perdas para criar `<file>.xz`, que produz tamanhos de arquivo excepcionalmente pequenos, tornando-o ideal para versões de kernel Linux.
Inspecionando o Ambiente
Imagine que você está tentando depurar um script que falha continuamente porque não consegue encontrar o caminho de um programa, ou deseja ver qual conta de usuário está ativa neste terminal. No Linux, todas essas configurações de toda a sessão são armazenadas juntas. - O comando `env` imprime um diretório completo de todas as variáveis de ambiente atualmente carregadas em sua sessão ativa, permitindo verificar as configurações de uma só vez.
Encontrando Comandos (que)
Agora que você está familiarizado com variáveis de ambiente ativas como `PATH` (que armazena os diretórios onde o Linux procura comandos), como você encontra o caminho exato do arquivo do programa que é executado quando você digita `ls` ou `grep`? Usamos `which` para localizar binários de comando. - O comando `which` pesquisa as pastas listadas em sua variável `$PATH` e imprime o caminho absoluto do binário executado quando o comando é executado (por exemplo, `which ls` gera `/bin/ls`). - Isso é útil para descobrir onde uma ferramenta está instalada ou resolver conflitos entre várias versões da mesma ferramenta.
Atalhos de shell personalizados (alias)
Digitar comandos longos com vários sinalizadores pode ser cansativo. No Linux, podemos criar atalhos personalizados chamados aliases. Por exemplo, você pode mapear `ll` para executar `ls -la` automaticamente. - Para criar um alias temporário, execute `alias name='command'` (por exemplo, `alias ll='ls -la'`). - Executar `alias` sem argumentos lista todos os aliases ativos na sessão atual. - Para tornar os aliases permanentes durante as reinicializações, eles normalmente são gravados nos arquivos de configuração `.bashrc` ou `.bash_profile`.
15. Sistema de Arquivos Avançado
Criando links (ln -s)
Imagine que você tem um arquivo de configuração enterrado em uma pasta aninhada, digamos `/var/www/html/configs/app/settings.conf`, mas precisa editá-lo constantemente. Em vez de digitar sempre o longo caminho da pasta, você deseja um atalho rápido na área de trabalho. No Linux, fazemos isso criando links. - **Hard Link**: Um clone direto apontando para os dados brutos do arquivo. Se você excluir o arquivo original, o link ainda funcionará. - **Link Simbólico (Soft Link)**: Um atalho baseado em caminho (assim como os atalhos do Windows). Se você excluir o arquivo original, o link será quebrado. Nós os criamos usando `ln -s target link_name`. **Por que isso é importante**: Se você executar `ln logs/app.log app_link.log` sem `-s`, criará um link físico em vez de um atalho simbólico. Se os arquivos residirem em partições de disco diferentes, você obterá: `ln: failed to create hard link: Invalid cross-device link`. O sinalizador `-s` cria um link simbólico flexível (atalho) que funciona em diferentes unidades e diretórios.
Processando Resultados da Pesquisa (xargs)
Imagine que você executou uma pesquisa que retornou 100 arquivos temporários e agora deseja excluir todos eles. A saída da pesquisa é apenas uma lista de nomes de texto na tela – como você alimenta esses nomes como entradas diretas para o comando de exclusão? No Linux, preenchemos essa lacuna usando `xargs`. - O comando `xargs` (executar argumentos) pega linhas de entrada padrão (como a lista de arquivos de `find`) e as alimenta uma por uma como argumentos para outro comando. - Por exemplo, `find . -name "*.tmp" | xargs rm` encontra todos os arquivos temporários e remove todos eles em uma única varredura.
16. Acesso Remoto e Admin de Usuários
Administração de usuários (useradd & passwd)
Até agora, você tem trabalhado como usuário `learner`. Mas em servidores do mundo real, os administradores de sistemas devem gerenciar várias contas. Vamos aprender como adicionar novos usuários e definir suas senhas. - O comando `useradd` cria uma nova conta de usuário. Como a criação de contas afeta a segurança do sistema, ela deve ser executada com privilégios de superusuário (por exemplo, `sudo useradd deployer`). - O comando `passwd` define ou altera a senha de um usuário. Execute como `sudo passwd deployer` para definir a senha do usuário do implementador.
Gerenciando usuários (adduser & userdel)
Embora `useradd` seja um utilitário de baixo nível que apenas registra detalhes do usuário em arquivos de configuração do sistema, os sistemas Debian/Ubuntu fornecem um script interativo de alto nível chamado `adduser` que automatiza a criação de pastas pessoais, configuração de senhas e inicialização de ambientes shell. Por outro lado, `userdel` exclui contas de usuário de forma limpa. - A execução de `sudo adduser tester` orienta você na configuração do usuário de forma interativa. - Executar `sudo userdel tester` exclui a conta do usuário.
Visualizando identidades de usuário (id)
Ao solucionar erros de permissão, você deve verificar o contexto exato do identificador de usuário e grupo em que está executando. Fazemos isso usando `id`. - A execução de `id` imprime o ID do usuário (UID), o ID do grupo primário (GID) do usuário atual e todas as listas de grupos complementares. - Executar `id <username>` consulta informações de um usuário específico.
Administração de grupos (groupadd e grupos)
No Linux, os usuários são organizados em **grupos** para compartilhar permissões facilmente. Por exemplo, todos os desenvolvedores podem pertencer a um grupo denominado `developers`. Isso nos permite compartilhar arquivos com toda a equipe de uma só vez. - O comando `groupadd` cria um novo grupo. Como esta é uma configuração do sistema, requer privilégios de superusuário (por exemplo, `sudo groupadd developers`). - O comando `groups [username]` lista todos os grupos aos quais um usuário pertence. Executado sem argumentos, exibe grupos para o usuário atual.
Excluindo grupos (groupdel)
Quando as equipes do projeto reorganizam ou desativam serviços, os grupos de segurança correspondentes devem ser limpos. No Linux, excluímos grupos usando `groupdel`. - O comando `groupdel <group_name>` exclui permanentemente um grupo dos arquivos de configuração do sistema, exigindo privilégios de superusuário.
Alternando contextos de segurança (su)
Agora que você criou a conta `deployer`, como fazer login nela localmente para testar seu ambiente? No Linux, usamos o comando `su` (usuário substituto) para trocar de conta sem fazer logout. - O comando `su <username>` alterna o shell do terminal atual para a sessão desse usuário. - Quando alternado, a execução de `whoami` refletirá o novo nome de usuário. - Para retornar à sessão original da sua conta de usuário, digite `exit` ou pressione `Ctrl+D`.
Secure Shell Access (ssh)
A troca de usuários localmente é útil, mas na computação em nuvem, os servidores residem em data centers remotos. Para conectar-se a eles com segurança pela rede, usamos `ssh` (Secure Shell). - O comando `ssh` criptografa a conexão entre sua máquina e um host remoto para evitar espionagem. - Sintaxe: `ssh user@hostname` ou `ssh user@ip_address` (por exemplo, `ssh admin@192.168.1.100`). - A primeira conexão solicitará que você verifique a autenticidade do host remoto exibindo uma impressão digital ECDSA exclusiva. **Observação:** Como este é um sandbox baseado em navegador, não há nenhum servidor remoto real ao qual se conectar. A execução deste comando mostrará o padrão de saída esperado do mundo real (verificação de host, conexão, sessão) instantaneamente, em vez de uma sessão interativa ao vivo real. Em um terminal real, o ssh colocaria você em um shell remoto genuinamente separado até você digitar `exit`.
Transferência segura de arquivos (scp)
Agora que você sabe como fazer login em um servidor remoto via SSH, como copiar um arquivo local (como um arquivo de backup) para ele? O comando `scp` (cópia segura) copia arquivos com segurança entre hosts usando SSH nos bastidores. - A sintaxe é `scp source_path user@host:destination_path`. - Por exemplo, `scp log.txt admin@192.168.1.100:/tmp/` copia o arquivo `log.txt` local para a pasta `/tmp/` remota. **Observação:** Assim como com o ssh, não há nenhum servidor remoto real aqui — a execução deste comando confirma a existência do seu arquivo local e mostra a saída de transferência esperada, mas na verdade não envia dados para lugar nenhum.
Who Am I and Where Am I?.
Referência de Comandos
Lista de Verificação
Dicas Reveladas
File Explorer
O que é o BashQuest?
Plataforma gratuita de prática de terminal Linux online e jogo educativo. Execute comandos reais em um sistema de arquivos simulado com validação imediata.
O que é o BashQuest?
O BashQuest é uma plataforma gratuita de prática de terminal Linux online e um jogo de aprendizado de bash focado no aprendizado prático. Ao contrário de vídeos teóricos, você aprende digitando comandos reais.
O BashQuest oferece uma simulação completa de terminal com objetivos claros e progressivos, 100% segura e no navegador.
Por que criei o projeto
Quando comecei a aprender Linux, tinha receio de danificar meu computador com comandos errados. Criei um ambiente seguro e sem riscos onde qualquer pessoa pode aprender de graça sem instalar nada.
Digitar comandos, ler saídas e corrigir erros constrói memória muscular real e confiança no uso do Linux.
Prática de Terminal Linux Online com Feedback Imediato
A retenção é muito maior quando você testa os comandos na hora. O BashQuest valida cada etapa automaticamente no navegador.
Um Terminal Linux Virtual para um Aprendizado Eficaz
O BashQuest oferece uma simulação completa de terminal com objetivos claros e progressivos, 100% segura e no navegador.
Por que a Prática Melhora a Fixação
Digitar comandos, ler saídas e corrigir erros constrói memória muscular real e confiança no uso do Linux.
O que você vai aprender
Nosso currículo estruturado abrange 16 áreas fundamentais da administração Linux:
Fundamentos do Sistema de Arquivos
Manipulação de Arquivos
Pipes e Filtragem
Redirecionamento e Segurança
Superusuário e Pacotes
Disco e Recursos do Sistema
Gerenciamento de Processos
Solução de Problemas de Rede
Busca de Arquivos
Serviços e Systemd
Edição de Texto no Terminal
Scripts Shell e Automação
Processamento Avançado de Texto
Ambiente e Usuários
Sistema de Arquivos Avançado
Acesso Remoto e Admin de Usuários
Ferramentas & Utilitários Web Linux
Calculadora de permissões chmod, gerador de cron, testador de expressões regulares e guia de comandos.
Chmod calculator
Octal & symbolic output
chmod 000 [file]Cron job explainer
Plain-English translation
Command synthesizer
Pick a task, get the command
Select a task above to see the command.
—