Tutorial Anterior: Estação de Trabalho como Código (Parte 1)
Próximo Tutorial: Estação de Trabalho como Código (Parte 2)
Na Parte 1, você instalou diversas ferramentas essenciais do Linux. Mas simplesmente instalar não é suficiente - é importante compreender o propósito de cada uma, saber quando e como usá-las, e entender como integrá-las com seu fluxo de trabalho.
Este tutorial é um guia de referência completo sobre as ferramentas instaladas. Você aprenderá não apenas como usar cada uma, mas também quando escolher entre alternativas similares e como integrá-las com Bash para aumentar sua produtividade.
Importante: Este tutorial é complementar e opcional. Se você já conhece essas ferramentas, pode pular para a Parte 2. Se é iniciante, este guia será invaluável.
Este tutorial é ideal para:
Pré-conhecimento: Conclusão da Parte 1 é essencial.
⏱ 90-120 minutos
Isso inclui:
Descrição: O vim (Vi IMproved) é um editor de texto altamente configurável e eficiente, amplamente utilizado por programadores e administradores de sistema. Ele opera em diferentes modos (normal, inserção, visual, comando) para manipulação de texto, oferecendo recursos avançados como realce de sintaxe, macros e plugins.
Instalado em: Parte 1
Exemplo de Uso:
# Abrir arquivo para edição
$ vim meu_arquivo.txt
# Abrir em modo read-only
$ vim -R arquivo.txt
# Abrir em múltiplas janelas
$ vim -O arquivo1.txt arquivo2.txt
Dicas Profissionais:
:set number para mostrar números de linha:set relativenumber para números relativos:%s/antigo/novo/g para substituição globaldd para deletar linha, yy para copiarIntegração com Bash:
# Alias para abrir vim rapidamente
alias v='vim'
alias vi='vim'
# Função para editar arquivo e executar
edit_and_run() {
vim "$1"
bash "$1"
}
Alternativas:
Descrição: O nano é um editor de texto simples e amigável, ideal para iniciantes. Oferece uma interface intuitiva com atalhos de teclado visíveis na tela, sendo perfeito para edições rápidas de arquivos de configuração.
Instalado em: Parte 1
Exemplo de Uso:
# Abrir arquivo para edição
$ nano meu_arquivo.txt
# Criar novo arquivo
$ nano novo_arquivo.txt
Atalhos Úteis:
Ctrl+X: SairCtrl+O: SalvarCtrl+W: BuscarCtrl+K: Cortar linhaIntegração com Bash:
# Usar nano como editor padrão
export EDITOR=nano
# Alias para editar rapidamente
alias n='nano'
Descrição: O curl é uma ferramenta de linha de comando para transferir dados com sintaxe de URL. Suporta HTTP, HTTPS, FTP, FTPS, SCP, SFTP e muitos outros protocolos. Frequentemente usado para testar APIs, baixar arquivos e interagir com serviços web.
Instalado em: Parte 1
Exemplos de Uso:
# Fazer requisição GET simples
$ curl https://api.example.com/data
# Fazer requisição POST com dados
$ curl -X POST -d "param1=value1" https://api.example.com/endpoint
# Salvar resposta em arquivo
$ curl https://example.com/arquivo.zip -o arquivo.zip
# Incluir headers customizados
$ curl -H "Authorization: Bearer TOKEN" https://api.example.com/data
# Seguir redirecionamentos
$ curl -L https://example.com/redirect
# Mostrar headers de resposta
$ curl -i https://example.com
# Fazer requisição com autenticação básica
$ curl -u usuario:senha https://api.example.com/data
Dicas Profissionais:
-v para modo verbose (debug)-X para especificar método HTTP-d para enviar dados-H para adicionar headersIntegração com Bash:
# Função para testar API rapidamente
test_api() {
local url=$1
local method=${2:-GET}
curl -X "$method" -v "$url"
}
# Alias para requisições comuns
alias curl_json='curl -H "Content-Type: application/json"'
Descrição: O wget é um utilitário de linha de comando para download de arquivos da web. Suporta HTTP, HTTPS e FTP, pode retomar downloads interrompidos, baixar recursivamente sites inteiros e trabalhar em segundo plano.
Instalado em: Parte 1
Exemplos de Uso:
# Download simples
$ wget https://example.com/arquivo.zip
# Download com nome customizado
$ wget https://example.com/arquivo.zip -O meu_arquivo.zip
# Retomar download interrompido
$ wget -c https://example.com/arquivo.zip
# Baixar recursivamente um site
$ wget -r https://example.com
# Baixar com limite de velocidade
$ wget --limit-rate=100k https://example.com/arquivo.zip
# Baixar múltiplos arquivos
$ wget https://example.com/arquivo1.zip https://example.com/arquivo2.zip
Dicas Profissionais:
-c para retomar downloads-r para download recursivo--limit-rate para limitar velocidade-b para download em backgroundIntegração com Bash:
# Função para download com progresso
download_file() {
local url=$1
local output=${2:-$(basename "$url")}
wget -c "$url" -O "$output"
}
# Alias para download rápido
alias wget_bg='wget -b'
Comparação: curl vs wget
| Aspecto | curl | wget |
|---|---|---|
| Protocolos | Muitos | HTTP/HTTPS/FTP |
| APIs | Excelente | Bom |
| Download Recursivo | Não | Sim |
| Retomar Download | Sim | Sim |
| Sintaxe | Complexa | Simples |
| Uso | APIs, testes | Downloads, mirrors |
Descrição: O dig (Domain Information Groper) é uma ferramenta para consultar servidores DNS. Fornece informações detalhadas sobre registros DNS, sendo essencial para diagnóstico de problemas de rede e configuração de domínios.
Instalado em: Parte 1 (via dnsutils)
Exemplos de Uso:
# Consultar registro A (IPv4)
$ dig example.com
# Consultar tipo específico de registro
$ dig example.com MX # Mail servers
$ dig example.com NS # Name servers
$ dig example.com CNAME # Aliases
# Consultar servidor DNS específico
$ dig @8.8.8.8 example.com
# Modo curto (apenas resultado)
$ dig +short example.com
# Rastrear caminho de resolução
$ dig +trace example.com
Dicas Profissionais:
+short para saída concisa+trace para entender resolução@servidor para consultar servidor específicoIntegração com Bash:
# Função para verificar DNS rapidamente
check_dns() {
local domain=$1
dig +short "$domain"
}
# Alias para consultas comuns
alias dig_mx='dig +short MX'
alias dig_ns='dig +short NS'
Descrição: O nmap (Network Mapper) é uma ferramenta de exploração de rede e auditoria de segurança. Descobre hosts e serviços em uma rede, detecta portas abertas, identifica sistemas operacionais e versões de serviços.
Instalado em: Parte 1
Exemplos de Uso:
# Escanear portas abertas
$ nmap example.com
# Escanear portas específicas
$ nmap -p 80,443,22 example.com
# Escanear faixa de portas
$ nmap -p 1-1000 example.com
# Detecção de versão
$ nmap -sV example.com
# Detecção de SO
$ nmap -O example.com
# Escanear rede inteira
$ nmap 192.168.1.0/24
# Modo agressivo (mais informações)
$ nmap -A example.com
Dicas Profissionais:
-sV para detectar versões-O para detectar SO-A para modo agressivo-p- para escanear todas as portasAviso: Use nmap apenas em redes que você possui ou tem permissão. Uso não autorizado é ilegal.
Integração com Bash:
# Função para escanear portas comuns
scan_ports() {
local host=$1
nmap -p 22,80,443,3306,5432 "$host"
}
Descrição: O iftop é uma ferramenta de monitoramento de rede em tempo real. Exibe o uso da largura de banda em uma interface de rede, mostrando quais hosts estão consumindo mais dados.
Instalado em: Parte 1
Exemplo de Uso:
# Monitorar tráfego na interface padrão
$ sudo iftop
# Monitorar interface específica
$ sudo iftop -i eth0
# Modo não-interativo
$ sudo iftop -n
Atalhos Úteis:
n: Alternar nomes/IPss: Alternar escalap: Alternar portasq: SairDescrição: O fzf (fuzzy finder) é um localizador de arquivos interativo e de uso geral. Permite pesquisar e selecionar arquivos ou diretórios de forma rápida e eficiente usando correspondência difusa (fuzzy matching).
Instalado em: Parte 1
Exemplos de Uso:
# Buscar arquivo interativamente
$ fzf
# Abrir arquivo selecionado com vim
$ vim $(fzf)
# Buscar em diretório específico
$ fzf --preview 'cat {}'
# Integração com histórico bash
$ history | fzf
Integração com Bash:
# Função para abrir arquivo com fzf
fopen() {
local file
file=$(fzf --preview 'cat {}')
[ -n "$file" ] && vim "$file"
}
# Alias para buscar e abrir
alias ff='fzf --preview "cat {}"'
# Função para buscar em histórico
fhistory() {
eval "$(history | fzf --tac | sed 's/^[[:space:]]*[0-9]\+[[:space:]]\+//')"
}
Descrição: O fd (fd-find) é uma alternativa mais rápida e amigável ao comando find. Oferece sintaxe mais simples, saída colorida por padrão, e é otimizado para velocidade.
Instalado em: Parte 1
Exemplos de Uso:
# Encontrar todos os arquivos .log
$ fd .log
# Encontrar diretórios
$ fd -t d nome_diretorio
# Encontrar arquivos com padrão regex
$ fd 'test.*\.py'
# Executar comando em cada resultado
$ fd .log -x rm {}
# Limitar profundidade
$ fd -d 2 arquivo.txt
Comparação: find vs fd
| Aspecto | find | fd |
|---|---|---|
| Sintaxe | Complexa | Simples |
| Velocidade | Lenta | Rápida |
| Cores | Não | Sim |
| Padrão | Glob | Regex |
| Curva de Aprendizado | Alta | Baixa |
Integração com Bash:
# Alias para buscas comuns
alias fds='fd -t f' # Apenas arquivos
alias fdd='fd -t d' # Apenas diretórios
alias fdl='fd .log' # Arquivos de log
# Função para encontrar e editar
fdedit() {
local file
file=$(fd "$1" | fzf)
[ -n "$file" ] && vim "$file"
}
Descrição: O ripgrep (rg) é uma ferramenta de busca de linha de comando que combina usabilidade do grep com velocidade. Otimizado para pesquisar recursivamente diretórios em busca de padrões regex.
Instalado em: Parte 1
Exemplos de Uso:
# Buscar string em arquivos
$ rg "minha_funcao"
# Buscar em tipo de arquivo específico
$ rg "minha_funcao" -g "*.py"
# Buscar com contexto
$ rg "minha_funcao" -C 3
# Buscar case-insensitive
$ rg -i "funcao"
# Contar ocorrências
$ rg "funcao" --count
# Listar apenas nomes de arquivo
$ rg "funcao" -l
Comparação: grep vs rg
| Aspecto | grep | rg |
|---|---|---|
| Velocidade | Lenta | Muito rápida |
| Sintaxe | Simples | Simples |
| Recursivo | Com -r | Por padrão |
| Cores | Não | Sim |
| Ignora .gitignore | Não | Sim |
Integração com Bash:
# Alias para buscas comuns
alias rg_py='rg -g "*.py"'
alias rg_js='rg -g "*.js"'
# Função para buscar e editar
rgedit() {
local file
file=$(rg "$1" -l | fzf)
[ -n "$file" ] && vim "$file"
}
Descrição: O plocate é uma alternativa mais rápida ao locate para encontrar arquivos no sistema de arquivos. Usa um banco de dados pré-indexado, tornando buscas extremamente rápidas.
Instalado em: Parte 1
Exemplos de Uso:
# Encontrar arquivo por nome
$ plocate config
# Busca case-insensitive
$ plocate -i CONFIG
# Contar ocorrências
$ plocate -c config
# Atualizar banco de dados
$ sudo updatedb
Integração com Bash:
# Alias para buscas rápidas
alias locate='plocate'
# Função para encontrar e abrir
plocate_open() {
local file
file=$(plocate "$1" | fzf)
[ -n "$file" ] && vim "$file"
}
Descrição: O btop é um monitor de recursos do sistema em tempo real, interativo e com interface colorida. Exibe informações sobre CPU, memória, discos, rede e processos.
Instalado em: Parte 1
Exemplo de Uso:
# Iniciar monitor
$ btop
# Modo não-interativo
$ btop -b
Atalhos Úteis:
q: Sairp: Alternar processosm: Alternar memórian: Alternar redeIntegração com Bash:
# Alias para monitorar
alias monitor='btop'
alias top='btop'
Descrição: O strace é uma ferramenta de diagnóstico que monitora chamadas de sistema e sinais recebidos por um processo. Útil para depurar programas e entender interações com o kernel.
Instalado em: Parte 1
Exemplos de Uso:
# Rastrear chamadas de sistema
$ strace ls
# Rastrear processo em execução
$ strace -p PID
# Salvar saída em arquivo
$ strace -o trace.txt ls
# Contar chamadas de sistema
$ strace -c ls
Dicas Profissionais:
-c para resumo de chamadas-e para filtrar chamadas específicas-o para salvar em arquivoDescrição: O jq é um processador JSON leve e flexível de linha de comando. Permite fatiar, filtrar, mapear e transformar dados JSON com facilidade.
Instalado em: Parte 1
Exemplos de Uso:
# Extrair campo específico
$ echo '{"name": "Alice", "age": 30}' | jq '.name'
# Extrair múltiplos campos
$ echo '{"name": "Alice", "age": 30}' | jq '.name, .age'
# Filtrar array
$ echo '[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]' | jq '.[] | select(.age > 26)'
# Transformar estrutura
$ echo '{"name": "Alice"}' | jq '{person: .name}'
# Formatar JSON
$ curl https://api.example.com/data | jq '.'
Integração com Bash:
# Função para parsear JSON de API
get_json_field() {
local url=$1
local field=$2
curl -s "$url" | jq "$field"
}
# Alias para formatar JSON
alias jq_format='jq "."'
Descrição: O bat é um clone do cat com superpoderes. Oferece realce de sintaxe, integração com git, numeração de linhas e paginação automática.
Instalado em: Parte 1
Exemplos de Uso:
# Visualizar arquivo com realce
$ bat meu_script.py
# Mostrar números de linha
$ bat -n meu_script.py
# Mostrar apenas linhas específicas
$ bat --line-range 1:10 meu_script.py
# Usar como paginador
$ man bash | bat
Integração com Bash:
# Usar bat como paginador padrão
export PAGER="bat"
# Alias para substituir cat
alias cat='bat'
# Função para visualizar com números
view_lines() {
bat -n "$1"
}
Descrição: O eza é um substituto moderno para ls. Oferece saída colorida, visualização de ícones, informações detalhadas e melhor legibilidade.
Instalado em: Parte 1
Exemplos de Uso:
# Listar com detalhes
$ eza -l
# Listar recursivamente
$ eza -R
# Mostrar árvore de diretórios
$ eza --tree
# Listar com ícones
$ eza -l --icons
# Ordenar por tamanho
$ eza -lS
Integração com Bash:
# Alias para substituir ls
alias ls='eza'
alias ll='eza -l'
alias la='eza -la'
alias tree='eza --tree'
# Função para listar com filtro
lsgrep() {
eza -l | grep "$1"
}
Descrição: O grc (Generic Colouriser) é um wrapper que adiciona cores à saída de comandos de linha de comando, tornando logs e saídas mais legíveis.
Instalado em: Parte 1
Exemplos de Uso:
# Colorir saída de ping
$ grc ping google.com
# Colorir saída de traceroute
$ grc traceroute google.com
# Colorir saída de ps
$ grc ps aux
# Colorir saída de netstat
$ grc netstat -an
Integração com Bash:
# Alias para comandos comuns
alias ping='grc ping'
alias traceroute='grc traceroute'
alias ps='grc ps'
alias netstat='grc netstat'
Descrição: O tldr (Too Long; Didn't Read) é uma coleção de páginas de manual simplificadas e exemplos práticos para comandos de linha de comando.
Instalado em: Parte 1
Exemplos de Uso:
# Ver exemplos de comando
$ tldr tar
# Ver exemplos de outro comando
$ tldr find
# Atualizar banco de dados
$ tldr --update
Integração com Bash:
# Alias para referência rápida
alias help='tldr'
# Função para buscar comando
cmd_help() {
tldr "$1" || man "$1"
}
Descrição: O lshw (list hardware) fornece informações detalhadas sobre a configuração de hardware do sistema, incluindo memória, CPU, placa-mãe, adaptadores de rede e dispositivos de armazenamento.
Instalado em: Parte 1
Exemplos de Uso:
# Listar todo hardware
$ sudo lshw
# Formato HTML
$ sudo lshw -html > hardware.html
# Apenas informações de CPU
$ sudo lshw -C cpu
# Apenas informações de memória
$ sudo lshw -C memory
Descrição: O hwinfo é uma ferramenta para detectar hardware presente no sistema, fornecendo saída detalhada sobre componentes.
Instalado em: Parte 1
Exemplos de Uso:
# Resumo do hardware
$ hwinfo --short
# Informações detalhadas
$ hwinfo
# Apenas CPU
$ hwinfo --cpu
# Apenas memória
$ hwinfo --memory
Descrição: O fwupd é um daemon para gerenciamento de firmware em sistemas Linux, permitindo atualizar firmware de dispositivos de hardware.
Instalado em: Parte 1
Exemplos de Uso:
# Verificar atualizações
$ fwupdmgr refresh && fwupdmgr get-updates
# Atualizar firmware
$ fwupdmgr update
# Listar dispositivos
$ fwupdmgr get-devices
Descrição: O ethtool é uma ferramenta para consultar e controlar configurações de drivers de dispositivos de rede Ethernet.
Instalado em: Parte 1
Exemplos de Uso:
# Informações sobre interface
$ ethtool eth0
# Velocidade de conexão
$ ethtool eth0 | grep Speed
# Estatísticas
$ ethtool -S eth0
Descrição: O rsync é uma ferramenta de sincronização de arquivos rápida e versátil. Copia e sincroniza arquivos localmente e remotamente, minimizando transferência de dados.
Instalado em: Parte 1
Exemplos de Uso:
# Sincronizar diretório local
$ rsync -avz /origem/ /destino/
# Sincronizar com servidor remoto
$ rsync -avz /origem/ usuario@host:/destino/
# Sincronizar com deleção
$ rsync -avz --delete /origem/ /destino/
# Mostrar progresso
$ rsync -avz --progress /origem/ /destino/
# Backup com timestamp
$ rsync -avz /origem/ /backup/backup-$(date +%Y%m%d)/
Integração com Bash:
# Função para backup automático
backup_dir() {
local source=$1
local dest=$2
rsync -avz --delete "$source" "$dest/backup-$(date +%Y%m%d)/"
}
# Alias para sincronização
alias sync_backup='rsync -avz --delete'
Descrição: O traceroute exibe a rota (caminho) e mede atrasos de trânsito de pacotes através de uma rede IP. Lista todos os roteadores pelos quais um pacote passa.
Instalado em: Parte 1
Exemplos de Uso:
# Rastrear rota para domínio
$ traceroute google.com
# Usar UDP em vez de ICMP
$ traceroute -U google.com
# Limitar número de hops
$ traceroute -m 10 google.com
Descrição: O whois permite obter informações sobre domínios da internet, endereços IP e blocos de rede, incluindo registrante, contato e servidores de nome.
Instalado em: Parte 1
Exemplos de Uso:
# Informações de domínio
$ whois example.com
# Informações de IP
$ whois 8.8.8.8
# Apenas registrante
$ whois example.com | grep Registrant
Descrição: O ipcalc é uma ferramenta para cálculos de rede IP, calculando endereço de broadcast, máscara de rede, número de hosts e faixa de endereços.
Instalado em: Parte 1
Exemplos de Uso:
# Calcular informações de rede
$ ipcalc 192.168.1.1/24
# Apenas endereço de broadcast
$ ipcalc -b 192.168.1.1/24
# Apenas máscara de rede
$ ipcalc -m 192.168.1.1/24
Integração com Bash:
# Função para calcular rede rapidamente
calc_net() {
ipcalc "$1"
}
# Alias para cálculos comuns
alias ipcalc_24='ipcalc -m /24'
| Ferramenta | Velocidade | Sintaxe | Cores | Recursivo | Melhor Para |
|---|---|---|---|---|---|
| find | Lenta | Complexa | Não | Sim | Buscas complexas |
| fd | Rápida | Simples | Sim | Sim | Buscas simples |
| locate | Muito rápida | Simples | Não | N/A | Buscas por nome |
| plocate | Muito rápida | Simples | Não | N/A | Buscas por nome |
| Ferramenta | Velocidade | Recursivo | Ignora .gitignore | Cores | Melhor Para |
|---|---|---|---|---|---|
| grep | Lenta | Com -r | Não | Não | Padrão |
| ack | Rápida | Por padrão | Sim | Sim | Código |
| ag | Muito rápida | Por padrão | Sim | Sim | Código |
| rg | Muito rápida | Por padrão | Sim | Sim | Código |
| Ferramenta | Cores | Ícones | Árvore | Detalhes | Melhor Para |
|---|---|---|---|---|---|
| ls | Não | Não | Não | Básicos | Padrão |
| exa | Sim | Não | Sim | Completos | Moderno |
| eza | Sim | Sim | Sim | Completos | Moderno |
| tree | Não | Não | Sim | Básicos | Árvore |
#!/bin/bash
################################################################################
################################################################################
smart_search() {
local search_term=$1
if [ -z "$search_term" ]; then
echo "Uso: smart_search <termo>"
return 1
fi
local file
# Tentar com ripgrep primeiro (mais rápido)
if command -v rg &> /dev/null; then
file=$(rg "$search_term" -l | fzf --preview "bat {}" --preview-window=right:50%)
elif command -v grep &> /dev/null; then
file=$(grep -r "$search_term" . -l 2>/dev/null | fzf --preview "cat {}")
else
echo "Erro: ripgrep ou grep não encontrado"
return 1
fi
if [ -n "$file" ]; then
vim "$file"
else
echo "Nenhum arquivo selecionado"
return 1
fi
}
fdedit() {
local pattern=$
if ! command -v fd &> /dev/null; then
echo "Erro: fd não encontrado"
return 1
fi
local file
file=$(fd "$pattern" | fzf --preview "bat {}" --preview-window=right:50%)
if [ -n "$file" ]; then
vim "$file"
else
echo "Nenhum arquivo selecionado"
return 1
fi
}
rgedit() {
local search_term=
if [ -z "$search_term" ]; then
echo "Uso: rgedit <termo> [tipo_arquivo]"
return 1
fi
if ! command -v rg &> /dev/null; then
echo "Erro: ripgrep não encontrado"
return 1
fi
local file
file=$(rg "$search_term" -g "$file_type" -l | fzf --preview "bat {}" --preview-window=right:50%)
if [ -n "$file" ]; then
vim "$file"
else
echo "Nenhum arquivo encontrado"
return 1
fi
}
plocate_open() {
local search_term=$1
if [ -z "$search_term" ]; then
echo "Uso: plocate_open <termo>"
return 1
fi
if ! command -v plocate &> /dev/null; then
echo "Erro: plocate não encontrado"
return 1
fi
local file
file=$(plocate "$search_term" | fzf --preview "bat {}" --preview-window=right:50%)
if [ -n "$file" ]; then
vim "$file"
else
echo "Nenhum arquivo encontrado"
return 1
fi
}
fopen() {
if ! command -v fzf &> /dev/null; then
echo "Erro: fzf não encontrado"
return 1
fi
local file
file=$(fzf --preview "bat {}" --preview-window=right:50%)
if [ -n "$file" ]; then
vim "$file"
else
echo "Nenhum arquivo selecionado"
return 1
fi
}
lsgrep() {
local pattern=$1
if [ -z "$pattern" ]; then
echo "Uso: lsgrep <padrão>"
return 1
fi
if command -v eza &> /dev/null; then
eza -l | grep "$pattern"
else
ls -l | grep "$pattern"
fi
}
test_api() {
local url=
if [ -z "$url" ]; then
echo "Uso: test_api <url> [método]"
return 1
fi
if ! command -v curl &> /dev/null; then
echo "Erro: curl não encontrado"
return 1
fi
echo "Testando $method $url..."
curl -X "$method" -v "$url"
}
check_dns() {
local domain=
if [ -z "$domain" ]; then
echo "Uso: check_dns <domínio> [tipo]"
return 1
fi
if ! command -v dig &> /dev/null; then
echo "Erro: dig não encontrado"
return 1
fi
echo "Consultando $type para $domain..."
dig +short "$domain" "$type"
}
scan_ports() {
local host=$1
if [ -z "$host" ]; then
echo "Uso: scan_ports <host>"
return 1
fi
if ! command -v nmap &> /dev/null; then
echo "Erro: nmap não encontrado"
return 1
fi
echo "Escaneando portas comuns em $host..."
nmap -p 22,80,443,3306,5432 "$host"
}
calc_net() {
local network=$1
if [ -z "$network" ]; then
echo "Uso: calc_net <ip/máscara>"
return 1
fi
if ! command -v ipcalc &> /dev/null; then
echo "Erro: ipcalc não encontrado"
return 1
fi
ipcalc "$network"
}
get_json_field() {
local url=$1
local field=$2
if [ -z "$url" ] || [ -z "$field" ]; then
echo "Uso: get_json_field <url> <campo>"
return 1
fi
if ! command -v curl &> /dev/null; then
echo "Erro: curl não encontrado"
return 1
fi
if ! command -v jq &> /dev/null; then
echo "Erro: jq não encontrado"
return 1
fi
curl -s "$url" | jq "$field"
}
backup() {
local source=
if [ -z "$source" ]; then
echo "Uso: backup <origem> [destino]"
return 1
fi
if ! command -v rsync &> /dev/null; then
echo "Erro: rsync não encontrado"
return 1
fi
local backup_dir="$dest/backup-$(date +%Y%m%d-%H%M%S)"
echo "Iniciando backup de $source para $backup_dir..."
rsync -avz --progress "$source" "$backup_dir"
if [ $? -eq 0 ]; then
echo "Backup concluído com sucesso!"
else
echo "Erro durante o backup"
return 1
fi
}
backup_dir() {
local source=$1
local dest=$2
if [ -z "$source" ] || [ -z "$dest" ]; then
echo "Uso: backup_dir <origem> <destino>"
return 1
fi
if ! command -v rsync &> /dev/null; then
echo "Erro: rsync não encontrado"
return 1
fi
local backup_dir="$dest/backup-$(date +%Y%m%d-%H%M%S)"
echo "Sincronizando $source para $backup_dir..."
rsync -avz --delete "$source" "$backup_dir"
if [ $? -eq 0 ]; then
echo "Sincronização concluída!"
else
echo "Erro durante sincronização"
return 1
fi
}
download_file() {
local url={2:-url")}
if [ -z "$url" ]; then
echo "Uso: download_file <url> [nome_saída]"
return 1
fi
if ! command -v wget &> /dev/null; then
echo "Erro: wget não encontrado"
return 1
fi
echo "Baixando $url para $output..."
wget -c "$url" -O "$output"
if [ $? -eq 0 ]; then
echo "Download concluído!"
else
echo "Erro durante download"
return 1
fi
}
sync_backup() {
local source=$1
local dest=$2
if [ -z "$source" ] || [ -z "$dest" ]; then
echo "Uso: sync_backup <origem> <destino>"
return 1
fi
if ! command -v rsync &> /dev/null; then
echo "Erro: rsync não encontrado"
return 1
fi
echo "Sincronizando $source para $dest (com deleção)..."
rsync -avz --delete --progress "$source" "$dest"
if [ $? -eq 0 ]; then
echo "Sincronização concluída!"
else
echo "Erro durante sincronização"
return 1
fi
}
system_info() {
echo "╔════════════════════════════════════════════════════════════════╗"
echo "║ INFORMAÇÕES DO SISTEMA ║"
echo "╚════════════════════════════════════════════════════════════════╝"
echo ""
echo "=== CPU Info ==="
if command -v lshw &> /dev/null; then
sudo lshw -C cpu 2>/dev/null | grep -E "product|cores|threads" || echo "Sem informações"
else
echo "lshw não encontrado"
fi
echo ""
echo "=== Memory Info ==="
if command -v free &> /dev/null; then
free -h
else
echo "free não encontrado"
fi
echo ""
echo "=== Disk Usage ==="
if command -v df &> /dev/null; then
df -h | awk 'NR==1 || NR>1 {print}'
else
echo "df não encontrado"
fi
echo ""
echo "=== Network Interfaces ==="
if command -v ip &> /dev/null; then
ip -s link show | head -20
else
echo "ip não encontrado"
fi
echo ""
echo "=== Uptime ==="
uptime
}
cmd_help() {
local cmd=$1
if [ -z "$cmd" ]; then
echo "Uso: cmd_help <comando>"
return 1
fi
if command -v tldr &> /dev/null; then
tldr "$cmd"
elif command -v man &> /dev/null; then
man "$cmd"
else
echo "Erro: tldr ou man não encontrado"
return 1
fi
}
view_lines() {
local file=$1
if [ -z "$file" ]; then
echo "Uso: view_lines <arquivo>"
return 1
fi
if [ ! -f "$file" ]; then
echo "Erro: arquivo não encontrado"
return 1
fi
if command -v bat &> /dev/null; then
bat -n "$file"
else
cat -n "$file"
fi
}
edit_and_run() {
local file=$1
if [ -z "$file" ]; then
echo "Uso: edit_and_run <arquivo>"
return 1
fi
if ! command -v vim &> /dev/null; then
echo "Erro: vim não encontrado"
return 1
fi
vim "$file"
if [ -f "$file" ]; then
echo ""
echo "Executando $file..."
bash "$file"
fi
}
fhistory() {
if ! command -v fzf &> /dev/null; then
echo "Erro: fzf não encontrado"
return 1
fi
local cmd
cmd=$(history | fzf --tac | sed 's/^[[:space:]]*[0-9]\+[[:space:]]\+//')
if [ -n "$cmd" ]; then
eval "$cmd"
fi
}
mkcd() {
local dir=$1
if [ -z "$dir" ]; then
echo "Uso: mkcd <diretório>"
return 1
fi
mkdir -p "$dir" && cd "$dir" || return 1
}
cd_git_root() {
if ! command -v git &> /dev/null; then
echo "Erro: git não encontrado"
return 1
fi
local root
root=$(git rev-parse --show-toplevel 2>/dev/null)
if [ -n "$root" ]; then
cd "$root" || return 1
echo "Mudado para raiz do repositório: $root"
else
echo "Erro: não está em um repositório git"
return 1
fi
}
extract() {
local file=$1
if [ -z "$file" ]; then
echo "Uso: extract <arquivo>"
return 1
fi
if [ ! -f "$file" ]; then
echo "Erro: arquivo não encontrado"
return 1
fi
case "$file" in
*.tar.gz|*.tgz)
tar -xzf "$file"
;;
*.tar.bz2|*.tbz2)
tar -xjf "$file"
;;
*.tar.xz|*.txz)
tar -xJf "$file"
;;
*.tar)
tar -xf "$file"
;;
*.zip)
unzip "$file"
;;
*.rar)
unrar x "$file"
;;
*.7z)
7z x "$file"
;;
*)
echo "Formato não suportado: $file"
return 1
;;
esac
echo "Arquivo extraído com sucesso!"
}
compress() {
local source=
if [ -z "$source" ]; then
echo "Uso: compress <arquivo_ou_diretório> [formato]"
echo "Formatos suportados: tar.gz, tar.bz2, tar.xz, zip"
return 1
fi
if [ ! -e "$source" ]; then
echo "Erro: arquivo ou diretório não encontrado"
return 1
fi
local output="${source}.${format}"
case "$format" in
tar.gz|tgz)
tar -czf "$output" "$source"
;;
tar.bz2|tbz2)
tar -cjf "$output" "$source"
;;
tar.xz|txz)
tar -cJf "$output" "$source"
;;
tar)
tar -cf "$output" "$source"
;;
zip)
zip -r "$output" "$source"
;;
*)
echo "Formato não suportado: $format"
return 1
;;
esac
echo "Arquivo compactado: $output"
}
Experimente cada ferramenta:
tldrIntegre com Bash:
~/.bashrcCustomize seu Ambiente:
Você agora compreende o propósito de cada ferramenta instalada na Parte 1. Mais importante, você sabe:
✓ Quando usar cada ferramenta
✓ Como integrá-las com Bash
✓ Alternativas e quando escolhê-las
✓ Exemplos práticos de uso
✓ Como otimizar seu fluxo de trabalho
Essas ferramentas são a base de um ambiente CLI profissional. Domine-as e você será muito mais produtivo.
Tutorial Anterior: Estação de Trabalho como Código (Parte 1)
Próximo Tutorial: Estação de Trabalho como Código (Parte 2)
Fim da Parte 1.5
Domine as ferramentas essenciais do Linux e construa um ambiente CLI profissional.