├── Scripts ├── files │ ├── 0.py │ ├── 1.py │ ├── 2.py │ ├── 3.py │ ├── 4.py │ ├── 5.py │ └── editores.txt ├── weather.sh ├── hello_world.sh ├── last_updated.sh ├── AWK │ ├── concat.awk │ ├── invert.awk │ ├── dados.awk │ ├── media.awk │ └── script.awk ├── ping.sh ├── while.sh ├── create_dirs.sh ├── string_slicing.sh ├── comments.sh ├── sleep.sh ├── cut_substrings.sh ├── input.sh ├── sequence.sh ├── string_concat.sh ├── echo.sh ├── sum.sh ├── until.sh ├── file_existance.sh ├── arguments.sh ├── manipulation.sh ├── root.sh ├── extensions.sh ├── help.sh ├── reading_files.sh ├── email.sh ├── or.sh ├── users.sh ├── system_update.sh ├── backup.sh ├── create_dir.sh ├── random.sh ├── date_time.sh ├── named_arguments.sh ├── for.sh ├── switch.sh ├── and.sh ├── functions.sh ├── files_directories.sh ├── mult_comments.sh ├── hello.sh ├── path.sh ├── arrays.sh └── backup-08-15-2020.tar ├── Arquivos ├── hello.txt ├── shadow.txt ├── dominios.txt ├── numeros.txt ├── pessoas.csv ├── alimentos.txt ├── lista_arquivos.txt ├── linguagens.txt ├── cientistas.txt ├── cientistas_ordenados.txt ├── cavaleiros.txt ├── livros.csv └── tuplas.py ├── Imagens ├── OSI.png ├── awk.png ├── awk2.png ├── bash.png ├── htop.png ├── top.png ├── shell.png ├── GnUnixLinux.png ├── datastreams.png ├── permissions.png ├── permissoes.png ├── Process_states.png ├── linux_layers.png ├── linux-filesystem.png └── linux-filesystem 2.png ├── Conteúdo ├── Referências.md ├── Introdução.md ├── Atalhos.md ├── Compressão.md ├── Softwares.md ├── Permissões.md ├── Informações.md ├── Usuários.md ├── Diretórios&Arquivos.md ├── Processos.md └── GNUnixLinux.md └── README.md /Scripts/files/0.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Scripts/files/1.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Scripts/files/2.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Scripts/files/3.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Scripts/files/4.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Scripts/files/5.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Arquivos/hello.txt: -------------------------------------------------------------------------------- 1 | Hello World 2 | -------------------------------------------------------------------------------- /Scripts/weather.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | curl -4 wttr.in/$1 -------------------------------------------------------------------------------- /Arquivos/shadow.txt: -------------------------------------------------------------------------------- 1 | cat: /etc/shadow: Permissão negada 2 | -------------------------------------------------------------------------------- /Scripts/hello_world.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | echo "Hello World" -------------------------------------------------------------------------------- /Scripts/last_updated.sh: -------------------------------------------------------------------------------- 1 | ls -lrt | grep ^- | awk 'END{print $NF}' -------------------------------------------------------------------------------- /Scripts/AWK/concat.awk: -------------------------------------------------------------------------------- 1 | { nomes = nomes $1 " " } 2 | END { print nomes } -------------------------------------------------------------------------------- /Arquivos/dominios.txt: -------------------------------------------------------------------------------- 1 | www..google....com 2 | www.tibia..com 3 | www...w3schools....com -------------------------------------------------------------------------------- /Scripts/files/editores.txt: -------------------------------------------------------------------------------- 1 | Sublime Text 2 | Visual Studio Code 3 | Atom 4 | Vim 5 | Emacs -------------------------------------------------------------------------------- /Arquivos/numeros.txt: -------------------------------------------------------------------------------- 1 | 1 2 | 13 3 | 27 4 | 7 5 | 9 6 | 600 7 | 8 8 | 3 9 | 10 10 | -------------------------------------------------------------------------------- /Imagens/OSI.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/OSI.png -------------------------------------------------------------------------------- /Imagens/awk.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/awk.png -------------------------------------------------------------------------------- /Imagens/awk2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/awk2.png -------------------------------------------------------------------------------- /Imagens/bash.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/bash.png -------------------------------------------------------------------------------- /Imagens/htop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/htop.png -------------------------------------------------------------------------------- /Imagens/top.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/top.png -------------------------------------------------------------------------------- /Scripts/ping.sh: -------------------------------------------------------------------------------- 1 | if ping -c 1 google.com; then 2 | echo "Internet está operando." 3 | fi -------------------------------------------------------------------------------- /Imagens/shell.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/shell.png -------------------------------------------------------------------------------- /Arquivos/pessoas.csv: -------------------------------------------------------------------------------- 1 | saldo,nome 2 | R$1,000,gabriel 3 | R$2,000,rafael 4 | R$3,000,miguel 5 | R$4,000,emanuel -------------------------------------------------------------------------------- /Imagens/GnUnixLinux.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/GnUnixLinux.png -------------------------------------------------------------------------------- /Imagens/datastreams.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/datastreams.png -------------------------------------------------------------------------------- /Imagens/permissions.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/permissions.png -------------------------------------------------------------------------------- /Imagens/permissoes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/permissoes.png -------------------------------------------------------------------------------- /Imagens/Process_states.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/Process_states.png -------------------------------------------------------------------------------- /Imagens/linux_layers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/linux_layers.png -------------------------------------------------------------------------------- /Imagens/linux-filesystem.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/linux-filesystem.png -------------------------------------------------------------------------------- /Imagens/linux-filesystem 2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/linux-filesystem 2.png -------------------------------------------------------------------------------- /Scripts/while.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | i=0 4 | while [ $i -le 10 ] 5 | do 6 | echo "Número: $i" 7 | ((i++)) 8 | done -------------------------------------------------------------------------------- /Scripts/create_dirs.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | echo -n "Informe o nome do dir: " 3 | read newdir 4 | cmd="mkdir $newdir" 5 | eval $cmd -------------------------------------------------------------------------------- /Scripts/string_slicing.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | string="Programação com Bash" 4 | substring=${string:0:12} 5 | echo $substring -------------------------------------------------------------------------------- /Scripts/comments.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Elevando 2 na potência 3 4 | (( x = 2**3 )) 5 | 6 | # Imprimindo o resultado 7 | echo $x -------------------------------------------------------------------------------- /Arquivos/alimentos.txt: -------------------------------------------------------------------------------- 1 | Banana 2 | Tomate 3 | Alface 4 | Alface 5 | Cenoura 6 | Arroz 7 | Arroz 8 | Banana 9 | Tomate 10 | Abacate -------------------------------------------------------------------------------- /Arquivos/lista_arquivos.txt: -------------------------------------------------------------------------------- 1 | alimentos.txt 2 | cientistas.txt 3 | hello.txt 4 | linguagens.txt 5 | lista_arquivos.txt 6 | livros.csv 7 | -------------------------------------------------------------------------------- /Scripts/sleep.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "Quanto tempo de espera?" 4 | read time 5 | sleep $time 6 | echo "Esperados $time segundos!" -------------------------------------------------------------------------------- /Arquivos/linguagens.txt: -------------------------------------------------------------------------------- 1 | Bash 2 | Haskell 3 | Perl 4 | Python 5 | Java 6 | Ruby 7 | Lisp 8 | Go 9 | C++ 10 | C 11 | PHP 12 | Javascript -------------------------------------------------------------------------------- /Scripts/cut_substrings.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | string="Coluna1 Coluna2 Coluna3" 3 | substring=$(echo $string | cut -d ' ' -f 1-3) 4 | echo $substring -------------------------------------------------------------------------------- /Scripts/input.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -n "Informe seu nome: " 4 | read nome 5 | 6 | echo "Você informou $nome com ${#nome} caracteres" -------------------------------------------------------------------------------- /Scripts/sequence.sh: -------------------------------------------------------------------------------- 1 | echo {0..10} # passos: 1 2 | echo $(seq 0 10) # passos: 1 3 | echo $(seq 0 2 12) # passos: 2 4 | echo $(seq 20 -3 2) # passos: -3 -------------------------------------------------------------------------------- /Scripts/string_concat.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | sistema="Linux" 4 | linguagem="C" 5 | 6 | echo "O ${sistema} foi escrito com a linguagem ${linguagem}" -------------------------------------------------------------------------------- /Scripts/AWK/invert.awk: -------------------------------------------------------------------------------- 1 | { arr[NR] = $0 } 2 | 3 | END { 4 | i = NR 5 | for(i=NR; i > 0; i--) 6 | { 7 | print arr[i] 8 | } 9 | } -------------------------------------------------------------------------------- /Scripts/echo.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "Imprimindo texto" 4 | echo -n "Imprimindo texto sem uma nova linha" 5 | echo -e "\nImprimindo \t caracteres \t especiais\n" -------------------------------------------------------------------------------- /Scripts/sum.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | soma=0 3 | for (( i=1; i<=36; i++ )) 4 | do 5 | (( soma+=i )) 6 | echo -n "$i " 7 | done 8 | printf "\n" 9 | echo "Total = $soma" -------------------------------------------------------------------------------- /Scripts/until.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | COUNT=0 4 | # bash until loop 5 | until [ $COUNT -gt 5 ]; do 6 | echo Valor de COUNT é = $COUNT 7 | let COUNT++ 8 | done -------------------------------------------------------------------------------- /Scripts/file_existance.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | filename=$1 4 | if [ -f "$filename" ]; then 5 | echo "Arquivo existe" 6 | else 7 | echo "Arquivo não existe" 8 | fi -------------------------------------------------------------------------------- /Scripts/arguments.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "Total de argumentos = $#" 4 | echo "Primeiro argumento = $1" 5 | echo "Segundo argumento = $2" 6 | echo "Terceiro argumento = $3" -------------------------------------------------------------------------------- /Scripts/manipulation.sh: -------------------------------------------------------------------------------- 1 | STR="BASH" 2 | echo ${STR,} # bASH 3 | echo ${STR,,} # bash 4 | 5 | STR="programming!" 6 | echo ${STR^} # Programming! 7 | echo ${STR^^} # PROGRAMMING! -------------------------------------------------------------------------------- /Scripts/root.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | ROOT_UID=0 3 | 4 | if [ "$UID" -eq "$ROOT_UID" ] 5 | then 6 | echo "You are root." 7 | else 8 | echo "You are not root" 9 | fi 10 | exit 0 -------------------------------------------------------------------------------- /Scripts/extensions.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Recebe um diretório como argumento 4 | # Altera a extensão dos arquivos para .py 5 | for file in `ls $1/*` 6 | do 7 | mv $file $file.py 8 | done -------------------------------------------------------------------------------- /Scripts/help.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | for arg in "$@" 4 | do 5 | if [ "$arg" == "--help" ] || [ "$arg" == "-h" ] 6 | then 7 | echo "Argumento help ativado!" 8 | fi 9 | done -------------------------------------------------------------------------------- /Scripts/reading_files.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | filename='files/editores.txt' 4 | n=1 5 | cat $filename | while read line || [[ -n $line ]] 6 | do 7 | echo "Linha $n -> $line" 8 | n=$((n+1)) 9 | done -------------------------------------------------------------------------------- /Scripts/email.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | recipient='gabrielfelippe90@gmail.com' 3 | subject='Desenvolvimento de Software' 4 | message='Vamos desenvolver um projeto juntos?' 5 | `mail -s $subject $recipient <<< $message` 6 | -------------------------------------------------------------------------------- /Scripts/or.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -n "Escolha um número: " 4 | read n 5 | 6 | if [[ ( $n -eq 13 || $n -eq 27 ) ]] 7 | then 8 | echo "Número vencedor" 9 | else 10 | echo "Número incorreto!" 11 | fi -------------------------------------------------------------------------------- /Arquivos/cientistas.txt: -------------------------------------------------------------------------------- 1 | Isaac Newton 2 | Albert Einstein 3 | Werner Heisenberg 4 | Erwin Schrödinger 5 | Ludwig Boltzmann 6 | Henri Poincaré 7 | Carl Friedrich Gauss 8 | Michael Faraday 9 | Max Planck 10 | César Lattes -------------------------------------------------------------------------------- /Arquivos/cientistas_ordenados.txt: -------------------------------------------------------------------------------- 1 | Albert Einstein 2 | Carl Friedrich Gauss 3 | César Lattes 4 | Erwin Schrödinger 5 | Henri Poincaré 6 | Isaac Newton 7 | Ludwig Boltzmann 8 | Max Planck 9 | Michael Faraday 10 | Werner Heisenberg 11 | -------------------------------------------------------------------------------- /Scripts/users.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Usuários logados no sistema 4 | echo "Usuários atualmente logados: `who | wc -l`" 5 | echo "Usuários atualmente logados: `who -q | sed -n '1p'`" 6 | echo "Quantidade de usuários logados: `users | wc -w`" -------------------------------------------------------------------------------- /Scripts/system_update.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -e "\n$(date "+%d-%m-%Y --- %T") Iniciando Atualização\n" 4 | 5 | apt update 6 | apt upgrade -y 7 | 8 | apt autoremove 9 | apt autoclean 10 | 11 | echo -e "\n$(date "+%T") Script finalizado" -------------------------------------------------------------------------------- /Arquivos/cavaleiros.txt: -------------------------------------------------------------------------------- 1 | Seiya Pégaso 100 2 | Shiryu Dragão 98 3 | Hyoga Cisne 96 4 | Shun Andrômeda 94 5 | Ikki Fênix 99 6 | Jabu Unicórnio 87 7 | Marin Águia 92 8 | Algol Perseu 95 9 | Mu Áries 100 10 | Shaka Virgem 100 11 | Aiolos Sagitário 100 -------------------------------------------------------------------------------- /Scripts/AWK/dados.awk: -------------------------------------------------------------------------------- 1 | # Função para rolar um dado simulado 2 | # n -> número de lados 3 | function dado(n) { return 1 + int(rand() * n) } 4 | 5 | # Rolamos 2 vezes um dado de 6 lados 6 | # Imprimos a soma de pontos 7 | BEGIN { print dado(6) + dado(6) } 8 | -------------------------------------------------------------------------------- /Scripts/backup.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | backupfile=backup-$(date +%m-%d-%Y) 4 | archive=${1:-$backupfile} 5 | 6 | find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar" 7 | echo "Directory $PWD backed up in archive file \"$archive.tar.gz\"." 8 | exit 0 -------------------------------------------------------------------------------- /Scripts/create_dir.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -n "Informe o nome do diretório ->" 4 | read dir 5 | 6 | if [ -d "$dir" ] 7 | then 8 | echo "Diretório já existente" 9 | else 10 | `mkdir $dir` 11 | echo "Diretório criado com sucesso!" 12 | fi -------------------------------------------------------------------------------- /Scripts/random.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # O Bash fornece uma variável global RANDOM 4 | # que imprime um número aleatório entre 0 e 32.767 5 | # toda vez que o acessamos. 6 | echo $RANDOM $RANDOM $RANDOM 7 | 8 | # número aleatório entre 0-10 9 | echo $(($RANDOM % 11)) -------------------------------------------------------------------------------- /Scripts/date_time.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ano=`date +%Y` 4 | mes=`date +%m` 5 | dia=`date +%d` 6 | hora=`date +%H` 7 | minuto=`date +%M` 8 | segundo=`date +%S` 9 | 10 | echo `date` 11 | echo "Data atual: $dia-$mes-$ano" 12 | echo "Horário atual: $hora:$minuto:$segundo" -------------------------------------------------------------------------------- /Scripts/named_arguments.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | for arg in "$@" 4 | do 5 | index=$(echo $arg | cut -f1 -d=) 6 | valor=$(echo $arg | cut -f2 -d=) 7 | case $index in 8 | X | x) x=$valor;; 9 | Y | y) y=$valor;; 10 | *) 11 | esac 12 | done 13 | ((z=x+y)) 14 | echo "$x+$y=$z" -------------------------------------------------------------------------------- /Scripts/for.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | for (( i=1; i<=13; i++ )) 4 | do 5 | echo -n "$i " 6 | done 7 | 8 | printf "\n" 9 | 10 | for i in $(ls) 11 | do 12 | echo "$i" 13 | done 14 | 15 | for i in {0..20..4} 16 | do 17 | printf "$i\t" 18 | done 19 | 20 | printf "\n" -------------------------------------------------------------------------------- /Scripts/switch.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -n "Informe uma opção (1, 2 ou 3): " 4 | read num 5 | 6 | case $num in 7 | 1) 8 | echo "Opção 1 Selecionada";; 9 | 2) 10 | echo "Opção 2 Selecionada";; 11 | 3) 12 | echo "Opção 3 Selecionada";; 13 | *) 14 | echo "Opção inexistente";; 15 | esac -------------------------------------------------------------------------------- /Scripts/and.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo -n "Informe um número: " 4 | read num 5 | 6 | if [[ ( $num -ge 0 ) && ( $num%2 -eq 0 ) ]] 7 | then 8 | echo "Número é par e positivo" 9 | elif [[ (( $num -lt 0 )) ]] 10 | then 11 | echo "Número é negativo" 12 | else 13 | echo "Número é ímpar" 14 | fi -------------------------------------------------------------------------------- /Scripts/AWK/media.awk: -------------------------------------------------------------------------------- 1 | { energia = energia + $3 } 2 | 3 | { printf "%-13s %-13s %6s %6d\n", $1,$2,$3,energia } 4 | 5 | END { 6 | print "-----------------------------------------" 7 | print "Total cavaleiros =", NR 8 | print "Energia total =", energia 9 | print "Energia média =", energia/NR 10 | } -------------------------------------------------------------------------------- /Scripts/functions.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | function Quadrado() { 4 | echo Função $FUNCNAME! 5 | echo -n "Informe um número -> " 6 | read x 7 | echo "$x² = $(( x**2 ))" 8 | } 9 | 10 | function Soma { 11 | (( x=$1+$2 )) 12 | echo "$1 + $2 = $x" 13 | } 14 | 15 | Quadrado 16 | soma=$(Soma 2 13) 17 | echo $soma -------------------------------------------------------------------------------- /Scripts/files_directories.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # encontra o número de arquivos ou diretórios 4 | # presentes em um determinado diretório. 5 | if [ -d "$@" ]; then 6 | echo "Arquivos encontrados: $(find "$@" -type f | wc -l)" 7 | echo "Diretórios encontrados: $(find "$@" -type d | wc -l)" 8 | else 9 | echo "Erro. Informe outro diretório." 10 | exit 1 11 | fi -------------------------------------------------------------------------------- /Scripts/mult_comments.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | : ' 4 | Script que calcula 5 | recursivamente 6 | o enésimo número 7 | da série Fibonacci 8 | 9 | O número deve ser 10 | passado via parâmetro 11 | 12 | Input / Output 13 | 1 -> 1 14 | 2 -> 1 15 | 3 -> 2 16 | 4 -> 3 17 | 5 -> 5 18 | 6 -> 8 19 | 20 -> 6.765 20 | ' 21 | echo $1 | awk 'function fib(n) { 22 | return n<2 ? n : fib(n-1) + fib(n-2) 23 | } {printf ("%'"'"'d\n", fib($1))}' -------------------------------------------------------------------------------- /Arquivos/livros.csv: -------------------------------------------------------------------------------- 1 | Title,Author,Genre,Height,Publisher 2 | History of Western Philosophy,"Russell, Bertrand",philosophy,213,Routledge 3 | "Theory of Everything, The","Hawking, Stephen",science,217,Jaico 4 | Data Structures Using C & C++,"Tanenbaum, Andrew",computer_science,235,Prentice Hall 5 | Tales of Mystery and Imagination,"Poe, Edgar Allen",fiction,172,HarperCollins 6 | Introduction to Algorithms,"Cormen, Thomas",computer_science,234,MIT Press -------------------------------------------------------------------------------- /Scripts/AWK/script.awk: -------------------------------------------------------------------------------- 1 | BEGIN { 2 | 3 | Titulo="Os Cavaleiros do Zodíaco" 4 | 5 | Coluna1="Nome" 6 | Coluna2="Signo" 7 | Coluna3="Energia" 8 | 9 | printf "%s\n", Titulo 10 | print "-----------------------------------" 11 | printf "%-13s %-13s %s\n", Coluna1, Coluna2, Coluna3 12 | 13 | } 14 | 15 | { printf "%-13s %-13s %6s\n", $1,$2,$3 | "sort -k3" } 16 | 17 | END { 18 | 19 | print "-----------------------------------" 20 | print "Total de cavaleiros:", NR 21 | 22 | } -------------------------------------------------------------------------------- /Scripts/hello.sh: -------------------------------------------------------------------------------- 1 | echo "Hello World" 2 | 3 | nome="Gabriel" 4 | x=50 5 | y=30 6 | 7 | echo "Olá $nome" 8 | echo $(($x + $y)) 9 | echo $(($x - $y)) 10 | echo $(($x / $y)) 11 | echo $(($x % $y)) 12 | echo $(($x * $y)) 13 | 14 | for((i = 0; i <= 20; i++)); do 15 | echo $i 16 | done 17 | 18 | for i in {5..50..5}; do 19 | echo "-> $i" 20 | done 21 | 22 | echo $(($RANDOM/1000)) 23 | 24 | if [[ -z "$nome" ]]; then 25 | echo "String is empty" 26 | elif [[ -n "$nome" ]]; then 27 | echo "String is not empty" 28 | else 29 | echo "This never happens" 30 | fi -------------------------------------------------------------------------------- /Scripts/path.sh: -------------------------------------------------------------------------------- 1 | STR="/arquivos/teste/main.cpp" 2 | echo ${STR%.cpp} # /arquivos/teste/main 3 | echo ${STR%.cpp}.o # /arquivos/teste/main.o 4 | echo ${STR%/*} # /arquivos/teste 5 | 6 | echo ${STR##*.} # cpp (extensão) 7 | echo ${STR##*/} # main.cpp (basepath) 8 | 9 | echo ${STR#*/} # arquivos/teste/main.cpp 10 | echo ${STR##*/} # main.cpp 11 | 12 | echo ${STR/main/tests} # /arquivos/teste/tests.cpp 13 | 14 | SRC="/arquivos/teste/main.cpp" # /arquivos/teste/main.cpp 15 | BASE=${SRC##*/} # main.cpp (basepath) 16 | DIR=${SRC%$BASE} # /arquivos/teste/ (dirpath) 17 | 18 | echo $SRC $BASE $DIR -------------------------------------------------------------------------------- /Scripts/arrays.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Definindo o array de arquivos 4 | arquivos=( "/etc/passwd" "/etc/group" "/etc/hosts" ) 5 | 6 | # Extraindo o tamanho do array 7 | tamanho_array=${#arquivos[@]} 8 | 9 | # Extraindo cada elemento do array 10 | elemento1=${arquivos[0]} 11 | elemento2=${arquivos[1]} 12 | elemento3=${arquivos[2]} 13 | 14 | # Imprimindo elementos individualmente 15 | echo $elemento1, $elemento2, $elemento3 16 | 17 | # Percorrendo todos os elementos com for 18 | for i in "${arquivos[@]}" 19 | do 20 | echo $i 21 | done 22 | 23 | # Percorrendo todos os elementos com for 24 | for (( i=0; i<$tamanho_array; i++)) 25 | do 26 | echo ${arquivos[${i}]} 27 | done -------------------------------------------------------------------------------- /Arquivos/tuplas.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import timeit 3 | 4 | # Exemplo de Lista 5 | numeros_primos = [2, 3, 5, 7, 11, 13, 17] 6 | 7 | # Exemplo de Tupla 8 | quadrados_perfeitos = (1, 4, 9, 16, 25, 36) 9 | 10 | # Mostrar os tamanhos 11 | print(f'# Primos: {len(numeros_primos)}') 12 | print(f'# Quadrados Perfeitos: {len(quadrados_perfeitos)}') 13 | 14 | # Iterar sob as sequencias 15 | for p in numeros_primos: 16 | print(f'Primos: {p}') 17 | 18 | for n in quadrados_perfeitos: 19 | print(f'Primos: {n}') 20 | 21 | # Métodos 22 | print('Métodos Lista') 23 | print(dir(numeros_primos)) 24 | print(80*"-") 25 | print('Métodos Tupla') 26 | print(dir(quadrados_perfeitos)) 27 | print(80*"-") 28 | 29 | ##### 30 | 31 | print(dir(sys)) 32 | print(help(sys.getsizeof)) 33 | 34 | lista_ex = [1, 2, 3, 'a', 'b', 'c', True, 3.14159] 35 | tupla_ex = (1, 2, 3, 'a', 'b', 'c', True, 3.14159) 36 | 37 | print(f'Tamanho da lista = {sys.getsizeof(lista_ex)}') 38 | print(f'Tamanho da tupla = {sys.getsizeof(tupla_ex)}') 39 | 40 | # Listas é possível adicionar, remover e mudar dados 41 | # Tuplas são imutáveis 42 | 43 | list_test = timeit.timeit(stmt='[1,2,3,4,5]', number=1_000_000) 44 | tuple_test = timeit.timeit(stmt='(1,2,3,4,5)', number=1_000_000) 45 | 46 | print(f'Tempo da lista: {list_test}') 47 | print(f'Tempo da tupla: {tuple_test}') 48 | 49 | #### 50 | 51 | tupla_vazia = () 52 | t1 = ('a',) 53 | t2 = ('a', 'b') 54 | t3 = ('a', 'b', 'c') 55 | 56 | print(tupla_vazia) 57 | print(t1,t2,t3) 58 | 59 | test1 = 1, 60 | test2 = 1, 2 61 | test3 = 1,2,3 62 | 63 | print(type(test1), type(test2), test3) 64 | -------------------------------------------------------------------------------- /Conteúdo/Referências.md: -------------------------------------------------------------------------------- 1 | # Referências 2 | 3 | - [TecMint](https://www.tecmint.com/) 4 | - [How-To Geek](https://www.howtogeek.com/) 5 | - [Linux Techi](https://www.linuxtechi.com/) 6 | - [LinuxCommand](http://www.linuxcommand.org/index.php) 7 | - [Linux Journey](https://linuxjourney.com/) 8 | - [GeeksforGeeks](https://www.geeksforgeeks.org/) 9 | - [The Unix Shell](https://swcarpentry.github.io/shell-novice/reference/) 10 | - [Linux Commands](https://i.pinimg.com/originals/dd/ea/4a/ddea4a4f7a593abcd4bb228b92b0a298.png) 11 | - [Wikipedia Linux](https://en.wikipedia.org/wiki/Linux) 12 | - [Bash Cheat Sheet](https://gist.github.com/LeCoupa/122b12050f5fb267e75f) 13 | - [Bash (Unix Shell)](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) 14 | - [Basic Unix Commands](http://mally.stanford.edu/~sr/computing/basic-unix.html) 15 | - [Bash Shell Reference](https://courses.cs.washington.edu/courses/cse390a/14au/bash.html) 16 | - [Bash Reference Manual](https://www.gnu.org/savannah-checkouts/gnu/bash/manual/bash.html) 17 | - [Important Linux Commands](https://www-uxsup.csx.cam.ac.uk/pub/doc/suse/suse9.0/userguide-9.0/ch24s04.html) 18 | - [Practical Linux Tutorial](http://xahlee.info/linux/linux_index.html) 19 | - [Unix / Linux Cheat Sheet](http://cheatsheetworld.com/programming/unix-linux-cheat-sheet/) 20 | - [HaWo's Linux Introduction](https://www.macs.hw.ac.uk/~hwloidl/Courses/LinuxIntro/t1.html) 21 | - [An A-Z Index of the Linux command line](https://ss64.com/bash/) 22 | - [Introduction to the Unix Shell (Bash)](https://pabloinsente.github.io/intro-unix-shell) 23 | - [101 Bash Commands and Tips for Beginners to Experts](https://dev.to/awwsmm/101-bash-commands-and-tips-for-beginners-to-experts-30je) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

Comandos Bash

2 | 3 |

4 | Bash
5 |

6 | 7 | Explorando a **[command-line interface (CLI)](https://en.wikipedia.org/wiki/Command-line_interface)** com a linguagem de comandos **[GNU Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell))**. 8 | 9 | ## Conteúdo 10 | 11 | - [Introdução](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Introdu%C3%A7%C3%A3o.md) 12 | - [Diretórios & Arquivos](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Diret%C3%B3rios%26Arquivos.md) 13 | - [Manipulação de Textos e Buscas](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Manipula%C3%A7%C3%A3oTextos%26Buscas.md) 14 | - [Gerenciamento de Usuários](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Usu%C3%A1rios.md) 15 | - [Permissões de Arquivos](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Permiss%C3%B5es.md) 16 | - [Compressão de Arquivos](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Compress%C3%A3o.md) 17 | - [Informações do Sistema](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Informa%C3%A7%C3%B5es.md) 18 | - [Gerenciamento de Processos](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Processos.md) 19 | - [Instalando Softwares](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Softwares.md) 20 | - [GNU, Unix & Linux](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/GNUnixLinux.md) 21 | - [Networking](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Networking.md) 22 | - [Scripting](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Scripting.md) 23 | - [Atalhos](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Atalhos.md) 24 | - [Referências](https://github.com/the-akira/Comandos-Bash/blob/master/Conte%C3%BAdo/Refer%C3%AAncias.md) -------------------------------------------------------------------------------- /Conteúdo/Introdução.md: -------------------------------------------------------------------------------- 1 | # Introdução 2 | 3 | [Shell](https://en.wikipedia.org/wiki/Shell_(computing)) é um programa utilitário [Unix](https://en.wikipedia.org/wiki/Unix). Possui uma identidade dupla: como uma interface do usuário para os utilitários Unix e como uma linguagem de programação, facilitando o uso e a combinação dos utilitários Unix. 4 | 5 | Quando você abre o terminal, o programa shell é carregado na memória do computador. Quando você digita comandos no terminal, o shell lê os comandos e os converte em um formato legível pelo kernel a ser executado. Ele fornece uma instância interativa para iniciar programas, gerenciar arquivos e processos em execução no computador. 6 | 7 | Como o shell é apenas um programa, muitas variações foram criadas desde 1969, quando [Ken Thompson](https://en.wikipedia.org/wiki/Ken_Thompson) desenvolveu a primeira implementação do Unix no Bell Labs. O shell Unix original foi escrito por [Steve Bourne](https://en.wikipedia.org/wiki/Stephen_R._Bourne) em 1970 e é conhecido como Bourne shell ou sh. 8 | 9 | O Bourne shell não estava disponível gratuitamente na época, o que limitava seu uso por outros programadores. Para aliviar esse problema, em 1988, a Free Software Foundation encarregou [Brian Fox](https://en.wikipedia.org/wiki/Brian_Fox_(computer_programmer)) de desenvolver uma reimplementação de código aberto do Bourne shell, o chamado [Bourne again shell](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) ou **bash**. Hoje, o bash shell é provavelmente a implementação de uso mais amplo do shell Unix. 10 | 11 | O Bash é um processador de comandos que normalmente é executado em uma janela de texto em que o usuário digita comandos que causam ações. O Bash também pode ler e executar comandos de um arquivo, chamado de shell script. Como todos os shells do Unix, ele suporta *filename [globbing](https://en.wikipedia.org/wiki/Glob_(programming))* (wildcard matching), *[piping](https://en.wikipedia.org/wiki/Pipeline_(Unix))*, *[here documents](https://en.wikipedia.org/wiki/Here_document)*, *[command substitution](https://en.wikipedia.org/wiki/Command_substitution)*, *[variáveis](https://en.wikipedia.org/wiki/Variable_(programming))*, e *[estruturas de controle](https://en.wikipedia.org/wiki/Control_flow)* para *[condition-testing](https://en.wikipedia.org/wiki/Conditional_(programming))* e *[iteration](https://en.wikipedia.org/wiki/Iteration)*. 12 | 13 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/shell.png) 14 | 15 | ## Comandos Básicos 16 | 17 | Iniciaremos abrindo o terminal para assim podermos executar os nossos primeiros comandos, vamos utilizar o comando `CTRL + ALT + T` para inicializá-lo. 18 | 19 | ### Imprimindo Hello World 20 | 21 | O comando **echo** no linux é usado para exibir o **texto**/**string** que é passada como argumento. 22 | 23 | ```bash 24 | echo "Hello World" 25 | ``` 26 | 27 | ### Imprimindo Variáveis de Ambiente 28 | 29 | ```bash 30 | echo $HOME # Diretório Home do usuário atual 31 | 32 | echo $PWD # Imprime o diretório de trabalho atual 33 | 34 | echo $TERM # Terminal sendo utilizado 35 | 36 | echo $USER # Usuário atual do sistema 37 | 38 | echo $SHELL # Shell sendo utilizada 39 | 40 | echo $HOSTNAME # O nome do host do computador no momento. 41 | 42 | echo $LANG # Linguagem atual em uso 43 | 44 | echo $COLUMNS # O número de colunas que estão sendo usadas para desenhar a saída na tela. 45 | 46 | echo $BASH_VERSION # Versão do Bash 47 | 48 | echo $BASHOPTS 49 | # A lista de opções usadas quando o bash foi executado. 50 | # Isso pode ser útil para descobrir se o ambiente do shell funcionará da maneira que você deseja. 51 | 52 | echo $PATH 53 | # Uma lista de diretórios que o sistema verificará ao procurar comandos. 54 | # Quando um usuário digita um comando, o sistema verifica os diretórios nesta ordem quanto ao executável. 55 | ``` 56 | 57 | ### Histórico de Comandos Digitados 58 | 59 | O comando **history** exibe ou manipula a lista do histórico de comandos. 60 | 61 | ```bash 62 | history 63 | ``` 64 | 65 | ### Limpando a Tela 66 | 67 | O comando **clear** ou `CTRL + L` limpa a tela do terminal. 68 | 69 | ```bash 70 | clear 71 | CTRL + L 72 | ``` 73 | 74 | ### Fechando a Shell 75 | 76 | O comando **exit** ou `CTRL + D` nos permite fechar o terminal. 77 | 78 | ```bash 79 | exit 80 | CTRL + D 81 | ``` 82 | 83 | ### Utilizando o Manual 84 | 85 | O comando **man** é uma interface para os manuais de referência online. 86 | 87 | ```bash 88 | man python 89 | man libc 90 | man cat 91 | ``` 92 | 93 | ### Obtendo Ajuda 94 | 95 | Muitos programas executáveis suportam uma opção **"--help"** que exibe uma descrição da sintaxe e das opções suportadas pelo comando. 96 | 97 | ```bash 98 | php --help 99 | chmod --help 100 | ls --help 101 | ``` 102 | 103 | ### Verificando Versões 104 | 105 | Muitos programas suportam uma opção **"--version"** que exibe a versão atual do programa que estamos utilizando. 106 | 107 | ```bash 108 | bash --version 109 | python --version 110 | ``` -------------------------------------------------------------------------------- /Conteúdo/Atalhos.md: -------------------------------------------------------------------------------- 1 | # Atalhos 2 | 3 | Na tabela a seguir temos os atalhos mais comuns do **Bash** 4 | 5 | | Atalho | Descrição | 6 | |---|---| 7 | | CTRL + A | move para o início da linha | 8 | | CTRL + B | retrocede um caracter | 9 | | CTRL + C | interrompe o comando atual | 10 | | CTRL + D | exclui um caractere para trás ou sai da sessão atual, semelhante ao exit | 11 | | CTRL + E | move para o final da linha | 12 | | CTRL + F | avança um caractere | 13 | | CTRL + G | interrompe o comando de edição atual e toca a campainha do terminal | 14 | | CTRL + J | mesmo que RETURN | 15 | | CTRL + K | exclui(elimina) para a frente até o final da linha | 16 | | CTRL + L | limpa a tela e reexibe a linha | 17 | | CTRL + M | mesmo que RETURN | 18 | | CTRL + N | próxima linha no histórico de comandos | 19 | | CTRL + O | igual a RETURN, em seguida, exibe a próxima linha no arquivo de histórico | 20 | | CTRL + P | linha anterior no histórico de comandos | 21 | | CTRL + R | pesquisas para trás | 22 | | CTRL + S | pesquisas para a frente | 23 | | CTRL + T | transpõe dois caracteres | 24 | | CTRL + U | elimina para trás do ponto até o início da linha | 25 | | CTRL + V | torna o próximo caractere digitado literalmente | 26 | | CTRL + W | elimina a palavra atrás do cursor | 27 | | CTRL + X | lista a possível conclusão de nome de arquivo da palavra atual | 28 | | CTRL + Y | recupera (cola) o último item eliminado | 29 | | CTRL + Z | interrompe o comando atual, retoma com fg em primeiro plano ou bg em segundo plano | 30 | | DELETE | exclui um caracter para trás | 31 | | !! | repete o último comando | 32 | | exit | sai da sessão atual | 33 | 34 | ## alias 35 | 36 | Os usuários do Linux geralmente precisam usar alguns comandos repetidamente. 37 | 38 | Podemos economizar algum tempo criando **aliases** para os comandos mais usados. Aliases são como atalhos personalizados usados para representar um comando (ou conjunto de comandos) executado com ou sem opções personalizadas. 39 | 40 | Para vermos uma lista de aliases definidos em nosso perfil simplesmente executamos o comando alias: 41 | 42 | ```bash 43 | alias 44 | ``` 45 | 46 | Nos serão apresentados os aliases deste usuário definidos em nossos sistema. 47 | 48 | ``` 49 | alias egrep='egrep --color=auto' 50 | alias fgrep='fgrep --color=auto' 51 | alias grep='grep --color=auto' 52 | alias l='ls -CF' 53 | alias la='ls -A' 54 | alias ll='ls -alF' 55 | alias ls='ls --color=auto' 56 | alias ports='netstat -tulanp' 57 | ``` 58 | 59 | Podemos observar por exemplo que o alias `ll` é equivalente ao comando `ls -alF`. 60 | 61 | ### Criando Aliases 62 | 63 | A criação de aliases é um processo relativamente fácil e rápido. Podemos criar dois tipos de aliases: **temporários** e **permanentes**. 64 | 65 | #### Temporário 66 | 67 | Para criarmos um **alias** temporário precisamos digitar a palavra **alias** e usar o nome que desejamos usar para executar um comando seguido do sinal `=` e citar o comando que queremos criar. 68 | 69 | Devemos então usar a seguinte sintaxe para definir um alias: 70 | 71 | ```bash 72 | alias atalho="comando customizado a ser executado" 73 | ``` 74 | 75 | Exemplo prático: 76 | 77 | ```bash 78 | alias wr=”cd /var/www/html” 79 | ``` 80 | 81 | Agora podemos usar o atalho **wr** que definimos para ir para o diretório webroot. O problema com esse alias é que ele estará disponível apenas para sua sessão de terminal atual, ele é temporário. 82 | 83 | Se abrirmos uma nova sessão de terminal, o alias não estará mais disponível. Se desejarmos salvar os aliases entre as sessões, precisaremos de um alias permanente. 84 | 85 | #### Permanente 86 | 87 | Para manter os aliases entre as sessões, podemos salvá-los no arquivo de perfil de configuração do shell do usuário, que pode ser: 88 | 89 | - Bash: `~/.bashrc` 90 | - ZSH: `~/.zshrc` 91 | - Fish: `~/.config/fish/config.fish` 92 | 93 | Existe também o arquivo `~/.bash_profile`, ele é carregado quando você faz o login. É lido apenas uma vez. 94 | 95 | A sintaxe que usamos é praticamente a mesma que a de criar um alias temporário. A única diferença vem do fato que estaremos salvando em um arquivo desta vez. Por exemplo, no bash, podemos abrir o arquivo `.bashrc` desta forma: 96 | 97 | ```bash 98 | # Com nano 99 | nano ~/.bashrc 100 | # Com vim 101 | vim ~/.bashrc 102 | ``` 103 | 104 | o arquivo `~/.bashrc` é carregado toda vez que você inicia um shell (por exemplo, iniciando um terminal), mas não é carregado quando você faz o login pela primeira vez. 105 | 106 | Encontramos um local no arquivo `~/.bashrc` onde queremos manter os aliases. Por exemplo, podemos adicioná-los no final do arquivo. Para fins de organização, podemos deixar um comentário antes dos aliases para identificá-los. 107 | 108 | ```bash 109 | # Custom Aliases 110 | alias rm="rm -vi" 111 | alias ll="ls -alFh" 112 | ``` 113 | 114 | Salvamos o arquivo. O arquivo será carregado automaticamente em nossa próxima sessão. Se quisermos usar o alias recém-definido na sessão atual, usamos o seguinte comando: 115 | 116 | ```bash 117 | source ~/.bashrc 118 | ``` 119 | 120 | Para remover um alias adicionado por meio da linha de comando podemos usar o comando **unalias**. 121 | 122 | ```bash 123 | unalias ll 124 | ``` -------------------------------------------------------------------------------- /Conteúdo/Compressão.md: -------------------------------------------------------------------------------- 1 | # Compressão e Arquivamento de Arquivos 2 | 3 | Às vezes é útil armazenar um grupo de arquivos em um arquivo para que eles possam ser copiados, facilmente transferidos para outro diretório ou mesmo transferidos para outro computador. Às vezes, também é útil compactar arquivos em um arquivo para que eles usem menos espaço em disco e baixem mais rapidamente. 4 | 5 | É importante entender a diferença e o relacionamento entre um **arquivo arquivado** e um **arquivo compactado**. 6 | 7 | Um arquivo arquivado é uma coleção de arquivos e diretórios armazenados em um arquivo. O arquivo arquivado não está compactado - ele usa a mesma quantidade de espaço em disco que todos os arquivos e diretórios individuais combinados. 8 | 9 | Um arquivo compactado é uma coleção de arquivos e diretórios armazenados em um arquivo e armazenados de uma maneira que utiliza menos espaço em disco do que todos os arquivos e diretórios individuais combinados. Se você não tiver espaço em disco suficiente no computador, poderá compactar os arquivos que não utiliza com muita frequência ou os arquivos que deseja salvar, mas não usa mais. Você pode até criar um arquivo e compactá-lo para economizar espaço em disco. 10 | 11 | **Importante**: Um arquivo arquivado não é compactado, mas um arquivo compactado pode ser um arquivo arquivado. 12 | 13 | ## Compactando Arquivos 14 | 15 | Os arquivos compactados usam menos espaço em disco e baixam mais rápido que os arquivos grandes e não compactados. No Linux podemos compactar arquivos com as ferramentas de compactação **gzip**, **bzip2** ou **zip**. 16 | 17 | A ferramenta de compactação **bzip2** é muito recomendada porque fornece a maior compactação e é encontrada na maioria dos sistemas operacionais do tipo Unix. A ferramenta de compactação **gzip** também pode ser encontrada na maioria dos sistemas operacionais semelhantes ao Unix. Se você precisar transferir arquivos entre o Linux e outro sistema operacional, como o Microsoft Windows, use o **zip**, pois é mais comum nesses outros sistemas operacionais. 18 | 19 | A tabela a seguir apresenta informações sobre as ferramentas de compactação/compressão 20 | 21 | | Ferramenta para Compactar | Extensão do Arquivo | Ferramenta para Descompactar | 22 | |---|---|---| 23 | | gzip | .gz | gunzip | 24 | | bzip2 | .bz2 | bunzip2 | 25 | | zip | .zip | unzip | 26 | 27 | Por convenção, os arquivos compactados com **gzip** recebem a extensão `.gz`, os arquivos compactados com **bzip2** recebem a extensão `.bz2` e os arquivos compactados com **zip** recebem a extensão `.zip`. 28 | 29 | Arquivos compactados com **gzip** são descompactados com **gunzip**, arquivos compactados com **bzip2** são descompactados com **bunzip2** e arquivos compactados com **zip** são descompactados com **unzip**. 30 | 31 | ## Comandos 32 | 33 | ### Bzip2 & Bunzip2 34 | 35 | Para utilizar o **bzip2** para compactar um arquivo, digite o seguinte comando em um prompt de shell: 36 | 37 | ```bash 38 | bzip2 arquivo 39 | ``` 40 | 41 | O arquivo será compactado e salvo como `arquivo.bz2`. 42 | 43 | Para expandir o arquivo compactado, digite o seguinte comando: 44 | 45 | ```bash 46 | bunzip2 arquivo.bz2 47 | ``` 48 | 49 | Observe que o `arquivo.bz2` é deletado e substituído por `arquivo`. 50 | 51 | Você pode usar o **bzip2** em vários arquivos ao mesmo tempo, listando-os com um espaço entre cada um: 52 | 53 | ```bash 54 | bzip2 texto.txt script.py index.php 55 | ``` 56 | 57 | O comando acima irá comprimir os arquivos: `texto.txt`, `script.py` e `index.php`. 58 | 59 | Para mais informações você pode utilizar o comando `man bzip2` ou a opção de ajuda `bunzip2 --help` 60 | 61 | ### Gzip & Gunzip 62 | 63 | Para usar o **gzip** para compactar um arquivo, digite o seguinte comando no prompt do shell: 64 | 65 | ```bash 66 | gzip arquivo 67 | ``` 68 | 69 | O arquivo será compactado e salvo como `arquivo.gz`. 70 | 71 | Para expandir o arquivo compactado, digite o seguinte comando: 72 | 73 | ```bash 74 | gunzip arquivo.gz 75 | ``` 76 | 77 | `arquivo.gz` é então deletado e substituído por `arquivo`. 78 | 79 | Você pode usar o **gzip** em vários arquivos ao mesmo tempo, listando-os com um espaço entre cada um: 80 | 81 | ```bash 82 | gzip texto.txt script.py index.php 83 | ``` 84 | 85 | O comando acima irá comprimir os arquivos: `texto.txt`, `script.py` e `index.php`. 86 | 87 | ### Zip & Unzip 88 | 89 | Para compactar um arquivo com **zip**, usamos o seguinte comando: 90 | 91 | ```bash 92 | zip -r arquivo.zip diretorio 93 | ``` 94 | 95 | Neste exemplo, `arquivo.zip` representa o arquivo que você está criando e `diretorio` representa o diretório que você deseja colocar no novo arquivo zip. A opção -r especifica que você deseja incluir todos os arquivos contidos no diretório `diretorio` recursivamente. 96 | 97 | Para extrair o conteúdo de um arquivo **zip**, digite o seguinte comando: 98 | 99 | ```bash 100 | unzip arquivo.zip 101 | ``` 102 | 103 | É possível compactar vários arquivos e diretórios ao mesmo tempo, listando-os com um espaço entre cada um: 104 | 105 | ```bash 106 | zip -r arquivo.zip readme.md texto.txt script.py /usr/documentos/scripts 107 | ``` 108 | 109 | O comando acima irá comprimir os arquivos `readme.md`, `texto.txt` e `script.py` e os conteúdos do diretório `/usr/documentos/scripts` e os colocará em `arquivo.zip`. 110 | 111 | ### Arquivamento de Arquivos 112 |   113 | Um arquivo **tar** é uma coleção de vários arquivos e/ou diretórios em um arquivo. Essa é uma boa maneira de criar backups e arquivamentos. 114 | 115 | Algumas das opções disponíveis para usarmos com **tar** são: 116 | 117 | - `-c`: cria um novo arquivamento 118 | - `-f`: quando utilizado com a opção **-c** utiliza o nome de arquivo especificado para a criação do arquivo tar. quando usado com a opção **-x** desarquiva o arquivo especificado. 119 | - `-t`: mostra a lista de arquivos no arquivo **tar** 120 | - `-v`: mostra o progresso dos arquivos sendo arquivados 121 | - `-x`: faz a extração dos arquivos de um arquivamento 122 | - `-z`: faz a compressão do arquivo **tar** com **gzip** 123 | - `-j`: faz a compressão do arquivo **tar** com **bzip2** 124 | 125 | Vejamos então alguns exemplos, para criar um arquivo **tar**: 126 | 127 | ```bash 128 | tar -cvf arquivos.tar Diretorio 129 | ``` 130 | 131 | Neste exemplo, `arquivos.tar` representa o arquivo que você está criando e `Diretorio` representa os arquivos ou diretórios que você deseja colocar no arquivo arquivado. 132 | 133 | Podemos utilizar **tar** em vários arquivos e diretórios ao mesmo tempo, listando-os com um espaço entre cada um: 134 | 135 | ```bash 136 | tar -cvf arquivos.tar Arquivos readme.md texto.txt 137 | ``` 138 | 139 | O comando acima irá colocar todos os arquivos do diretório `Arquivos` e os arquivos `readme.md` e `texto.txt` em um novo arquivo chamado de `arquivos.tar` no diretório atual. 140 | 141 | Para listar o conteúdo de um arquivo tar, digite o comando: 142 | 143 | ```bash 144 | tar -tvf arquivos.tar 145 | ``` 146 | 147 | Para extrair o conteúdo de um arquivo **tar**, digite: 148 | 149 | ```bash 150 | tar -xvf arquivos.tar 151 | ``` 152 | 153 | Este comando não remove o arquivo **tar**, mas coloca cópias de seu conteúdo no *diretório de trabalho atual*. 154 | 155 | É importante lembrarmos que o comando tar não compacta os arquivos por padrão. Para criar um arquivo compactado com tar e bzip, use a opção **-j**: 156 | 157 | ```bash 158 | tar -cjvf arquivo.tbz readme.md texto.txt Arquivos 159 | ``` 160 | 161 | Os arquivos **tar** compactados com o **bzip2** recebem convencionalmente a extensão `.tbz`. 162 | 163 | Este último comando irá criar um arquivo arquivado e então irá comprimí-lo como `arquivo.tbz`. Se você descompactar o arquivo `arquivo.tbz` com o comando **bunzip2**, o arquivo `arquivo.tbz` será removido e substituído por `arquivo.tar`. 164 | 165 | Você também pode expandir e desarquivar um arquivo tar **bzip** em um único comando: 166 | 167 | ```bash 168 | tar -xjvf arquivo.tbz 169 | ``` 170 | 171 | Para criar um arquivo compactado com **tar** e **gunzip**, utilizamos a opção **-z**: 172 | 173 | ```bash 174 | tar -czvf arquivos.tgz readme.md Arquivos/ 175 | ``` 176 | 177 | Os arquivos **tar** compactados com o **gzip** recebem convencionalmente a extensão `.tgz`. 178 | 179 | Este comando cria o arquivo `arquivos.tar` e, em seguida, o compacta como o arquivo `arquivos.tgz`. (O arquivo filename.tar não será salvo) Se você descompactar o arquivo `arquivo.tgz` com o comando gunzip, o arquivo `arquivo.tgz` será removido e substituído por `arquivo.tar`. 180 | 181 | Também podemos expandir um arquivo tar/gzip em apenas um comando: 182 | 183 | ```bash 184 | tar -xzvf arquivos.tgz 185 | ``` -------------------------------------------------------------------------------- /Conteúdo/Softwares.md: -------------------------------------------------------------------------------- 1 | # Instalando Softwares 2 | 3 | ## Distribuição de Software 4 | 5 | Um sistema é composto de muitos pacotes, como navegadores de internet, editores de texto, reprodutores de mídia, etc. Esses pacotes são gerenciados por gerenciadores de pacotes, que instalam e mantêm o software em seu sistema. No entanto, nem todos os pacotes são instalados através de gerenciadores de pacotes, é possível normalmente instalar pacotes diretamente de seu código-fonte. No entanto, na maioria das vezes usaremos um gerenciador de pacotes para instalar software, a variedade mais comum de pacotes são **Debian** (.deb) e **Red Hat** (.rpm). Os pacotes de estilo Debian são usados em distribuições como Debian, Ubuntu, Linux Mint, etc. Os pacotes de estilo Red Hat são vistos no Red Hat Enterprise Linux, como Fedora, CentOS, etc. 6 | 7 | O que são pacotes? Conhecemos normalmente eles como Chrome, Photoshop, etc, mas o que eles realmente são é apenas muitos e muitos arquivos que foram compilados em um. 8 | 9 | ## Repositórios de Pacotes 10 | 11 | Como os pacotes que são enviados para a Internet de alguma forma acabam em nossos computadores? Você vai para a página de download de cada pacote que deseja e clica em baixar e instalar? Na verdade é possível fazer isso, mas existe algo melhor chamado de repositórios de pacotes. Repositórios são apenas um local de armazenamento central para pacotes. Existem diversos repositórios que contêm muitos pacotes e o melhor de tudo eles são encontrados na Internet, sem necessidade de discos de instalação. 12 | 13 | Nossa distribuição já vem com fontes pré-aprovadas para obter pacotes e é assim que ela instala todos os pacotes básicos que você vê em seu sistema. Em um sistema Debian, este arquivo de fontes é o arquivo `/etc/apt/sources.list`. Sua máquina saberá olhar lá e verificar se há repositórios de origem que você adicionou. 14 | 15 | ## Dependências de Pacote 16 | 17 | Os pacotes raramente funcionam sozinhos; na maioria das vezes, são acompanhados por dependências para ajudá-los a funcionar. 18 | 19 | No Linux, essas dependências geralmente são outros pacotes ou bibliotecas compartilhadas. Bibliotecas compartilhadas são bibliotecas de código que outros programas desejam usar e não precisam reescrever por conta própria. 20 | 21 | ## rpm & dpkg 22 | 23 | Assim como `.exe` é um único arquivo executável, `.deb` e `.rpm` também são. Normalmente não os veremos se usarmos repositórios de pacotes, mas se baixarmos pacotes diretamente, provavelmente os obteremos neste formato popular. Obviamente, eles são exclusivos de suas distribuições, `.deb` para baseadas em Debian e `.rpm` para baseadas em Red Hat. 24 | 25 | Para instalar esses pacotes diretos, podemos usar os comandos de gerenciamento de pacotes: **rpm** e **dpkg**. Essas ferramentas são usadas para instalar arquivos de pacote, no entanto, não irão instalar as dependências do pacote, então se o pacote tivesse 10 dependências, teríamos que instalar esses pacotes separadamente e então as dependências e assim por diante. 26 | 27 | ### Instalando um Pacote 28 | 29 | #### Debian 30 | 31 | ```bash 32 | dpkg -i pacote.deb 33 | ``` 34 | 35 | #### RPM 36 | 37 | ```bash 38 | rpm -i pacote.rpm 39 | ``` 40 | 41 | O opção **-i** significa instalar. É possível também pode usar o formato mais longo **--install**. 42 | 43 | ### Removendo um Pacote 44 | 45 | #### Debian 46 | 47 | ```bash 48 | dpkg -r pacote.deb 49 | ``` 50 | 51 | A opção **-r** significa *remove* 52 | 53 | #### RPM 54 | 55 | ```bash 56 | rpm -e pacote.rpm 57 | ``` 58 | 59 | A opção **-e** significa *erase* 60 | 61 | ### Listando os Pacotes Instalados 62 | 63 | #### Debian 64 | 65 | ```bash 66 | dpkg -l 67 | ``` 68 | 69 | A opção **-l** significa *list* 70 | 71 | #### RPM 72 | 73 | ```bash 74 | rpm -qa 75 | ``` 76 | 77 | A opção **-q** significa *query e **a** quer dizer *all* 78 | 79 | ## yum & apt 80 | 81 | Os sistemas possuem consigo todas as correções para facilitar a instalação, remoção e mudanças de pacotes, incluindo a instalação de dependências de pacotes. Dois dos sistemas de gerenciamento mais populares são o **yum** e o **apt**. Yum é exclusivo da família Red Hat e apt é exclusivo da família Debian. 82 | 83 | ### Instalando um Pacote de um Repositório 84 | 85 | #### Debian 86 | 87 | ```bash 88 | apt install pacote 89 | ``` 90 | 91 | #### RPM 92 | 93 | ```bash 94 | yum install pacote 95 | ``` 96 | 97 | ### Removendo um Pacote 98 | 99 | #### Debian 100 | 101 | ```bash 102 | apt remove pacote 103 | ``` 104 | 105 | #### RPM 106 | 107 | ```bash 108 | yum erase pacote 109 | ``` 110 | 111 | ### Atualizando Pacotes de um Repositório 112 | 113 | É sempre uma prática recomendada atualizar seus repositórios de pacotes para que eles estejam atualizados antes de instalar e atualizar um pacote. 114 | 115 | #### Debian 116 | 117 | ```bash 118 | apt update 119 | apt upgrade 120 | ``` 121 | 122 | #### RPM 123 | 124 | ```bash 125 | yum update 126 | ``` 127 | 128 | ### Obtendo Informação sobre um Pacote Instalado 129 | 130 | #### Debian 131 | 132 | ```bash 133 | apt show pacote 134 | ``` 135 | 136 | #### RPM 137 | 138 | ```bash 139 | yum info pacote 140 | ``` 141 | 142 | ## Compilando o Código-Fonte 143 | 144 | Freqüentemente podemos encontrar um pacote que só vem na forma de código-fonte puro. Para ele precisaremos usar alguns comandos para obter o pacote de código-fonte compilado e instalado em nosso sistema. 145 | 146 | O primeiro passo é instalar um software para instalar as ferramentas que permitirão compilar o código-fonte. 147 | 148 | ```bash 149 | sudo apt install build-essential 150 | ``` 151 | 152 | Depois de fazer isso, extraímos o conteúdo do arquivo do pacote, possivelmente será um arquivo `.tar.gz`. 153 | 154 | ```bash 155 | tar -xzvf package.tar.gz 156 | ``` 157 | 158 | Antes de fazer qualquer coisa, é importante sempre olharmos o arquivo **README** ou **INSTALL** dentro do pacote. Às vezes, haverá instruções de instalação específicas. 159 | 160 | Dentro do conteúdo do pacote estará um script de configuração, este script verifica as dependências em seu sistema e se estiver faltando alguma coisa, você verá um erro e precisará consertar essas dependências. 161 | 162 | ```bash 163 | ./configure 164 | ``` 165 | 166 | O `./` permite executarmos um script no diretório atual. 167 | 168 | Dentro do conteúdo do pacote, existe um arquivo chamado **Makefile** que contém regras para construir o software. Quando executamos o comando **make**, ele examina esse arquivo para construir o software. 169 | 170 | ```bash 171 | make 172 | ``` 173 | 174 | Este comando realmente instala o pacote, ele irá copiar os arquivos corretos para os locais corretos em seu computador: 175 | 176 | ```bash 177 | sudo make install 178 | ``` 179 | 180 | Se desejarmos desinstalar o pacote, podemos usar: 181 | 182 | ```bash 183 | sudo make uninstall 184 | ``` 185 | 186 | O comando **checkinstall** irá essencialmente fazer o "make install" e construir um pacote `.deb` e instalá-lo. Isso torna mais fácil remover o pacote posteriormente. 187 | 188 | ```bash 189 | sudo checkinstall 190 | ``` 191 | 192 | ## Instalando Aplicativos no Ubuntu usando PPA 193 | 194 | PPA - Personal Package Archive é outra maneira fácil de instalar software no Ubuntu Linux. Muitos desenvolvedores desejam oferecer a versão mais recente de seu software diretamente aos usuários finais. Nesse caso, o PPA pode ser usado como repositório de software oficial do Ubuntu. Muitos usuários do Ubuntu podem não esperar por tanto tempo, mas podem usar o PPA para instalar a versão mais recente instantaneamente. 195 | 196 | Exemplo da instalação do Cinnamon Desktop no Ubuntu Linux: 197 | 198 | ```bash 199 | sudo add-apt-repository ppa:embrosyn/cinnamon 200 | sudo apt update 201 | sudo apt install cinnamon 202 | ``` 203 | 204 | O primeiro comando é para adicionar o repositório PPA à lista de fontes do sistema, o segundo é para atualizar o cache da lista de software e o último é para instalar o software específico usando o comando apt. 205 | 206 | ## Instalando Aplicações Python via Pip 207 | 208 | Pip é outra maneira de instalar software, especialmente aplicativos baseados em Python, no Linux. Pip é na verdade um sistema de gerenciamento de software baseado em linha de comando para aplicativos que são escritos na linguagem de programação Python. É fácil de usar e, se você for um desenvolvedor de software, poderá usar o Pip para instalar e gerenciar vários pacotes e módulos Python para seus projetos Python. 209 | 210 | Para instalar o Pip executamos o comando abaixo para Python 2 e Python 3 respectivamente: 211 | 212 | ```bash 213 | sudo apt install python-pip 214 | sudo apt install python3-pip 215 | ``` 216 | 217 | Para pesquisar os pacotes, executamos o seguinte comando: 218 | 219 | ```bash 220 | pip search palavra 221 | ``` 222 | 223 | Para instalarmos uma aplicação usando o **pip**: 224 | 225 | ```bash 226 | pip install pacote 227 | ``` 228 | 229 | Para removermos um pacote instalado com **pip**: 230 | 231 | ```bash 232 | pip uninstall pacote 233 | ``` 234 | 235 | Para mais informações e ajuda podemos contar com o comando `pip3 --h`. -------------------------------------------------------------------------------- /Conteúdo/Permissões.md: -------------------------------------------------------------------------------- 1 | # Permissões 2 | 3 | Os sistemas operacionais do tipo Unix, como o Linux, diferem de outros sistemas de computação, pois além de serem multitarefas, são também multiusuários. 4 | 5 | Isso significa que mais de um usuário pode estar operando o computador ao mesmo tempo. Embora seu computador tenha apenas um teclado e monitor, ele ainda pode ser usado por mais de um usuário. Por exemplo, se o seu computador estiver conectado a uma rede ou à Internet, os usuários remotos poderão efetuar login via **ssh**(shell seguro) e operar o computador. De fato, os usuários remotos podem executar aplicativos gráficos e exibir o *output* em um computador remoto. 6 | 7 | A capacidade multiusuário de sistemas do tipo Unix é um recurso profundamente arraigado no design do sistema operacional. Anos atrás, antes dos computadores serem "pessoais", eles eram grandes, caros e centralizados. Um sistema de computador universitário tradicional consistia em um grande computador mainframe localizado em algum prédio do campus e os terminais estavam localizados em todo o campus, cada um conectado ao grande computador central. O computador suportava muitos usuários ao mesmo tempo. 8 | 9 | Para tornar o sistema prático, um método teve que ser desenvolvido para proteger os usuários uns dos outros. Afinal, você não podia permitir que as ações de um usuário travassem o computador, nem que um usuário interferisse nos arquivos pertencentes a outro usuário. 10 | 11 | ## Permissões de Arquivos 12 | 13 | Em um sistema Linux, cada arquivo e diretório recebe direitos de acesso para o **proprietário do arquivo**, **os membros de um grupo de usuários relacionados** e **todos os outros**. Direitos podem ser atribuídos para **ler um arquivo**, **escrever em um arquivo** e **executar um arquivo**(rodá-lo como se fosse um programa). 14 | 15 | Para visualizarmos as configurações de permissões para um arquivo podemos utilizar o comando **ls**. Utilizaremos como exemplo o programa **bash** que está localizado no diretório `/bin`: 16 | 17 | ```bash 18 | ls -l /bin/bash 19 | 20 | # Output: 21 | # -rwxr-xr-x 1 root root 1113504 jun 6 2019 /bin/bash 22 | ``` 23 | 24 | Podemos observar que: 25 | 26 | - O arquivo `/bin/bash` pertence ao usuário **root** 27 | - O superusuário tem o direito de ler, escrever e executar este arquivo 28 | - O arquivo pertence ao grupo **root** 29 | - Membros do grupo **root** também podem ler e executar esse arquivo 30 | - Todos os demais podem ler e executar este arquivo. 31 | 32 | Na imagem abaixo, nós podemos ver como as permissões são interpretadas. Basicamente ela consiste de um caracter indicando o tipo do arquivo (**d** para diretório, **-** para outros arquivos), seguido por **três conjuntos** de **três caracteres** que consistem das permissões de **ler**, **escrever** e **executar** um arquivo para o **owner**, **grupo** e **todos os demais**. 33 | 34 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/permissoes.png) 35 | 36 | Cada caracter representa então uma permissão diferente, por exemplo: 37 | 38 | - **r** = readable (possível de ler) 39 | - **w** = writable (possível de escrever) 40 | - **x** = executable (executável) 41 | - **-** = vazio 42 | 43 | ## Comandos 44 | 45 | ### chmod 46 | 47 | O comando chmod é usado para alterar as permissões de um arquivo ou diretório. Para usá-lo, você especifica as configurações de permissão desejadas e o arquivo ou arquivos que deseja modificar. Existem duas maneiras de especificar as permissões. 48 | 49 | Podemos imaginar as configurações de permissão como uma série de bits(que é exatamente como o computador os trata). 50 | 51 | Funciona da seguinte forma: 52 | 53 | ``` 54 | rwx rwx rwx = 111 111 111 55 | rw- rw- rw- = 110 110 110 56 | rwx --- --- = 111 000 000 57 | 58 | rwx = 111 = 7 59 | rw- = 110 = 6 60 | r-x = 101 = 5 61 | r-- = 100 = 4 62 | ``` 63 | 64 | Podemos então representar cada um dos **três conjuntos**(owner, grupo, e todos os demais) como um único dígito. 65 | 66 | Por exemplo, se quiséssemos definir *arquivo.txt* para ter permissão de leitura e gravação para o proprietário/owner, mas quiséssemos manter o arquivo privado de outros, poderíamos executar o seguinte comando: 67 | 68 | ```bash 69 | chmod 600 arquivo.txt 70 | ``` 71 | 72 | A tabela a seguir apresentar algumas configurações comuns. Os que começam com o número **7** são usados para programas, uma vez que eles habilitam a execução, e os demais são para outros tipos de arquivos. 73 | 74 | | Valor | Significado | 75 | |---|---| 76 | | 777 | (rwxrwxrwx) Não há restrições de permissões. Qualquer um pode fazer qualquer coisa. | 77 | | 755 | (rwxr-xr-x) O proprietário/owner do arquivo pode ler, escrever e executar o arquivo. Todos os outros podem ler e executar o arquivo. | 78 | | 700 | (rwx------) O proprietário do arquivo pode ler, escrever e executar o arquivo. Ninguém mais tem nenhum direito. | 79 | | 666 | (rw-rw-rw-) Todos os usuários podem ler e escrever o arquivo. | 80 | | 644 | (rw-r--r--) O proprietário pode ler e escrever um arquivo, enquanto todos os outros podem apenas ler o arquivo. | 81 | | 600 | (rw-------) O proprietário pode ler e escrever um arquivo. Todos os outros não têm direitos. | 82 | 83 | O comando **chmod** também pode ser usado para controlar as permissões de acesso para diretórios. Novamente, podemos usar a notação octal para definir permissões, mas o significado dos atributos **r**, **w** e **x** é diferente: 84 | 85 | - **r**: Permite que o conteúdo do diretório seja listado se o atributo **x** também estiver definido. 86 | - **w**: Permite que arquivos dentro do diretório sejam criados, excluídos ou renomeados se o atributo **x** também estiver definido. 87 | - **x**: Permite que um diretório seja acessado (por exemplo: `cd docs`) 88 | 89 | Configurações interessantes para diretórios: 90 | 91 | | Valor | Significado | 92 | |---|---| 93 | | 777 | (rwxrwxrwx) Não há restrições de permissões. Qualquer pessoa pode listar arquivos, criar novos arquivos no diretório e excluir arquivos no diretório. | 94 | | 755 | (rwxr-xr-x) O proprietário do diretório tem acesso total. Todos os outros podem listar o diretório, mas não podem criar arquivos nem excluí-los. | 95 | | 700 | (rwx------) O proprietário do diretório tem acesso total. Ninguém mais tem nenhum direito. | 96 | 97 | Há também uma outra maneira de alterar as permissões: 98 | 99 | Primeiro, escolhemos qual conjunto de permissões você deseja alterar, **usuário**, **grupo** ou **outro**. Podemos adicionar ou remover permissões com um **+** ou **-**, vejamos alguns exemplo: 100 | 101 | Alterando a permissão no `script.py` adicionando o bit de permissão executável ao conjunto de usuários. Então agora o usuário tem permissão de executar este arquivo: 102 | 103 | ```bash 104 | chmod u+x script.py 105 | ``` 106 | 107 | Caso queíramos remover a permissão: 108 | 109 | ```bash 110 | chmod u-x script.py 111 | ``` 112 | 113 | Também podemos adicionar múltiplas permissões em um arquivo: 114 | 115 | ```bash 116 | chmod ug+w script.py 117 | ``` 118 | 119 | Neste exemplo, habilitamos os bits de permissão de escrita para o **usuário** e **grupo**. 120 | 121 | Podemos também habilitar o bit de permissão de execução apenas para **os outros**: 122 | 123 | ```bash 124 | chmod o+x script.py 125 | ``` 126 | 127 | ### Permissões de Propriedade 128 | 129 | #### chown 130 | 131 | Além de modificar as permissões nos arquivos, podemos também modificar a propriedade do grupo e do usuário, ou seja, a quem pertence o arquivo. 132 | 133 | ##### Modificar a propriedade do usuário 134 | 135 | ```bash 136 | sudo chown akira arquivo.txt 137 | ``` 138 | 139 | Este comando irá setar **akira** como proprietário de `arquivo.txt` 140 | 141 | #### chgrp 142 | 143 | ##### Modificar propriedade do grupo 144 | 145 | ```bash 146 | sudo chgrp programadores script.js 147 | ``` 148 | 149 | Este comando irá setar o grupo de `script.js` para **programadores** 150 | 151 | ##### Modificar a propriedade do usuário e do grupo ao mesmo tempo 152 | 153 | Se adicionarmos dois pontos e nome de grupo após o usuário, podemos definir o usuário e o grupo ao mesmo tempo. 154 | 155 | ```bash 156 | sudo chown akira:programadores script.js 157 | ``` 158 | 159 | ### Tornando-se Superusuário 160 | 161 | Geralmente, é necessário se tornar o superusuário para executar tarefas importantes de administração do sistema. Na maioria das distribuições, existe um programa que pode fornecer acesso temporário aos privilégios do superusuário. Este programa é chamado **su**(abreviação de usuário substituto) e pode ser usado nesses casos em que você precisa ser o superusuário. Para se tornar o superusuário, basta digitar o comando su. Você será solicitado a senha do superusuário: 162 | 163 | ```bash 164 | su 165 | ``` 166 | 167 | Após executar o comando **su**, você terá uma nova sessão de shell como superusuário. Para sair da sessão de superusuário, digite `exit` ou `CTRL + D` e você retornará à sua sessão anterior. 168 | 169 | Em algumas distribuições é usado um método alternativo. Em vez de usar **su**, esses sistemas empregam o comando **sudo**. Com o sudo, um ou mais usuários recebem privilégios de superusuário conforme a necessidade. Para executar um comando como superusuário, o comando desejado é simplesmente precedido pelo comando sudo. Depois que o comando é inserido, o usuário solicita a senha do usuário, em vez da senha do superusuário: 170 | 171 | ```bash 172 | sudo script.py 173 | ``` 174 | 175 | ### umask 176 | 177 | Máscara de criação de arquivo do usuário. O comando **umask** define uma variável de ambiente que define automaticamente as permissões de arquivo nos arquivos recém-criados. ou seja, definirá a máscara de criação de arquivo. 178 | 179 | Este comando aceita o conjunto de permissões de 3 bits que vemos nas permissões numéricas. Em vez de adicionar essas permissões, o umask tira essas permissões. 180 | 181 | Por exemplo: 182 | 183 | ```bash 184 | umask 021 185 | ``` 186 | 187 | No exemplo acima, estamos afirmando que queremos que as permissões padrão de novos arquivos permitam aos usuários acessar tudo, mas para grupos queremos retirar sua permissão de leitura e para outros queremos retirar sua permissão de executar. 188 | 189 | Para determinar o valor de **umask** que você deseja definir, subtraia o valor das permissões desejadas de 666(para um arquivo) ou 777(para um diretório), o restante é o valor a ser usado com o comando umask. 190 | 191 | Por exemplo, suponha que você queira alterar o modo padrão dos arquivos para 644(**rw-r--r--**). A diferença entre 666 e 644 é 022, que é o valor que você usaria como argumento para o comando **umask**. 192 | 193 | Você também pode determinar o valor de umask que deseja definir usando a tabela a seguir, que mostra as permissões de arquivo e diretório criadas para cada um dos valores octais de umask. 194 | 195 | | Valor Octal | Permissões de Arquivos | Permissões de Diretórios | 196 | |---|---|---| 197 | | 0 | rw- | rwx | 198 | | 1 | rw- | rw- | 199 | | 2 | r-- | r-x | 200 | | 3 | r-- | r-- | 201 | | 4 | -w- | -wx | 202 | | 5 | -w- | -w- | 203 | | 6 | --x | --x | 204 | | 7 | --- | --- | 205 | 206 | O comando a seguir define as permissões de arquivo padrão como (rw-rw-rw-). 207 | 208 | ```bash 209 | umask 000 210 | ``` 211 | -------------------------------------------------------------------------------- /Conteúdo/Informações.md: -------------------------------------------------------------------------------- 1 | # Informações do Sistema 2 | 3 | Existem diversos comandos que podem nos trazer informações úteis sobre o sistema que estamos operando. 4 | 5 | Para saber apenas o **nome do sistema**, você pode usar o comando **uname** sem nenhuma opção: 6 | 7 | ```bash 8 | uname 9 | # Linux 10 | ``` 11 | 12 | Para visualizar o nome do host da sua rede, use a opção **'-n'** com o comando **uname**: 13 | 14 | ```bash 15 | uname -n 16 | # akira 17 | ``` 18 | 19 | Para obter informações sobre o kernel, usamos a opção **'-v'**: 20 | 21 | ```bash 22 | uname -v 23 | # #46~18.04.1-Ubuntu SMP Fri Jul 10 07:21:24 UTC 2020 24 | ``` 25 | 26 | Para obter as informações sobre a versão do seu kernel, use a opção **'-r'**: 27 | 28 | ```bash 29 | uname -r 30 | # 5.4.0-42-generic 31 | ``` 32 | 33 | Para imprimir o nome do hardware da sua máquina, use a opção **'-m'**: 34 | 35 | ```bash 36 | uname -m 37 | # x86_64 38 | ``` 39 | 40 | Todas essas informações podem ser impressas de uma só vez utilizando a opção **'-a'**: 41 | 42 | ```bash 43 | uname -a 44 | # Linux akira 5.4.0-42-generic #46~18.04.1-Ubuntu SMP Fri Jul 10 07:21:24 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux 45 | ``` 46 | 47 | Informações sobre a distribuição Linux podem ser encontradas nos arquivos *release*: 48 | 49 | ```bash 50 | cat /etc/*-release 51 | ``` 52 | 53 | Podemos também usar o arquivo **version**, localizado em `/proc/`: 54 | 55 | ```bash 56 | cat /proc/version 57 | ``` 58 | 59 | ## Informações de Hardware 60 | 61 | A ferramenta **lshw** pode ser usada para coletar informações abrangentes sobre os componentes de hardware, como CPU, discos, memória, controladores USB, etc. 62 | 63 | **Importante**: Lembre-se de que o comando **lshw** é executado pelo superusuário(root) ou pelo usuário sudo. 64 | 65 | Para imprimir informações sobre o hardware do sistema Linux, podemos executar o comando. 66 | 67 | ```bash 68 | sudo lshw 69 | ``` 70 | 71 | É possível imprimir um resumo das informações do seu hardware usando a opção **-short**. 72 | 73 | ```bash 74 | sudo lshw -short 75 | ``` 76 | 77 | Se você deseja gerar uma saída como um arquivo html, pode usar a opção **-html**. 78 | 79 | ```bash 80 | sudo lshw -html > lshw.html 81 | ``` 82 | 83 | ## Informações de CPU 84 | 85 | Para visualizarmos informações sobre a CPU, usamos o comando lscpu, pois ele mostra informações sobre a arquitetura da CPU, como número de CPUs, núcleos, modelo de família de CPUs, caches de CPU, threads, etc. 86 | 87 | ```bash 88 | lscpu 89 | ``` 90 | 91 | Também podemos recorrer ao arquivo **cpuinfo** para obter informações 92 | 93 | ```bash 94 | cat /proc/cpuinfo 95 | ``` 96 | 97 | Para localizarmos se CPU é de 32 bits ou 64 bits podemos executar 98 | 99 | ```bash 100 | getconf LONG_BIT 101 | ``` 102 | 103 | ## Informações sobre Block Devices 104 | 105 | *Block Devices* são dispositivos de armazenamento, como discos rígidos, unidades flash etc. O comando **lsblk** é usado para relatar informações sobre os *block devices* da seguinte maneira. 106 | 107 | ```bash 108 | lsblk 109 | ``` 110 | 111 | Para obtermos informações específicas sobre a memória, podemos utilizar o comando 112 | 113 | ```bash 114 | cat /proc/meminfo 115 | ``` 116 | 117 | Para sabermos quanto há de memória em uso e disponível e *swap*, o comando **free** pode nos ajudar, com a opção **-m** podemos ver em *MB*. 118 | 119 | ```bash 120 | free -m 121 | ``` 122 | 123 | - `-b`: Saída em bytes 124 | 125 | - `-k`: Saída em kilobytes 126 | 127 | - `-m`: Saída em megabytes 128 | 129 | Se você deseja visualizar todos os *block devices* no seu sistema, inclua a opção **-a**. 130 | 131 | ```bash 132 | lsblk -a 133 | ``` 134 | 135 | ## Informações sobre os Controladores USB 136 | 137 | O comando **lsusb** é usado para relatar informações sobre controladores USB e todos os dispositivos conectados a eles. 138 | 139 | ```bash 140 | lsusb 141 | ``` 142 | 143 | Você pode usar a opção **-v** para gerar informações detalhadas sobre cada dispositivo USB. 144 | 145 | ```bash 146 | lsusb -v 147 | ``` 148 | 149 | ## Informações sobre Dispositivos PCI 150 | 151 | Os dispositivos PCI podem incluir portas USB, placas gráficas, adaptadores de rede etc. A ferramenta **lspci** é usada para gerar informações sobre todos os controladores PCI do seu sistema, além dos dispositivos conectados a eles. 152 | 153 | Para imprimir informações sobre dispositivos PCI, executamos o seguinte comando. 154 | 155 | ```bash 156 | lspci 157 | ``` 158 | 159 | A opção **-t** pode ser usada para produzir saída em um formato de árvore. 160 | 161 | ```bash 162 | lspci -t 163 | ``` 164 | 165 | A opção **-v** produz informações detalhadas sobre cada dispositivo conectado. 166 | 167 | ```bash 168 | lspci -v 169 | ``` 170 | 171 | ## Informações do Sistema de Arquivos Linux 172 | 173 | Para coletarmos informações sobre partições do sistema de arquivos, podemos usar o comando **fdisk**. Embora a principal funcionalidade do comando fdisk seja modificar partições do sistema de arquivos, ele também pode ser usado para visualizar informações sobre as diferentes partições no seu sistema de arquivos. 174 | 175 | Podemos imprimir as informações da partição da seguinte maneira. Lembre-se de executar o comando como superusuário. 176 | 177 | ```bash 178 | sudo fdisk -l 179 | ``` 180 | 181 | O comando **df**(disk free), quando usado sem nenhuma opção, exibe informações sobre o espaço total em disco, o espaço em disco atualmente em uso e o espaço livre em todas as unidades montadas. Se um diretório for especificado, as informações serão limitadas à unidade em que esse diretório está localizado. 182 | 183 | - `-H`: mostra o número de blocos ocupados em gigabytes, megabytes ou kilobytes - em formato legível por humanos 184 | 185 | - `-t`: Tipo de sistema de arquivos (ext2, nfs, etc.) 186 | 187 | O comando **du** quando executado sem nenhum parâmetro, mostra o espaço total em disco ocupado por arquivos e subdiretórios no diretório atual. 188 | 189 | - `-a`: Exibe o tamanho de cada arquivo individual 190 | 191 | - `-h`: Saída em formato legível por humanos 192 | 193 | - `-s`: Exibe apenas o tamanho total calculado 194 | 195 | ## Extrair Informações sobre Componentes de Hardware 196 | 197 | Podemos também usar o utilitário **dmidecode** para extrair informações de hardware lendo dados das [tabelas DMI](https://en.wikipedia.org/wiki/Desktop_Management_Interface). 198 | 199 | Para imprimir informações sobre memória, executamos este comando como um superusuário. 200 | 201 | ```bash 202 | sudo dmidecode -t memory 203 | ``` 204 | 205 | Para imprimir informações sobre o sistema, executamos este comando. 206 | 207 | ```bash 208 | sudo dmidecode -t system 209 | ``` 210 | 211 | Para imprimir informações sobre o BIOS, executamos este comando. 212 | 213 | ```bash 214 | sudo dmidecode -t bios 215 | ``` 216 | 217 | Para imprimir informações sobre o processador, executamos este comando. 218 | 219 | ```bash 220 | sudo dmidecode -t processor 221 | ``` 222 | 223 | Para sabermos o fabricante podemos usar o comando. 224 | 225 | ```bash 226 | sudo dmidecode -s system-manufacturer 227 | ``` 228 | 229 | Para sabermos o modelo podemos usar o comando. 230 | 231 | ```bash 232 | sudo dmidecode -s system-product-name 233 | ``` 234 | 235 | ## Desligar e Reiniciar o Sistema 236 | 237 | No Linux, como em todas as tarefas, as operações de desligamento e reinicialização também podem ser feitas na linha de comando. Os comandos normalmente utilizados são **shutdown**, **halt**, **poweroff**, **reboot**. 238 | 239 | Os comandos são úteis especialmente quando precisamos reiniciar um servidor Linux remoto, onde apenas o acesso ao shell está disponível e não há interface de usuário. Os servidores geralmente precisam ser reiniciados quando as atualizações são instaladas ou precisam ser desligados para outras tarefas de manutenção. 240 | 241 | ### shutdown 242 | 243 | O comando **shutdown** pode ser usado para desligar um sistema ou reiniciá-lo. É comumente usado para desligar ou reinicializar máquinas locais e remotas. 244 | 245 | shutdown faz com que o sistema seja desativado de maneira segura. Todos os usuários logados são notificados de que o sistema está caindo e, nos últimos cinco minutos de **TEMPO**, novos logins são impedidos. 246 | 247 | A síntaxe dele é: 248 | 249 | ``` 250 | shutdown [OPÇÃO] [TEMPO] [MENSAGEM] 251 | ``` 252 | 253 | Para desligar uma máquina podemos executar o shutdown da seguinte forma: 254 | 255 | ```bash 256 | shutdown -h now 257 | ``` 258 | 259 | A opção **-h** é para *halt*, o que significa parar. O segundo parâmetro é o parâmetro de tempo. "**now**" significa desligar o sistema imediatamente. 260 | 261 | O parâmetro de tempo também pode ser especificado em minutos ou horas. Por exemplo: 262 | 263 | ```bash 264 | shutdown -h +5 "Server vai cair para atualização, por favor, salve seu trabalho." 265 | ``` 266 | 267 | O comando acima deve mostrar a mensagem para todos os outros usuários conectados e dar a eles 5 minutos antes que o sistema seja desligado. 268 | 269 | O comando shutdown também pode ser usado para reiniciar um sistema com a opção **-r**: 270 | 271 | ```bash 272 | shutdown -r +5 "Server vai cair para atualização, por favor, salve seu trabalho." 273 | ``` 274 | 275 | Todos os outros usuários conectados verão uma mensagem de transmissão em seus terminais, neste ponto, o shutdown pode ser cancelado chamando-o com a opção "**-c**". 276 | 277 | ```bash 278 | shutdown -c 279 | ``` 280 | 281 | ### reboot 282 | 283 | O comando **reboot** pode ser utilizado para desligar ou reiniciar o sistema Linux. 284 | 285 | O seguinte comando desligará o Linux: 286 | 287 | ```bash 288 | reboot -p 289 | ``` 290 | 291 | A opçõe "**-p**" significa poweroff. Para reinicializar o Linux, basta chamarmos o comando reboot diretamente sem nenhuma opção. 292 | 293 | ```bash 294 | reboot 295 | ``` 296 | 297 | Isso executará um desligamento normal e reinicialização da máquina. Isso é o que acontece quando você clica em reiniciar no menu gráfico. 298 | 299 | Já o comando a seguir forçará a reinicialização da máquina. Isso é semelhante a pressionar o botão liga/desliga. Nenhum desligamento ocorre. O sistema será reiniciado instantaneamente. 300 | 301 | ```bash 302 | reboot -f 303 | ``` 304 | 305 | ### halt 306 | 307 | O comando **halt** também pode desligar um sistema: 308 | 309 | ```bash 310 | halt 311 | ``` 312 | 313 | Para mais detalhes e opções: 314 | 315 | ```bash 316 | man halt 317 | ``` 318 | 319 | ### poweroff 320 | 321 | **poweroff** é um comando muito semelhante ao comando halt. Ele faz as mesmas coisas e usa as mesmas opções. 322 | 323 | ```bash 324 | poweroff 325 | ``` 326 | 327 | ### REISUB - Pressionamento das teclas R E I S U B 328 | 329 | Os comandos mostrados acima podem ser usados ​​quando você está no controle de seu sistema. E se o sistema travou e não está respondendo? E você não quer pressionar o botão liga/desliga da CPU, o que pode levar à corrupção de dados. Para salvar de tal situação, vêm as chaves mágicas sysRQ. 330 | 331 | Uma combinação especial de pressionamentos de tecla que permitirá que você reinicie seu sistema Linux, não importa o quanto ele esteja travado. 332 | 333 | "Um uso comum da chave mágica **SysRq** é realizar uma reinicialização segura de um computador Linux que, de outra forma, travou. Isso pode evitar que um fsck seja necessário na reinicialização e dá a alguns programas a chance de salvar backups de emergência de trabalhos não salvos." 334 | 335 | **Atenção!**: Pressionar as seguintes teclas reinicializaria instantaneamente o seu sistema. É semelhante a pressionar o botão liga/desliga ou executar o comando `reboot -f`. 336 | 337 | ``` 338 | ALT + PrintScreen + B 339 | ``` 340 | 341 | Agora, no lugar da tecla **B**, temos que usar as letras **R** **E** **I** **S** **U** primeiro. Cada chave realiza uma tarefa conforme mencionado abaixo: 342 | 343 | ``` 344 | unRaw (take control of keyboard back from X), 345 | tErminate (send SIGTERM to all processes, allowing them to terminate gracefully), 346 | kIll (send SIGKILL to all processes, forcing them to terminate immediately), 347 | Sync (flush data to disk), 348 | Unmount (remount all filesystems read-only), 349 | reBoot. 350 | ``` 351 | 352 | O procedimento então é: 353 | 354 | 1. Mantenha pressionadas as teclas Alt e SysRq (Print Screen). 355 | 2. Enquanto as mantém pressionadas, digite as seguintes teclas em ordem, com um intervalo: `R E I S U B` 356 | 3. O computador deve reiniciar. 357 | 358 | Certifique-se de ter algum intervalo de tempo entre cada uma das teclas `R E I S U B`. 359 | 360 | O recurso **sysrq** pode ser controlado alterando o valor de `/proc/sys/kernel/sysrq`. 361 | 362 | ## Data e Calendário 363 | 364 | O comando **date** nos traz informação sobre o dia e horário e o comando **cal** nos traz um calendário, ambos contam com diversas opções. 365 | 366 | Podemos por exemplo compor o seguinte *output* com date: 367 | 368 | ```bash 369 | date +"%d/%m/%Y" 370 | ``` 371 | 372 | Que me traz o resultado: `14/08/2020`. -------------------------------------------------------------------------------- /Conteúdo/Usuários.md: -------------------------------------------------------------------------------- 1 | # Gerenciamento de Usuários 2 | 3 | Em qualquer sistema operacional tradicional, existem usuários e grupos. Eles existem apenas para acesso e permissões. Ao executar um processo, ele será executado como o proprietário desse processo, seja **Gabriel** ou **Rafael**. O acesso e a propriedade do arquivo também dependem da permissão. Não seria seguro que **Gabriel** visse os documentos de **Rafael** e vice-versa. 4 | 5 | Um usuário é uma entidade, em um sistema operacional Linux, que pode manipular arquivos e realizar várias outras operações. Cada usuário recebe um ID exclusivo para cada usuário no sistema operacional. Após a instalação do sistema operacional, o ID 0 é atribuído ao usuário root e os IDs 1 a 999 (ambos inclusivos) são atribuídos aos usuários do sistema e, portanto, os IDs para o usuário local começam a partir de 1000. 6 | 7 | Cada usuário tem seu próprio diretório inicial, onde seus arquivos específicos são armazenados, geralmente localizado em `/home/usuario` , mas pode variar em distribuições diferentes. 8 | 9 | O sistema usa IDs de usuário (UID) para gerenciar usuários, nomes de usuário são a forma amigável de associar usuários à identificação, mas o sistema os identifica por seu UID. O sistema também usa grupos para gerenciar permissões, grupos são apenas conjuntos de usuários com permissão definida por aquele grupo, eles são identificados pelo sistema com seu ID de grupo (GID). 10 | 11 | No Linux, você terá usuários além dos humanos normais que usam o sistema. Às vezes, esses usuários são daemons do sistema que executam processos continuamente para manter o funcionamento do sistema. Um dos usuários mais importantes é o **root** ou **superusuário**, o root é o usuário mais poderoso do sistema, o root pode acessar qualquer arquivo e iniciar e encerrar qualquer processo. Por esse motivo, pode ser perigoso operar como root o tempo todo, você pode remover arquivos essenciais do sistema. Felizmente, se o acesso root for necessário e um usuário tiver acesso root, ele poderá executar um comando como root em vez do comando sudo. O comando sudo (superuser do) é usado para executar um comando com acesso root. 12 | 13 | Podemos por exemplo tentar visualizar um arquivo protegido como `/etc/shadow`: 14 | 15 | ```bash 16 | cat /etc/shadow 17 | ``` 18 | 19 | Observe como obtemos um erro de **permissão negada**, podemos consultar as permissões com o comando: 20 | 21 | ```bash 22 | ls -la /etc/shadow 23 | ``` 24 | 25 | **root** é o proprietário deste arquivo e precisaremos de acesso root ou fazer parte do grupo shadow para ler o conteúdo. Podemos então ler ele prefixando nosso comando com **sudo**: 26 | 27 | ```bash 28 | sudo cat /etc/shadow 29 | ``` 30 | 31 | ## Root 32 | 33 | o comando **sudo** nos permite obter acesso de superusuário. Também podemos executar comandos como superusuário com o comando **su**. Este comando irá "substituir usuários" e abrir um shell root se nenhum nome de usuário for especificado. Podemos usar este comando para substituir qualquer usuário, desde que saibamos a senha. 34 | 35 | ```bash 36 | su 37 | ``` 38 | 39 | Existem algumas desvantagens em usar este método: é muito mais fácil cometer um erro crítico executando tudo no root, você não terá registros dos comandos que usa para alterar as configurações do sistema, etc. Basicamente, se você precisar executar comandos como o superusuário, **sudo** é uma excelente opção. 40 | 41 | Como saber quem tem acesso para fazer isso? O sistema não permite que cada pessoa execute comandos como superusuário, então, como ele sabe? Existe um arquivo chamado `/ etc/sudoers`, esse arquivo lista os usuários que podem executar o **sudo**. Você pode editar este arquivo com o comando **visudo**. 42 | 43 | ## /etc/passwd 44 | 45 | É importante lembrarmos de que nomes de usuário não são identificações de usuários. O sistema usa um ID de usuário (UID) para identificar um usuário. Para descobrir quais usuários estão mapeados para qual ID, podemos consultar o arquivo `/etc/passwd`. 46 | 47 | ```bash 48 | cat /etc/passwd 49 | ``` 50 | 51 | Este arquivo mostra uma lista de usuários e informações detalhadas sobre eles. Por exemplo, a primeira linha neste arquivo é semelhante a: 52 | 53 | ``` 54 | root:x:0:0:root:/root:/bin/bash 55 | daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin 56 | bin:x:2:2:bin:/bin:/usr/sbin/nologin 57 | sys:x:3:3:sys:/dev:/usr/sbin/nologin 58 | ``` 59 | 60 | Cada linha exibe informações de usuário para um usuário, comumente veremos o usuário root como a primeira linha. 61 | 62 | Existem muitos campos separados por dois pontos que fornecem informações adicionais sobre o usuário: 63 | 64 | 1. Nome do usuário 65 | 2. Senha do usuário: a senha não é realmente armazenada neste arquivo, geralmente é armazenada no arquivo `/etc/shadow`. É possível vermos muitos símbolos diferentes neste campo, se você ver um "x" significa que a senha está armazenada no arquivo `/etc/shadow`, um "\*" significa que o usuário não tem acesso de login e se houver um campo em branco significa que o usuário não tem uma senha. 66 | 3. O ID do usuário: o usuário root tem o UID de 0 67 | 4. O ID do grupo 68 | 5. Campo GECOS - geralmente é usado para deixar comentários sobre o usuário ou conta, como seu nome real ou número de telefone, delimitado por vírgulas. 69 | 6. Diretório inicial do usuário 70 | 7. Shell do usuário: muitos usuários usam o bash para seu shell 71 | 72 | O arquivo `/etc/passwd` também contém outros usuários. É importante lembrarmos que os usuários estão realmente apenas no sistema para executar processos com permissões diferentes. Às vezes, queremos executar processos com permissões pré-determinadas. Por exemplo, o usuário daemon é usado para processos daemon. 73 | 74 | Podemos editar o arquivo `/etc/passwd` manualmente se quisermos adicionar usuários e modificar informações com a ferramenta **vipw**. 75 | 76 | ## /etc/shadow 77 | 78 | O arquivo `/etc/shadow` é usado para armazenar informações sobre a autenticação do usuário. Requer permissões de leitura de superusuário. 79 | 80 | ```bash 81 | sudo cat /etc/shadow 82 | ``` 83 | 84 | É possível percebermos que seu conteúdo é muito semelhante ao conteúdo de `/etc/passwd`, entretanto, no campo de senha, você verá uma senha criptografada. Os campos são separados por dois pontos da seguinte forma: 85 | 86 | 1. Nome do usuário 87 | 2. Senha criptografada 88 | 3. Data da última alteração da senha: expressa como o número de dias desde 1º de janeiro de 1970. Se houver um 0, isso significa que o usuário deve alterar sua senha na próxima vez que fizer login 89 | 4. Duração mínima da senha: Dias que um usuário terá que esperar antes de poder alterar sua senha novamente 90 | 5. Duração máxima da senha: Número máximo de dias antes que um usuário tenha que alterar sua senha 91 | 6. Período de aviso de senha: Número de dias antes que uma senha expire 92 | 7. Período de inatividade da senha: Número de dias após a expiração de uma senha para permitir o login com sua senha 93 | 8. Data de expiração da conta: data em que o usuário não poderá fazer o login 94 | 9. Campo reservado para uso futuro 95 | 96 | Em muitas das distribuições de hoje, a autenticação do usuário não depende apenas do arquivo `/etc/shadow`, existem outros mecanismos em funcionamento, como PAM(Pluggable Authentication Modules) que substituem a autenticação. 97 | 98 | ## /etc/group 99 | 100 | Outro arquivo usado no gerenciamento de usuários é o arquivo `/etc/group`. Este arquivo permite diferentes grupos com diferentes permissões. 101 | 102 | ```bash 103 | cat /etc/group 104 | ``` 105 | 106 | Semelhante aos campos de `/etc/password`, os campos `/etc/group` são os seguintes: 107 | 108 | 1. Nome do grupo 109 | 2. Senha de grupo: Não há necessidade de definir uma senha de grupo, usando um privilégio elevado, como sudo é padrão. Um "\*" será colocado como o valor padrão. 110 | 3. ID do grupo (GID) 111 | 4. Lista de usuários: Podemos especificar manualmente os usuários que desejarmos em um grupo específico 112 | 113 | ## Ferramentas de Gerenciamento de Usuários 114 | 115 | A maioria dos ambientes corporativos usam sistemas de gerenciamento para gerenciar usuários, contas e senhas. No entanto, em um único computador, existem comandos úteis que podemos executar para gerenciar usuários. 116 | 117 | ### Adicionando Usuários 118 | 119 | Podemos usar o comando **adduser** ou o comando **useradd**. O comando adduser contém recursos úteis, como criar um diretório inicial. Existem arquivos de configuração para adicionar novos usuários que podem ser personalizados, dependendo do que você deseja alocar para um usuário padrão. 120 | 121 | ```bash 122 | sudo useradd gabriel 123 | ``` 124 | 125 | O comando acima cria uma entrada em `/etc/passwd` para **gabriel**, configura grupos padrão e adiciona uma entrada ao arquivo `/etc/shadow`. 126 | 127 | ### Removendo Usuários 128 | 129 | Para remover um usuário, podemos usar o comando **userdel**: 130 | 131 | ```bash 132 | sudo userdel gabriel 133 | ``` 134 | 135 | ### Alterando Senhas 136 | 137 | O comando **passwd** permitirá que você altere a sua senha ou de outro usuário (se você for root). 138 | 139 | ```bash 140 | passwd gabriel 141 | ``` 142 | 143 | ### Listando Usuários 144 | 145 | Para listar todos os usuários no Linux, podemos usar **awk** com a opção **-F**. Acessaremos um arquivo e imprimimos apenas a primeira coluna com a ajuda de `print $1` e awk. 146 | 147 | ```bash 148 | awk -F':' '{ print $1}' /etc/passwd 149 | ``` 150 | 151 | ### Obtendo o ID do Usuário 152 | 153 | Usando o comando **id**, podemos obter o ID de qualquer nome de usuário. Cada usuário tem um id atribuído a ele e o usuário é identificado com a ajuda deste id. Por padrão, este id é também o id do grupo do usuário. 154 | 155 | ```bash 156 | id usuario 157 | ``` 158 | 159 | ### Alterando o ID de um Usuário 160 | 161 | o comando **usermod** pode alterar o ID de usuário de um usuário. O usuário com o nome de usuário fornecido será atribuído com o novo ID fornecido no comando e o ID antigo será removido. 162 | 163 | ```bash 164 | usermod -u novoidusuario usuario 165 | ``` 166 | 167 | ### Modificando o ID de Grupo de um Usuário 168 | 169 | O comando **usermod** pode alterar o ID de grupo de um usuário e, portanto, pode até ser usado para mover um usuário para um grupo já existente. Isso mudará o ID do grupo do usuário cujo nome de usuário é fornecido e define o ID do grupo como o **novo_id_fornecido** fornecido. 170 | 171 | ```bash 172 | usermod -g novoidgrupo usuario 173 | ``` 174 | 175 | ### Adicionando Usuários aos Grupos de Usuários 176 | 177 | É possível visualizar os grupos existentes em seu sistema operacional Linux digitando o seguinte comando: 178 | 179 | ```bash 180 | # Digite o comando e aperte [tab] duas vezes 181 | groupmod 182 | ``` 183 | 184 | Para adicionar um usuário a um grupo, use o seguinte comando: 185 | 186 | ```bash 187 | sudo usermod -a -G grupo usuario 188 | ``` 189 | 190 | ### Criando um Grupo de Usuários 191 | 192 | Vamos entender como criar um grupo. Temos todos os grupos listados no arquivo `/etc/groups`. 193 | 194 | Todos os grupos padrão são grupos específicos de contas do sistema e não é recomendado usá-los para contas comuns. A seguir temos sintaxe para criar uma nova conta de grupo 195 | 196 | ```bash 197 | groupadd programadores 198 | ``` 199 | 200 | O exemplo em cima cria um grupo de programadores com valores padrão, o que é bastante aceitável para a maioria dos administradores de sistemas. 201 | 202 | ### Modificando um Grupo 203 | 204 | Para modificar um grupo, usamos o comando **groupmod** 205 | 206 | ```bash 207 | groupmod -n novo_grupo antigo_grupo 208 | ``` 209 | 210 | ### Deletando um Grupo 211 | 212 | Para excluir um grupo existente, tudo que precisamos é o comando **groupdel** e o **nome do grupo**. 213 | 214 | ```bash 215 | groupdel programadores 216 | ``` 217 | 218 | ### Mudando o Nome de Login do Usuário 219 | 220 | É possível alterar o nome de login do usuário usando o comando **usermod**. O comando a seguir é usado para alterar o nome de login do usuário. O nome de login antigo do usuário é alterado para o novo nome de login fornecido. 221 | 222 | ```bash 223 | sudo usermod -l novo_login antigo_login 224 | ``` 225 | 226 | ### Alterando o Diretório Home 227 | 228 | O comando **usermod** pode ser utilizado também para alterar o diretório inicial. O comando a seguir altera o diretório inicial do usuário cujo nome de usuário é fornecido e define o novo diretório inicial como o diretório cujo caminho é fornecido. 229 | 230 | ```bash 231 | usermod -d novo_caminho_diretorio_home usuario 232 | ``` 233 | 234 | ### Deletando um Usuário 235 | 236 | É possível também excluir um nome de usuário. O comando a seguir exclui o usuário cujo nome de usuário é fornecido. Certifique-se de que o usuário não faça parte de um grupo. Se o usuário fizer parte de um grupo, ele não será excluído diretamente, portanto, primeiro teremos que removê-lo do grupo e depois podemos excluí-lo. 237 | 238 | ```bash 239 | userdel -r gabriel 240 | ``` 241 | 242 | ### /etc/default/useradd 243 | 244 | O arquivo `/etc/default/useradd` contém algumas opções padrão do usuário. O comando useradd -D pode ser usado para exibir este arquivo. 245 | 246 | ```bash 247 | useradd -D 248 | ``` 249 | 250 | ### Finger 251 | 252 | O comando **finger** é usado para obter informações dos usuários em uma máquina Linux. É possível usá-lo em máquinas locais e remotas. 253 | 254 | A sintaxe `finger` fornece dados sobre todos os usuários logados na máquina remota e local: 255 | 256 | ```bash 257 | finger 258 | ``` 259 | 260 | A sintaxe `finger usuário` especifica as informações do usuário. 261 | 262 | ```bash 263 | finger gabriel 264 | ``` -------------------------------------------------------------------------------- /Conteúdo/Diretórios&Arquivos.md: -------------------------------------------------------------------------------- 1 | # Diretórios e Arquivos 2 | 3 | Tudo no Linux é um arquivo. Cada arquivo é organizado em uma árvore de diretórios hierárquica. O primeiro diretório no sistema de arquivos é apropriadamente chamado de diretório **root**. O diretório **root** tem muitas pastas e arquivos e você pode armazenar mais pastas e arquivos, etc. 4 | 5 | A imagem a seguir apresenta um exemplo de como é a árvore de diretórios: 6 | 7 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/linux-filesystem%202.png) 8 | 9 | ## Estrutura de Diretórios 10 | 11 | No [FHS](https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard), todos os arquivos e diretórios aparecem no diretório **root** `/`, mesmo se estiverem armazenados em diferentes dispositivos físicos ou virtuais. 12 | 13 | - `/`: **Root** de hierarquia primária e diretório **root** de toda a hierarquia do sistema de arquivos. 14 | - `/bin`: Binários de comando essenciais que precisam estar disponíveis no modo de usuário único. Exemplo: [cat](https://en.wikipedia.org/wiki/Cat_(Unix)), [ls](https://en.wikipedia.org/wiki/Ls), [cp](https://en.wikipedia.org/wiki/Cp_(Unix)) 15 | - `/boot`: Arquivos do [carregador de inicialização](https://en.wikipedia.org/wiki/Boot_loader), por exemplo, [kernels](https://en.wikipedia.org/wiki/Kernel_(computer_science)), [initrd](https://en.wikipedia.org/wiki/Initrd). 16 | - `/dev`: Arquivos de dispositivo, por exemplo, `/dev/null`, `/dev/sda1` 17 | - `/etc`: Contém arquivos de configuração do sistema 18 | - `/home`: Diretórios pessoais dos usuários, contendo arquivos salvos, configurações pessoais, etc 19 | - `/lib`: Bibliotecas essenciais para os binários em `/bin` e `/sbin` 20 | - `/media`: Pontos de montagem para mídia removível, como CD-ROMs 21 | - `/mnt`: Sistemas de arquivos montados temporariamente 22 | - `/opt`: Pacotes opcionais de software de aplicativo 23 | - `/proc`: Sistema de arquivos virtual que fornece informações de processo e kernel como arquivos. No Linux, corresponde a uma montagem [procfs](https://en.wikipedia.org/wiki/Procfs). Geralmente gerado automaticamente e preenchido pelo sistema, em tempo real. 24 | - `/root`: Diretório inicial para o usuário **root**. 25 | - `/run`: Dados variáveis em tempo de execução: informações sobre o sistema em execução desde a última inicialização, por exemplo, usuários conectados no momento e [daemons](https://en.wikipedia.org/wiki/Daemon_(computer_software)) em execução. 26 | - `/sbin`: Binários essenciais do sistema, por exemplo, fsck, init, route. 27 | - `/srv`: Dados específicos do site atendidos por esse sistema, como dados e scripts para servidores Web, dados oferecidos por servidores FTP e repositórios para sistemas de controle de versão. 28 | - `/sys`: Contém informações sobre dispositivos, drivers e alguns recursos do kernel. 29 | - `/tmp`: Arquivos temporários 30 | - `/usr`: Hierarquia secundária para dados do usuário, somente leitura; contém a maioria dos utilitários e aplicativos para (multi)usuários. 31 | - `/var`: Arquivos variáveis - arquivos cujo conteúdo deverá mudar continuamente durante a operação normal do sistema - como logs, e arquivos de email temporários. 32 | 33 | A localização desses arquivos e diretórios é conhecida como caminhos. Se você tivesse uma pasta chamada **home** com uma pasta dentro dela chamada **Documentos** e outra pasta nessa pasta chamada **Livros**, esse caminho seria assim: `/home/Documentos/Livros` 34 | 35 | ## Comandos 36 | 37 | ### Imprimir Diretório de Trabalho 38 | 39 | A navegação no sistema de arquivos, bem como a vida real, é útil se você souber onde está e para onde está indo. Para ver onde você está, você pode usar o comando [pwd](https://en.wikipedia.org/wiki/Pwd), este comando significa "imprimir diretório de trabalho" e mostra apenas em qual diretório você está, observe o caminho decorrente do diretório raiz. 40 | 41 | ```bash 42 | pwd 43 | ``` 44 | 45 | ### Mudar de Diretório 46 | 47 | Agora que sabemos onde estamos, vamos então nos mover pelo sistema de arquivos. Lembre-se de que precisamos navegar usando caminhos. 48 | 49 | Existem duas maneiras diferentes de especificar um caminho, com **caminhos absolutos** e **relativos**. 50 | 51 | - **Caminho absoluto**: Este é o caminho do diretório **root**. O diretório **root** geralmente é mostrado como uma barra. Toda vez que seu caminho começa com / significa que você está iniciando no diretório **root**. Por exemplo, `/home/gabriel/Desktop`. 52 | - **Caminho relativo**: Este é o caminho de onde você está atualmente no sistema de arquivos. Se estivéssemos na localização `/home/gabriel/Documentos` e quiséssemos acessar um diretório dentro de **Documentos** chamado **site**, não é necessário especificarmos o caminho inteiro a partir do **root**, como `/home/gabriel/Documentos/site`, basta irmos para `site/` em vez disso. 53 | 54 | Para que possámos mudar o nosso Diretório de Trabalho, podemos utilizar o comando `cd`, que significa *“change directory”*, ou seja, mudar diretório. 55 | 56 | Navegando até o diretório `Documentos` 57 | 58 | ```bash 59 | cd /home/gabriel/Documentos 60 | ``` 61 | 62 | Agora estamos trabalhando dentro do diretório `Documentos`, em que dentro dele eu tenho um diretório chamado `GitHub`, vou então navegar até esse diretório com o comando 63 | 64 | ```bash 65 | cd GitHub 66 | ``` 67 | 68 | Observe que utilizamos apenas o nome do diretório `GitHub`, isso porque já estávamos em `home/gabriel/Documentos`. 69 | 70 | Pode ser bastante cansativo navegar com caminhos absolutos e relativos o tempo todo, felizmente existem alguns atalhos para nos ajudar. 71 | 72 | - `.` (diretório atual). Este é o diretório em que você está atualmente. 73 | - `..` (diretório pai). Leva você ao diretório acima do seu atual. 74 | - `~` (diretório home). O diretório padrão é o seu "diretório inicial". Como `/home/gabriel`. 75 | - `-` (diretório anterior). Isso o levará ao diretório anterior em que você estava. 76 | 77 | ```bash 78 | cd . 79 | cd .. 80 | cd ~ 81 | cd - 82 | ``` 83 | 84 | **Auto-complete**: Quando estamos utilizando comandos no Bash, podemos contar com uma característica chamada *auto-complete*, que trata de auto-completar um comando para nós de forma a aumentar nossa eficiência. Por exemplo, se digitarmos o comando `cd Git` e apertarmos a tecla `[tab]` **uma vez**, ele irá preencher o comando com o diretório correspondente, que nesse exemplo é `GitHub`, se houver mais opções similares ele nos tratá todas elas. Se usarmos somente um comando como `ls` e teclarmos `[tab]` **duas vezes**, ele trará todas as opções possíveis de auto-complete existentes. 85 | 86 | ### Listando Arquivos e Diretórios 87 | 88 | [ls](https://www.rapidtables.com/code/linux/ls.html) é um comando shell que lista o conteúdo do **diretório de trabalho atual**. 89 | 90 | O comando ls listará os diretórios e arquivos no diretório atual por padrão, no entanto, podemos especificar em qual caminho desejamos listar os diretórios. 91 | 92 | ```bash 93 | ls 94 | ls /home/gabriel/Documentos 95 | ``` 96 | 97 | Para que podermos listar arquivos escondidos que começam com `.` podemos utilizar a opção/flag **"-a"** que significa *all*, ou seja, todos os arquivos e diretórios, sem exceção. 98 | 99 | ```bash 100 | ls -a 101 | ``` 102 | 103 | Uma outra opção muito importante é o **"-l"**, de *long*, que é capaz de mostrar a lista de arquivos e diretórios em um formato longo e detalhado. 104 | 105 | A partir da esquerda: permissões de arquivo, número de links, nome do proprietário, grupo de proprietários, tamanho do arquivo, *timestamp* da última modificação e nome do arquivo/diretório. 106 | 107 | ```bash 108 | ls -l 109 | ``` 110 | 111 | **Output:** 112 | 113 | ``` 114 | total 12 115 | drwxrwxr-x 2 akira akira 4096 jul 30 23:57 Conteúdo 116 | drwxrwxr-x 2 akira akira 4096 jul 30 05:04 Imagens 117 | -rw-rw-r-- 1 akira akira 591 jul 30 01:14 README.md 118 | ``` 119 | 120 | Os comandos possuem uma característica chamada de *flags*, também conhecido como argumentos ou opções para adicionar mais funcionalidades a eles. Veja como nos exemplos anteriores adicionamos `-l` e `-a` para modificar o *output* do comando **ls**, podemos além disso, combinar as opções e utilizá-las em conjunto. 121 | 122 | ```bash 123 | ls -la 124 | ``` 125 | 126 | **Output:** 127 | 128 | ``` 129 | total 24 130 | drwxrwxr-x 5 akira akira 4096 jul 30 00:40 . 131 | drwxrwxr-x 11 akira akira 4096 jul 30 00:04 .. 132 | drwxrwxr-x 2 akira akira 4096 jul 30 23:57 Conteúdo 133 | drwxr-xr-x 8 akira akira 4096 jul 30 16:01 .git 134 | drwxrwxr-x 2 akira akira 4096 jul 30 05:04 Imagens 135 | -rw-rw-r-- 1 akira akira 591 jul 30 01:14 README.md 136 | ``` 137 | 138 | Em breve veremos mais detalhes sobre usuários e permissões. 139 | 140 | **tree** é um pequeno programa de linha de comando, cross-platform, usado para listar ou exibir recursivamente o conteúdo de um diretório em um formato semelhante a uma árvore. Ele produz os caminhos de diretório e arquivos em cada subdiretório e um resumo de um número total de subdiretórios e arquivos. 141 | 142 | O programa tree está disponível em Unix e sistemas semelhantes ao Unix, como Linux, bem como DOS, Windows e muitos outros sistemas operacionais. Ele apresenta várias opções para manipulação de *output*, desde opções de arquivo, opções de classificação, até opções de gráficos e suporte para *output* em formatos XML, JSON e HTML. 143 | 144 | Para listar o conteúdo do diretório em um formato semelhante a uma árvore, navegamos até o diretório desejado e executamos o comando tree sem quaisquer opções ou argumentos, Devemos lembrar de invocar sudo para executar a árvore em um diretório que requer permissões de acesso do usuário root. 145 | 146 | ```bash 147 | tree 148 | sudo tree 149 | ``` 150 | 151 | Ele exibirá o conteúdo do *working directory* recursivamente, mostrando subdiretórios e arquivos, e um resumo do número total de subdiretórios e arquivos. Podemos ativar a impressão de arquivos ocultos usando a opção **-a**. 152 | 153 | ```bash 154 | sudo tree -a 155 | ``` 156 | 157 | Para listar o conteúdo do diretório com o prefixo do caminho completo para cada subdiretório e arquivo, usamos a opção **-f**. 158 | 159 | ```bash 160 | sudo tree -f 161 | ``` 162 | 163 | Podemos também instruir o tree a imprimir apenas os subdiretórios, sem os arquivos neles, usando a opção **-d**. Se usado junto com a opção **-f**, a árvore imprimirá o caminho completo do diretório. 164 | 165 | ```bash 166 | sudo tree -df 167 | ``` 168 | 169 | É possível especificar a profundidade máxima de exibição da árvore de diretórios usando a opção **-L**. Por exemplo, se quisermos uma profundidade de 2: 170 | 171 | ```bash 172 | sudo tree -f -L 2 173 | ``` 174 | 175 | Para exibirmos apenas os arquivos que correspondem ao padrão *wildcard*, usamos a opção **-P** e especificamos o padrão. Neste exemplo, o comando listará apenas os arquivos que correspondem a `linux*`, arquivos como: `linux-filesystem 2.png`, `linux-filesystem.png`, `linux_layers.png`, serão listados. 176 | 177 | ```bash 178 | tree -f -P linux* 179 | ``` 180 | 181 | Podemos exibir todos os arquivos Python que terminam com a extensão `.py`: 182 | 183 | ```bash 184 | tree -f -P *.py 185 | ``` 186 | 187 | É possível dizer ao **tree** para remover diretórios vazios do *output* adicionando a opção **--prune**: 188 | 189 | ```bash 190 | sudo tree -f --prune 191 | ``` 192 | 193 | A opção **-p** é capaz de imprimir o tipo de arquivo e as permissões para cada arquivo de maneira semelhante ao comando `ls -l`. 194 | 195 | ```bash 196 | sudo tree -f -p 197 | ``` 198 | 199 | Podemos ainda usar a opção **-u** para imprimir o nome de usuário (ou UID se nenhum nome de usuário estiver disponível) e a opção **-g** que imprime o nome do grupo (ou GID se nenhum nome de grupo estiver disponível). Podemos combinar as opções **-p**, **-u** e **-g**: 200 | 201 | ```bash 202 | tree -f -pug 203 | ``` 204 | 205 | É possível imprimir o tamanho de cada arquivo em bytes junto com o nome usando a opção **-s**. Para imprimir o tamanho de cada arquivo, mas em um formato mais legível, usamos a opção **-h**. 206 | 207 | ```bash 208 | sudo tree -s -h 209 | ``` 210 | 211 | Para exibir a data da hora da última modificação para cada subdiretório ou arquivo podemos usar a opção **-D**: 212 | 213 | ```bash 214 | tree -f -pug -h -D 215 | ``` 216 | 217 | Finalmente podemos enviar ou redirecionar o *output* do programa **tree** para um arquivo para análise posterior usando a opção **-o**. 218 | 219 | ```bash 220 | sudo tree -o arvore_diretorios.txt 221 | ``` 222 | 223 | o comando **du** (*Disk Usage*) é um comando padrão Unix/Linux usado para verificar as informações de uso do disco de arquivos e diretórios em uma máquina. O comando du tem muitas opções de parâmetro que podem ser usadas para obter os resultados em muitos formatos. Ele também é capaz de exibir os arquivos e tamanhos de diretório de maneira recursiva. 224 | 225 | Podemos usar ele em um arquivo, juntamente com a opção **-h** que indica *human readable*, em outras palavras, legível para humanos. 226 | 227 | ```bash 228 | du -h arrays.sh 229 | ``` 230 | 231 | Podemos também user ele em um diretório: 232 | 233 | ```bash 234 | du -h arquivos/ 235 | ``` 236 | 237 | Se usarmos a opção **-a** ele listará todos os arquivos dentro do diretório: 238 | 239 | ```bash 240 | du -ha files/ 241 | ``` 242 | 243 | Para exibirmos o uso do disco com base na modificação do tempo, usamos a opção **--time**: 244 | 245 | ```bash 246 | du -ha --time files/ 247 | ``` 248 | 249 | ### Criando Arquivos 250 | 251 | Vamos aprender a criar arquivos. Uma maneira muito simples é usar o comando **touch**. O touch permite criarmos novos arquivos vazios. 252 | 253 | Criando apenas um arquivo 254 | 255 | ```bash 256 | touch arquivo.txt 257 | ``` 258 | 259 | Criando múltiplos arquivos 260 | 261 | ```bash 262 | touch script.py readme.md 263 | ``` 264 | 265 | Existem também muitas outras maneiras de criar arquivos, como redirecionamento e editores de texto que veremos em breve. 266 | 267 | ### Criando Diretórios 268 | 269 | O comando **mkdir** nos permite criar diretórios, ele criará um diretório se ele ainda não existir. É possível também criar vários diretórios ao mesmo tempo. 270 | 271 | Criando apenas um diretório 272 | 273 | ```bash 274 | mkdir projeto 275 | ``` 276 | 277 | Criando múltiplos diretórios 278 | 279 | ```bash 280 | mkdir imagens videos 281 | ``` 282 | 283 | Criando um diretório com espaço em seu nome 284 | 285 | ```bash 286 | mkdir Scripts\ Python 287 | ``` 288 | 289 | Criando subdiretórios com a opção **"-p"** 290 | 291 | ```bash 292 | mkdir -p scripts/python 293 | ``` 294 | 295 | ### Removendo Arquivos e Diretórios 296 | 297 | Para remover arquivos, podemos utilizar o comando **rm**. O comando **rm** é usado para excluir arquivos e diretórios. 298 | 299 | Tenha cuidado ao usar **rm**, pois não há como recuperar os arquivos removidos por este comando. Depois que eles se foram, eles se foram para sempre. 300 | 301 | Para remover especificamente diretórios, podemos utilizar o comando **rmdir**. 302 | 303 | Vejamos alguns exemplos 304 | 305 | Adicionando a opção **"-i"** nos fornecerá um prompt para confirmarmos se realmente desejamos remover o arquivo, adicionando assim mais segurança ao processo de remoção. 306 | 307 | ```bash 308 | rm -i readme.md 309 | ``` 310 | 311 | Já a opção **"-f"** ou **force** diz ao comando **rm** para remover todos os arquivos, estejam eles protegidos contra gravação ou não. 312 | 313 | ```bash 314 | rm -f script.py 315 | ``` 316 | 317 | Por padrão **rm** não é capaz de remover diretórios, para obtermos essa funcionalidade temos de adicionar a flag **"-r"** de **recursive** para remover todos os arquivos e quaisquer subdiretórios que possam ter. 318 | 319 | ```bash 320 | rm -r scripts 321 | ``` 322 | 323 | Também podemos simplesmente remover um diretório com o comando **rmdir** 324 | 325 | ```bash 326 | rmdir imagens 327 | ``` 328 | 329 | ### Movendo e Renomeando Arquivos e Diretórios 330 | 331 | O comando **mv** é utilizado para mover arquivos e diretórios 332 | 333 | Para renomear um arquivo é muito simples 334 | 335 | ```bash 336 | mv arquivo.txt texto.txt 337 | ``` 338 | 339 | O arquivo de nome `arquivo.txt` agora irá se chamar `texto.txt` 340 | 341 | Podemos também mover um arquivo para um diretório diferente 342 | 343 | ```bash 344 | mv texto.txt Arquivos/ 345 | ``` 346 | 347 | Ou até mesmo mover mais de um arquivo: 348 | 349 | ```bash 350 | mv readme.md script.py Arquivos/ 351 | ``` 352 | 353 | A opção **"-i"** nos oferece um prompt que nos avisa se desejamos sobrescrever arquivos que possuem o mesmo nome. 354 | 355 | ```bash 356 | mv -i script.py Arquivos/ 357 | ``` 358 | 359 | Digamos que você queira mover um arquivo para substituir o anterior. Você também pode fazer um backup desse arquivo e ele renomeará a versão antiga com um **~** 360 | 361 | ```bash 362 | mv -b script.py Arquivos/ 363 | ``` 364 | 365 | Movendo diretórios para um diretório. Imagine que temos o diretório **imagens** e **vídeos** e desejamos movê-los para o diretório **Arquivos**. 366 | 367 | ```bash 368 | mv imagens/ videos/ Arquivos/ 369 | ``` 370 | 371 | ### Copiando Arquivos e Diretórios 372 | 373 | O comando **cp** nos permite copiar arquivos e diretórios. 374 | 375 | Podemos por exemplo copiar um arquivo para um diretório específico 376 | 377 | ```bash 378 | cp readme.md Arquivos/ 379 | ``` 380 | 381 | **readme.md** é o arquivo que estamos copiando e **Arquivos** é o diretório de destino da cópia. 382 | 383 | Podemos também copiar vários arquivos e diretórios e usar *wildcards*. Um *wildcard* é um caracter que pode ser substituído por uma seleção baseada em padrão, oferecendo mais flexibilidade nas pesquisas. Você pode usar *wildcards* em todos os comandos para obter mais flexibilidade: 384 | 385 | - `*`: É usado para representar todos os caracteres únicos ou qualquer *string*. 386 | - `?`: Usado para representar um caracter 387 | - `[]`: Usado para representar qualquer caracter entre colchetes 388 | 389 | Por exemplo, podemos copiar todos os arquivos com a extensão **.txt** para o diretório **Arquivos** 390 | 391 | ```bash 392 | cp *.txt Arquivos 393 | ``` 394 | 395 | Uma opção muito útil é **"-r"**, ele copiará recursivamente os arquivos e diretórios dentro de um diretório. 396 | 397 | ```bash 398 | cp -r Arquivos/ ArquivosCopia 399 | ``` 400 | 401 | Neste exemplo somos capazes de copiar por complete o diretório Arquivos, incluindo subdiretórios e arquivos. 402 | 403 | Se copiarmos um arquivo para um diretório com o mesmo nome de arquivo, o arquivo será substituído pelo que você estiver copiando. Se tivermos um arquivo que não desejamos substituir acidentalmente. Podemos usar a opção **"-i"** (de interativo) para avisar antes de substituir um arquivo. 404 | 405 | ```bash 406 | cp -i texto.txt Arquivos 407 | ``` 408 | 409 | Nesse caso nos será perguntado se desejamos sobrescrever o arquivo **texto.txt**, uma vez que já existe um arquivo com o mesmo nome dentro do diretório **Arquivos**. 410 | 411 | Para copiar um arquivo com um determinado caminho para o nosso diretório atual, podemos usar o comando: 412 | 413 | ```bash 414 | cp /home/akira/Documents/domains.csv . 415 | ``` 416 | 417 | O `.` indica nosso diretório atual. 418 | 419 | ### Examinando Arquivos 420 | 421 | O comando **file** examinará um arquivo e informará que tipo de arquivo ele é. Ele mostrará uma descrição do conteúdo do arquivo. 422 | 423 | Por exemplo 424 | 425 | ```bash 426 | file Arquivos # Arquivos: directory 427 | file readme.md # readme.md: ASCII text 428 | file imagem.png # imagem.png: PNG image data, 1400 x 1400, 8-bit/color RGB, non-interlaced 429 | ``` 430 | 431 | ### Lendo Arquivos 432 | 433 | Para lermos o conteúdo de um arquivo podemos utilizar o comando **cat**, abreviação de *concatenate*, ele não apenas exibe o conteúdo do arquivo, mas pode combinar vários arquivos e mostrar o *output* deles. 434 | 435 | ```bash 436 | cat script.py readme.md 437 | # print('Hello World') 438 | # Arquivo Leia-me 439 | ``` 440 | 441 | Podemos também copiar um arquivo com o comando **cat**: 442 | 443 | ```bash 444 | cat script.py > copia_script.py 445 | ``` 446 | 447 | O `>` é um operador de redirecionamento que nos permite mudar onde o *standard output* irá. Nos possibilita enviar o output de um comando como o **cat** ou **echo** para um arquivo, ao invés da tela. 448 | 449 | **Less** é um utilitário de linha de comando que exibe o conteúdo de um arquivo ou *output* de um comando, uma página de cada vez. É semelhante ao **more**, mas possui recursos mais avançados e permite navegar para frente e para trás no arquivo. 450 | 451 | Ao iniciar **less**, ele não lê o arquivo inteiro, o que resulta em tempos de carregamento muito mais rápidos. 452 | 453 | ```bash 454 | less /usr/share/common-licenses/GPL-3 455 | ``` 456 | 457 | Se você quiser mostrar os números de linha, inicie o programa com a opção **"-N"**: 458 | 459 | ```bash 460 | less -N /usr/share/common-licenses/GPL-3 461 | ``` 462 | 463 | Para navegar com o **less** podemos utilizar os seguintes comandos: 464 | 465 | - `q`: Utilizado para sair do **less** e retornar para a shell 466 | - `Page Up`, `Page Down`, `Up`, `Down`: Navegação através das teclas setas ou das teclas Page 467 | - `g`: Move para o início do arquivo 468 | - `G`: Move para o final do arquivo 469 | - `/search`: Podemos buscar por um texto específico dentro de um documento de texto por exemplo. Para início temos que colocar na frente da palavra que desejamos buscar um `/`, por exemplo `/developer` 470 | - `h`: Help/Ajuda dentro do programa **less**, traz um sumário de informações e comandos. 471 | 472 | O comando **more** é um comando para visualizar (mas não modificar) o conteúdo de um arquivo de texto, uma tela por vez. 473 | 474 | Por exemplo 475 | 476 | ```bash 477 | more /proc/cpuinfo 478 | ``` 479 | 480 | Para navegarmos no arquivo com **more** podemos usar as seguintes teclas: `[enter]` para irmos para a próxima linha, `[barra de espaço]` para a próxima página, `b` para retornarmos uma página, `q` para sairmos do arquivo, `h` para apresentar o texto de ajuda. 481 | 482 | ### Obtendo Informação 483 | 484 | Aprendemos um pouco sobre diversos comandos até então, se estivermos em dúvida sobre o que um comando faz, podemos usar o comando **whatis**. O comando whatis fornece uma breve descrição dos programas de linha de comando. 485 | 486 | ```bash 487 | whatis ls 488 | whatis cat 489 | whatis python 490 | ``` 491 | 492 | A descrição, como podemos observar, é obtida da página de manual de cada comando. -------------------------------------------------------------------------------- /Conteúdo/Processos.md: -------------------------------------------------------------------------------- 1 | # Gerenciamento de Processos 2 | 3 | ## Breve Histórico 4 | 5 | Com o passar do tempo os computadores ficaram mais rápidos enquanto que o [tempo computacional](https://en.wikipedia.org/wiki/Time-sharing) ainda não era barato nem totalmente utilizado, esse ambiente tornou *[multiprogramming](https://en.wikipedia.org/wiki/Computer_multitasking#Multiprogramming)* possível e necessário. Multiprogramação significa que vários programas são executados [simultaneamente](https://en.wikipedia.org/wiki/Concurrency_(computer_science)). 6 | 7 | No início, mais de um programa era executado em um único processador, como resultado da arquitetura subjacente do computador [uniprocessador](https://en.wikipedia.org/wiki/Uniprocessor_system), e eles compartilhavam recursos de hardware escassos e limitados, consequentemente, a simultaneidade era de natureza serial. Em sistemas posteriores com [múltiplos processadores](https://en.wikipedia.org/wiki/Multiprocessing), vários programas podem ser executados simultaneamente em [paralelo](https://en.wikipedia.org/wiki/Parallel_computing). 8 | 9 | Os programas consistem em sequências de instruções para processadores. Um único processador pode executar apenas uma instrução de cada vez: é impossível executar mais programas ao mesmo tempo. Um programa pode precisar de algum [recurso](https://en.wikipedia.org/wiki/System_resource), como um dispositivo de *input*, com um possível grande *delay*, ou um programa pode iniciar uma operação lenta, como o envio de *output* para uma impressora. Isso levaria o processador a ficar "inativo" (não utilizado). Para manter o processador sempre ocupado, a execução de um programa desse tipo é interrompida e o sistema operacional alterna o processador para executar outro programa. Para o usuário, parece que os programas são executados ao mesmo tempo (surge então o termo "paralelo"). 10 | 11 | Pouco tempo depois, a noção de "programa" foi expandida para a noção de "programa em execução e seu contexto". Nasceu o conceito de processo, que também se tornou necessário com a invenção do *[re-entrant code](https://en.wikipedia.org/wiki/Reentrancy_(computing))*. 12 | 13 | *Threads* vieram um pouco mais tarde. No entanto, com o advento de conceitos como *[time-sharing](https://en.wikipedia.org/wiki/Time-sharing)*, [redes de computadores](https://en.wikipedia.org/wiki/Computer_network) e computadores com [memória compartilhada](https://en.wikipedia.org/wiki/Shared_memory) com várias CPUs, a antiga "multiprogramação" deu lugar à verdadeira [multitarefa](https://en.wikipedia.org/wiki/Computer_multitasking), multiprocessamento e, posteriormente, [multithreading](https://en.wikipedia.org/wiki/Thread_(computing)#Multithreading). 14 | 15 | ## Processo 16 | 17 | Na computação, um processo é a [instância](https://en.wikipedia.org/wiki/Instance_(computer_science)) de um [programa de computador](https://en.wikipedia.org/wiki/Computer_program) que está sendo executado por um ou vários *threads*. 18 | 19 | Ele contém o código do programa e sua atividade. Dependendo do [sistema operacional(SO)](https://en.wikipedia.org/wiki/Operating_system), um processo pode ser composto de vários threads de execução que executam instruções [simultaneamente](https://en.wikipedia.org/wiki/Concurrency_(computer_science)). 20 | 21 | Um programa de computador é uma coleção passiva de instruções, já um processo é a execução real dessas instruções. Vários processos podem estar associados ao mesmo programa; por exemplo, abrir várias instâncias do mesmo programa geralmente resulta em mais de um processo sendo executado. 22 | 23 | A [multitarefa](https://en.wikipedia.org/wiki/Computer_multitasking) é um método para permitir que vários processos compartilhem [processadores](https://en.wikipedia.org/wiki/Central_processing_unit)(CPU's) e outros recursos do sistema. Cada CPU(núcleo) executa uma única tarefa de cada vez. No entanto, a multitarefa permite que cada processador alterne entre as tarefas que estão sendo executadas sem ter que esperar a conclusão de cada tarefa(*[preemption](https://en.wikipedia.org/wiki/Preemption_(computing))*). 24 | 25 | ## Representação 26 | 27 | Em geral, um processo de sistema de computador consiste dos seguintes recursos: 28 | 29 | - Uma imagem do código de máquina executável associado a um programa. 30 | - Memória (normalmente alguma região da [memória virtual](https://en.wikipedia.org/wiki/Virtual_memory)), que inclui o código executável, dados específicos do processo (*input* e *output*), uma [callstack](https://en.wikipedia.org/wiki/Call_stack)(para rastrear sub-rotinas ativas e/ou outros eventos) e uma [heap](https://en.wikipedia.org/wiki/Memory_management#Dynamic_memory_allocation) para armazenar dados de computação intermediários gerados durante o tempo de execução. 31 | - Descritores de recursos do sistema operacional que são alocados ao processo, como [file descriptors](https://en.wikipedia.org/wiki/File_descriptor)(terminologia Unix) ou [handles](https://en.wikipedia.org/wiki/Handle_(computing))(Windows) e fontes de dados. 32 | - Atributos de segurança, como o proprietário do processo e o conjunto de permissões do processo (operações permitidas). 33 | - Estado do processador([contexto](https://en.wikipedia.org/wiki/Context_(computing))), como o conteúdo dos registradores e o endereçamento da memória física. O estado normalmente é armazenado nos registros do computador quando o processo está em execução e na memória. 34 | 35 | O sistema operacional mantém a maioria dessas informações sobre processos ativos em estruturas de dados chamadas [blocos de controle de processo](https://en.wikipedia.org/wiki/Process_control_block). Qualquer subconjunto de recursos, geralmente ao menos o estado do processador, pode ser associado a cada um dos [threads](https://en.wikipedia.org/wiki/Thread_(computer_science)) do processo nos sistemas operacionais que suportam *threads* ou processos filhos(*child processes*). 36 | 37 | O sistema operacional mantém seus processos separados e aloca os recursos de que precisam, para que tenham menos probabilidade de interferir um com o outro e causar falhas no sistema(exemplo: [deadlock](https://en.wikipedia.org/wiki/Deadlock) ou [thrashing](https://en.wikipedia.org/wiki/Thrashing_(computer_science))). 38 | 39 | O sistema operacional também pode fornecer mecanismos de [comunicação entre processos](https://en.wikipedia.org/wiki/Inter-process_communication) para permitir que os processos interajam de maneiras seguras e previsíveis. 40 | 41 | ## Estados do Processo 42 | 43 | Um [kernel](https://en.wikipedia.org/wiki/Kernel_(computing)) do sistema operacional que permite a **multitarefa** necessita que os processos tenham [determinados estados](https://en.wikipedia.org/wiki/Process_states). Os nomes desses estados não são padronizados, mas eles têm uma funcionalidade semelhante. 44 | 45 | - Primeiro, o processo é "criado" ao ser carregado de um dispositivo de armazenamento secundário (unidade de disco rígido, CD-ROM, etc.) na memória principal. Depois disso, o [agendador de processos](https://en.wikipedia.org/wiki/Scheduling_(computing)) atribui o estado "em espera". 46 | - Enquanto o processo está "em espera", ele aguarda o agendador fazer a chamada [troca de contexto](https://en.wikipedia.org/wiki/Context_switch). A opção de contexto carrega o processo no processador e altera o estado para "em execução" enquanto o processo "em execução" anterior é armazenado no estado "em espera". 47 | - Se um processo no estado "em execução" precisar aguardar um recurso(esperar pelo input de um usuário ou abrir um arquivo), será atribuído o estado "bloqueado". O estado do processo é alterado novamente para "aguardando" quando o processo não precisa mais esperar(em um estado bloqueado). 48 | - Depois que o processo termina a execução ou é finalizado pelo sistema operacional, ele não é mais necessário. O processo é removido instantaneamente ou é movido para o estado "finalizado". Quando removido, ele apenas esperar ser removido da memória principal. 49 | 50 | A imagem a seguir representa os vários estados do processo, exibidos em um diagrama de estados, com setas indicando possíveis transições entre estados. 51 | 52 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/Process_states.png) 53 | 54 | ## Rastreando Processos com top 55 | 56 | [top](https://linux.die.net/man/1/top) é a ferramenta que usamos para obter uma visualização em tempo real da utilização do sistema por nossos processos: 57 | 58 | Pressione **H** para acessar uma página que explica brevemente as opções principais para personalizar o programa. 59 | 60 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/top.png) 61 | 62 | Vamos então interpretar o significado do *output* do top 63 | 64 | ### Linha 1 65 | 66 | É a mesma informação que veríamos se executássemos o comando **uptime** 67 | 68 | Os campos são respectivamente, da esquerda para a direita: 69 | 70 | 1. Horário atual 71 | 2. Há quanto tempo o sistema está em execução 72 | 3. Quantos usuários estão conectados no momento 73 | 4. Média de carga do sistema 74 | 75 | ### Linha 2 76 | 77 | Tarefas em execução, em suspensão, interrompidas e *zombied*. 78 | 79 | ### Linha 3 80 | 81 | Informação do CPU: 82 | 83 | 1. us: user CPU time - Porcentagem do tempo de CPU gasto na execução de processos de usuários que não são *[niced](https://en.wikipedia.org/wiki/Nice_(Unix))*. 84 | 2. sy: system CPU time - Porcentagem do tempo de CPU gasto executando os processos do kernel e o próprio kernel. 85 | 3. ni: nice CPU time - Porcentagem de tempo de CPU gasto executando processos *[niced](https://en.wikipedia.org/wiki/Nice_(Unix))* 86 | 4. id: tempo ocioso da CPU - porcentagem do tempo da CPU gasto ocioso. 87 | 5. wa: I/O wait - Porcentagem do tempo de CPU gasto aguardando Input/Output. Se esse valor for baixo, o problema provavelmente não é a I/O de disco ou de rede. 88 | 6. hi: interrupções de hardware - Porcentagem de tempo de CPU gasto servindo interrupções de hardware. 89 | 7. si: interrupções de software - porcentagem de tempo de CPU gasto atendendo interrupções de software. 90 | 8. st: steal time - Se você estiver executando máquinas virtuais, esta é a porcentagem de tempo de CPU que foi extraída de você para outras tarefas. 91 | 92 | ### Linhas 4 e 5 93 | 94 | Representam o uso de memória e uso de swap. 95 | 96 | ### Lista de Processos Atualmente em Uso 97 | 98 | Significado de cada coluna: 99 | 100 | 1. **PID**: ID do processo 101 | 2. **USER**: Usuário que é o proprietário do processo 102 | 3. **PR**: Prioridade do processo 103 | 4. **NI**: O valor *nice* 104 | 5. **VIRT**: Memória virtual usada pelo processo 105 | 6. **RES**: Memória física usada no processo 106 | 7. **SHR**: Memória compartilhada do processo 107 | 8. **S**: Indica o status do processo: `S = sleep`, `R = running`, `Z = zombie`, `D = uninterruptible`, `T = stopped` 108 | 9. **%CPU**: O percentual de CPU usado por esse processo 109 | 10. **%MEM**: Porcentagem de RAM usada por esse processo 110 | 11. **TIME+**: Tempo total de atividade deste processo 111 | 12. **COMMAND**: Nome do processo 112 | 113 | Também podemos especificar um **ID do processo** se desejarmos apenas controlar certos processos específicos: 114 | 115 | ```bash 116 | top -p 1 117 | ``` 118 | 119 | ## Tipos de Processos 120 | 121 | Existem fundamentalmente dois tipos de processos no Linux: 122 | 123 | - **Foreground processes**: Também chamados de processos interativos, são inicializados e controlados por meio de uma sessão do terminal. Em outras palavras, deve haver um usuário conectado ao sistema para iniciar esses processos; eles não foram iniciados automaticamente como parte das funções/serviços do sistema. 124 | - **Background processes**: Também chamados de processos não-interativos/automáticos, são processos não conectados a um terminal; eles não esperam nenhum *input* do usuário. 125 | 126 | ### Daemons 127 | 128 | [Daemons](https://en.wikipedia.org/wiki/Daemon_(computing)) são tipos especiais de processos em segundo plano que iniciam na inicialização do sistema e continuam funcionando para sempre como um serviço, eles não morrem. Eles são iniciados como tarefas do sistema (executadas como serviços), espontaneamente. No entanto, eles podem ser controlados por um usuário através do [processo init](https://en.wikipedia.org/wiki/Init). 129 | 130 | ### Criação de Processos no Linux 131 | 132 | Normalmente, um novo processo é criado quando um processo existente faz uma cópia exata de si mesmo na memória. O processo filho terá o mesmo ambiente que seu pai, mas apenas o número de identificação(ID) do processo é diferente. 133 | 134 | Existem duas maneiras convencionais usadas para criar um novo processo no Linux: 135 | 136 | - Usando a função **system()** - esse método é relativamente simples, no entanto, é ineficiente e possui riscos de segurança significativos. 137 | - Usando as funções **fork()** e **exec()** - técnica um pouco avançada, mas que oferece maior flexibilidade, velocidade e segurança. 138 | 139 | ### Identificando Processos no Linux 140 | 141 | Como o Linux é um sistema multiusuário, o que significa que diferentes usuários podem executar vários programas no sistema, cada instância em execução de um programa deve ser identificada exclusivamente pelo kernel. 142 | 143 | Um programa é identificado pelo seu ID do processo(**PID**) e pelo ID do processo pai(**PPID**). Sendo assim, os processos podem ser categorizados em: 144 | 145 | - **Parent processes**: esses são processos que criam outros processos durante o tempo de execução. 146 | - **Child processes**: esses processos são criados por outros processos durante o tempo de execução. 147 | 148 | ### O Processo Init 149 | 150 | O processo **init** é a mãe (ou pai) de todos os processos no sistema; é o primeiro programa executado quando o sistema Linux é inicializado; ele gerencia todos os outros processos no sistema. Ele é iniciado pelo próprio kernel, portanto, em princípio, ele não possui um processo pai. 151 | 152 | O processo **init** sempre tem o **ID** do processo **1**. Ele funciona como um pai adotivo para todos os processos órfãos. 153 | 154 | Podemos usar o comando **pidof** para encontrar o ID de um processo, por exemplo: 155 | 156 | ```bash 157 | pidof top 158 | pidof chrome 159 | pidof bash 160 | pidof apache2 161 | ``` 162 | 163 | Para localizarmos o ID do processo e o ID do processo pai da **shell atual**, podemos executar: 164 | 165 | ```bash 166 | echo $$ 167 | echo $PPID 168 | ``` 169 | 170 | ### Controlando Processos 171 | 172 | Existem diversos comandos que podem ser usados para controlar processos. São eles, por exemplo: 173 | 174 | - **ps**: lista os processos em execução no sistema 175 | - **kill**: envia um sinal para um ou mais processos (geralmente para "matar" um processo) 176 | - **jobs**: uma maneira alternativa de listar seus próprios processos 177 | - **bg**: coloca um processo em *background*/segundo plano 178 | - **fg**: colocar um processo em *foreground*/primeiro plano 179 | 180 | A maioria (se não todos) dos programas gráficos pode ser iniciada na linha de comando, podemos por exemplo iniciliazar o programa **GIMP** através do seguindo comando: 181 | 182 | ```bash 183 | gimp 184 | ``` 185 | 186 | Observe que seu prompt não reapareceu após o lançamento do programa **GIMP**. O shell está aguardando a conclusão do programa antes que o controle retorne a você. Se você fechar a janela do GIMP, o programa GIMP será encerrado e o prompt retornará. 187 | 188 | #### Colocando um Programa em Background 189 | 190 | Agora lançaremos o programa **GIMP** novamente, mas desta vez o colocaremos em segundo plano/*background* para que o prompt retorne. Para fazer isso, executamos o **GIMP** assim: 191 | 192 | ```bash 193 | gimp & 194 | ``` 195 | 196 | Nesse caso, o prompt retornou porque o processo foi colocado em segundo plano. 197 | 198 | Imagine então que você esqueceu de usar o símbolo "**&**" para colocar o programa em segundo plano. Você pode digitar `Ctrl + Z` e o processo será suspenso. O processo ainda existe, mas está ocioso. Para retomar o processo em segundo plano, digite o comando **bg**(abreviação de background). 199 | 200 | ```bash 201 | gimp 202 | CTRL + Z 203 | bg # [2]+ gimp & 204 | ``` 205 | 206 | #### Listando Processos 207 | 208 | Agora que temos um processo em segundo plano, seria útil exibir uma lista dos processos que lançamos. Para fazer isso, podemos usar o comando **jobs** ou o comando **ps** que é mais poderoso. 209 | 210 | ```bash 211 | jobs 212 | ps 213 | ``` 214 | 215 | #### Assassinando Processos 216 | 217 | Uma maneira fundamental de controlar processos no Linux é enviando sinais para eles. Existem vários sinais que você pode enviar para um processo, para visualizar todos os sinais possíveis que podemos utilizar, digite o seguinte comando: 218 | 219 | ```bash 220 | kill -L 221 | ``` 222 | 223 | A maioria dos sinais é para uso interno do sistema ou para programadores quando eles escrevem código. A seguir, apresentamos sinais úteis para um usuário do sistema: 224 | 225 | - **SIGHUP 1**: enviado para um processo quando seu terminal de controle está fechado. 226 | - **SIGINT 2**: enviado a um processo pelo seu terminal de controle quando um usuário interrompe o processo pressionando `Ctrl + C`. 227 | - **SIGQUIT 3**: enviado para um processo se o usuário enviar um sinal de saída/quit `Ctrl + D`. 228 | - **SIGKILL 9**: este sinal finaliza imediatamente (mata) um processo e o processo não realiza nenhuma operação de limpeza. 229 | - **SIGTERM 15**: este é um sinal de encerramento do programa (o comando **kill** enviará ele por padrão). 230 | - **SIGTSTP 20**: enviado a um processo pelo seu terminal de controle para solicitar que ele pare (parada do terminal); iniciado pelo usuário pressionando `Ctrl + Z`. 231 | 232 | Imagine agora que temos um programa que não responde; Como podemos resolver este problema? O comando **kill** pode nos ajudar. 233 | 234 | Faremos um experimento com o programa **GIMP**. Primeiro, precisamos identificar o processo que desejamos matar. Podemos usar **jobs** ou **ps** para esta tarefa. Caso utilizemos **jobs**, receberemos como retorno um número de trabalho. Já no **ps**, recebemos um ID do processo(PID). 235 | 236 | **jobs**: 237 | 238 | ```bash 239 | gimp & # [2] 2495 240 | jobs 241 | # [1]+ Parado top 242 | # [2]- Executando gimp & 243 | kill %2 244 | ``` 245 | 246 | **ps**: 247 | 248 | ```bash 249 | gimp & # [2] 2585 250 | ps 251 | # PID TTY TIME CMD 252 | # 2585 pts/0 00:00:01 gimp 253 | # 2593 pts/0 00:00:00 script-fu 254 | # 2598 pts/0 00:00:00 ps 255 | # 4006 pts/0 00:00:00 bash 256 | # 29881 pts/0 00:00:12 top 257 | kill 2585 258 | ``` 259 | 260 | #### Checando Principais Processos 261 | 262 | Para verificarmos os principais processos ordenados por uso de RAM ou CPU no Linux podemos usar novamente o comando **ps**, que mostrará a lista dos principais processos ordenados pelo uso da RAM e da CPU na forma descendente (remova o [pipeline](https://en.wikipedia.org/wiki/Pipeline_(Unix)) e **head** se quiser ver a lista completa). 263 | 264 | **Ordenando por Memória**: 265 | 266 | ```bash 267 | ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%mem | head 268 | ``` 269 | 270 | **Ordenando por CPU**: 271 | 272 | ```bash 273 | ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%mem | head 274 | ``` 275 | 276 | ## Introdução ao SystemD 277 | 278 | O **systemd** é um pacote de software que fornece uma variedade de componentes de sistema para sistemas operacionais Linux. 279 | 280 | Seu principal objetivo é unificar a configuração e o comportamento do serviço nas distribuições Linux. O principal componente do systemd é um "gerenciador de sistemas e serviços" - um sistema init usado para inicializar o [espaço do usuário](https://en.wikipedia.org/wiki/User_space) e gerenciar [processos do usuário](https://en.wikipedia.org/wiki/Process_(computing)). Ele também fornece substituições para vários [daemons](https://en.wikipedia.org/wiki/Daemon_(computing)) e utilitários, incluindo gerenciamento de dispositivos, gerenciamento de login, gerenciamento de conexões de rede e log de eventos. 281 | 282 | Systemd é controlado pelo utilitário **systemctl**, a tabela a seguir apresenta os comandos que podemos utilizar com ele: 283 | 284 | | Comando systemctl | Descrição | 285 | |---|---| 286 | | systemctl start name | Inicia name (onde name é um serviço) | 287 | | systemctl stop name | Pára name | 288 | | systemctl try-restart name | Reinicia name (se já estiver executando) | 289 | | systemctl restart name | Reinicia name | 290 | | systemctl reload name | Recarrega a configuração para name | 291 | | systemctl status name | Apresenta o status atual de name | 292 | | systemctl | Exibe o status de todos os serviços atuais | 293 | | systemctl enable name | Ativa name para executar na inicialização, conforme especificado no arquivo da unidade (o arquivo para o qual o link simbólico aponta). O processo de ativar ou desativar um serviço para iniciar automaticamente na inicialização consiste em adicionar ou remover links simbólicos dentro do diretório `/etc/systemd/system` | 294 | | systemctl disable name | Desativa name para execução na inicialização, conforme especificado no arquivo da unidade (o arquivo para o qual o link simbólico aponta) | 295 | | systemctl is-enabled name | Verifique se name (um serviço específico) está ativado no momento | 296 | | systemctl –type=service | Exibe todos os serviços e informa se eles estão ativados ou desativados | 297 | | systemctl poweroff | Desliga a máquina (halt) | 298 | | systemctl reboot | Reinicia o sistema | 299 | 300 | Por exemplo: 301 | 302 | ```bash 303 | systemctl status apache2 304 | systemctl restart mysql 305 | ``` 306 | 307 | ## Rastreando Processos com htop 308 | 309 | O [htop](https://hisham.hm/htop/) é um *[system-monitor](https://en.wikipedia.org/wiki/System_monitor)*, visualizador de processos e gerenciador de processos. 310 | 311 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/htop.png) 312 | 313 | Ele foi desenvolvido como uma alternativa ao programa **top** do Unix. Ele mostra uma lista atualizada com frequência dos processos em execução no computador, normalmente ordenadas pela quantidade de uso da CPU. Ao contrário do top, o [htop](https://github.com/hishamhm/htop) fornece uma lista completa dos processos em execução, em vez dos principais processos que consomem recursos. O htop usa cores e fornece informações visuais sobre o status do processador, da troca e da memória. O htop também pode exibir os processos como uma árvore. 314 | 315 | ## Sumário 316 | 317 | - Qualquer programa em execução ou um comando fornecido a um sistema Linux é chamado de processo 318 | - Um processo pode ser executado em primeiro plano/*foreground* ou em segundo plano/*background* 319 | - O índice de prioridade de um processo é chamado de **Nice** no Linux. Seu valor padrão é 0 e pode variar entre 20 e -19 320 | - Quanto menor o índice Nice, maior seria a prioridade dada a essa tarefa 321 | 322 | ### Comandos Importantes 323 | 324 | | Comando | Descrição | 325 | |---|---| 326 | | bg | Para enviar um processo para o segundo plano | 327 | | fg | Para executar um processo parado em primeiro plano | 328 | | top | Detalhes sobre todos os processos ativos | 329 | | ps | Fornece o status dos processos em execução para um usuário | 330 | | ps PID | Fornece o status de um processo específico | 331 | | pidof | Fornece o ID do processo(PID) | 332 | | kill PID | Mata um processo de ID especificado | 333 | | nice | Inicia um processo com uma determinada prioridade | 334 | | renice | Altera a prioridade de um processo já em execução | -------------------------------------------------------------------------------- /Conteúdo/GNUnixLinux.md: -------------------------------------------------------------------------------- 1 | # GNU, Unix & Linux 2 | 3 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/GnUnixLinux.png) 4 | 5 | Para compreendermos como o **[Linux](https://en.wikipedia.org/wiki/Linux)** surgiu, devemos retornar ao início de 1969, quando [Ken Thompson](https://en.wikipedia.org/wiki/Ken_Thompson) e [Dennis Ritchie](https://en.wikipedia.org/wiki/Dennis_Ritchie), do [Bell Laboratories](https://en.wikipedia.org/wiki/Bell_Labs), desenvolveram o sistema operacional [Unix](https://en.wikipedia.org/wiki/Unix). Posteriormente, foi reescrito em [C](https://en.wikipedia.org/wiki/C_(programming_language)) para torná-lo mais portátil e, eventualmente, se tornou um sistema operacional amplamente utilizado. 6 | 7 | ## Unix 8 | 9 | Unix é uma família de sistemas operacionais de computador [multitarefa](https://en.wikipedia.org/wiki/Computer_multitasking) e [multiusuário](https://en.wikipedia.org/wiki/Multiuser) que derivam do AT&T Unix original. 10 | 11 | Inicialmente planejado para uso dentro do [Sistema Bell](https://en.wikipedia.org/wiki/Bell_System), a AT&T licenciou o Unix para terceiros no final dos anos 1970, levando a uma diversidade de variantes Unix acadêmicas e comerciais de fornecedores, incluindo Universidade da Califórnia, Berkeley (BSD), Microsoft (Xenix), Sun Microsystems (SunOS / Solaris), HP / HPE (HP-UX) e IBM (AIX). No início dos anos 1990, a AT&T vendeu seus direitos no Unix para a Novell, que então vendeu seu negócio Unix para a Santa Cruz Operation (SCO) em 1995. A marca Unix passou para o The Open Group, um consórcio neutro da indústria fundado em 1996, que permite o uso da marca para sistemas operacionais certificados que estejam em conformidade com a [Single Unix Specification](https://en.wikipedia.org/wiki/Single_UNIX_Specification) (SUS). No entanto, a Novell continua detendo os direitos autorais do Unix. 12 | 13 | Os sistemas Unix são caracterizados por um design modular que às vezes é chamado de "filosofia Unix". De acordo com essa filosofia, o sistema operacional deve fornecer um conjunto de ferramentas simples, cada uma das quais desempenhando uma função limitada e bem definida. Um sistema de arquivos unificado (o sistema de arquivos Unix) e um mecanismo de comunicação entre processos conhecido como "**pipes**" servem como os principais meios de comunicação, e um shell scripting e linguagem de comando (o shell Unix) é usado para combinar as ferramentas para executar fluxos de trabalho complexos. 14 | 15 | O Unix se diferencia de seus predecessores como o primeiro sistema operacional **portátil**: quase todo o sistema operacional é escrito na linguagem de programação C, o que permite que o Unix opere em várias plataformas. 16 | 17 | No início, o Unix não foi projetado para ser portátil ou para multitarefa. Mais tarde, o Unix gradualmente ganhou portabilidade, capacidades multitarefa e multiusuário em uma configuração *time-sharing*. Os sistemas Unix são caracterizados por vários conceitos: o uso de texto simples para armazenamento de dados; um sistema de arquivos hierárquico; tratar dispositivos e certos tipos de [inter-process communication](https://en.wikipedia.org/wiki/Inter-process_communication) (IPC) como arquivos; e o uso de um grande número de ferramentas de software, pequenos programas que podem ser agrupados por meio de um [interpretador de linha de comando](https://en.wikipedia.org/wiki/Command-line_interpreter) usando **pipes**, em vez de usar um único programa monolítico que inclui todas as mesmas funcionalidades. Esses conceitos são conhecidos coletivamente como "[filosofia Unix](https://en.wikipedia.org/wiki/Unix_philosophy)". Brian Kernighan e Rob Pike resumem isso em [The Unix Programming Environment](https://en.wikipedia.org/wiki/The_Unix_Programming_Environment) como "a ideia de que o poder de um sistema vem mais das relações entre os programas do que dos próprios programas". 18 | 19 | No início dos anos 1980, os usuários começaram a ver o Unix como um sistema operacional universal em potencial, adequado para computadores de todos os tamanhos. O ambiente Unix e o modelo de programa [cliente-servidor](https://en.wikipedia.org/wiki/Client%E2%80%93server) foram elementos essenciais no desenvolvimento da Internet e na reformulação da computação centrada em redes, em vez de em computadores individuais. 20 | 21 | Tanto o Unix quanto a linguagem de programação C foram desenvolvidos pela AT&T e distribuídos para instituições governamentais e acadêmicas, o que levou ambos a serem portados para uma variedade maior de famílias de máquinas do que qualquer outro sistema operacional. 22 | 23 | O sistema operacional Unix consiste em muitas bibliotecas e utilitários junto com o programa de controle mestre, o **[kernel](https://en.wikipedia.org/wiki/Kernel_(operating_system))**. O kernel fornece serviços para iniciar e parar programas, lida com o sistema de arquivos e outras tarefas comuns de "baixo nível" que a maioria dos programas compartilha, ele também agenda o acesso para evitar conflitos quando os programas tentam acessar o mesmo recurso ou dispositivo simultaneamente. Para mediar esse acesso, o kernel tem direitos especiais, refletidos na distinção entre o **espaço do kernel** e o **espaço do usuário**, sendo o último um domínio prioritário onde a maioria dos programas de aplicativos opera. 24 | 25 | Em 1983, **[Richard Stallman](https://en.wikipedia.org/wiki/Richard_Stallman)** anunciou o projeto GNU (abreviação de "*GNU's Not Unix*"), um esforço ambicioso para criar um sistema de software livre semelhante ao Unix; "livre" no sentido de que todos que receberem uma cópia serão livres para usá-la, estudar, modificar e redistribuí-la. O próprio projeto de desenvolvimento de kernel do projeto GNU chamado de [GNU Hurd](https://en.wikipedia.org/wiki/GNU_Hurd), ainda não havia produzido um kernel funcional, mas em 1991 **[Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds)** lançou o [kernel Linux](https://en.wikipedia.org/wiki/Linux_kernel) como software livre sob a [GNU General Public License](https://en.wikipedia.org/wiki/GNU_General_Public_License). Além de seu uso no sistema operacional GNU, muitos pacotes GNU - como o [GNU Compiler Collection](https://en.wikipedia.org/wiki/GNU_Compiler_Collection) (e o resto da [GNU toolchain](https://en.wikipedia.org/wiki/GNU_toolchain)), a [biblioteca GNU C](https://en.wikipedia.org/wiki/Glibc) e os [GNU core utilities](https://en.wikipedia.org/wiki/Coreutils) - passaram a desempenhar papéis centrais em outros sistemas Unix gratuitos também. 26 | 27 | As [distribuições Linux](https://en.wikipedia.org/wiki/Linux_distribution), que consistem do kernel Linux e grandes coleções de software compatível, tornaram-se populares tanto para usuários individuais quanto para empresas. Distribuições populares incluem Red Hat Enterprise Linux, Fedora, SUSE Linux Enterprise, openSUSE, Debian GNU/Linux, Ubuntu, Linux Mint, Mandriva Linux, Slackware Linux, Arch Linux e Gentoo. 28 | 29 | ## Linux 30 | 31 | Linux é uma família de sistemas operacionais de código aberto do tipo Unix baseados no [kernel Linux](https://en.wikipedia.org/wiki/Linux_kernel), um kernel de sistema operacional lançado pela primeira vez em 17 de setembro de 1991, por Linus Torvalds. O Linux é normalmente empacotado em uma distribuição Linux. 32 | 33 | As distribuições incluem o kernel Linux, softwares e bibliotecas de suporte de sistema, muitos dos quais são fornecidos pelo Projeto GNU. Muitas distribuições Linux usam a palavra "Linux" em seus nomes, mas a Free Software Foundation usa o nome GNU/Linux para enfatizar a importância do software GNU. 34 | 35 | ### Linux Design 36 | 37 | Muitos desenvolvedores *open-source* concordam que o kernel do Linux não foi projetado, ao invés disso, ele evoluiu por meio da Seleção Natural. Torvalds considera que embora o design do Unix tenha servido como um andaime, "o Linux cresceu com muitas mutações - e como as mutações eram menos do que aleatórias, elas eram mais rápidas e mais direcionadas do que as partículas alfa no DNA". 38 | 39 | Raymond considera os aspectos revolucionários do Linux como sociais, não técnicos, antes que o software complexo do Linux fosse projetado cuidadosamente por pequenos grupos, mas o Linux evoluiu de uma maneira completamente diferente. Desde quase o início, foi casualmente hackeado por um grande número de voluntários coordenando apenas através da Internet. A qualidade era mantida não por padrões rígidos ou autocracia, mas pela estratégia ingenuamente simples de lançar todas as semanas e obter feedback de centenas de usuários em poucos dias, criando uma espécie de seleção darwiniana rápida nas mutações introduzidas pelos desenvolvedores. 40 | 41 | Um sistema baseado em Linux é um sistema operacional modular semelhante ao Unix, derivando muito de seu design básico de princípios estabelecidos no Unix durante os anos 1970 e 1980. Tal sistema usa um kernel monolítico, o kernel Linux, que lida com controle de processos, rede, acesso a periféricos e sistemas de arquivos. Os drivers de dispositivo são integrados diretamente ao kernel ou adicionados como módulos que são carregados enquanto o sistema está em execução. 42 | 43 | O GNU [userland](https://en.wikipedia.org/wiki/Userland_(computing)) é uma parte fundamental da maioria dos sistemas baseados no kernel Linux, com o Android sendo a exceção notável. A implementação do projeto da biblioteca C funciona como um wrapper para as chamadas do sistema do kernel Linux necessárias para a interface kernel-userspace, a [toolchain](https://en.wikipedia.org/wiki/GNU_toolchain) é uma ampla coleção de ferramentas de programação vitais para o desenvolvimento do Linux (incluindo os compiladores usados para construir o kernel do Linux em si), e os [coreutils](https://en.wikipedia.org/wiki/GNU_Core_Utilities) implementam muitas ferramentas básicas do Unix. O projeto também desenvolve o [Bash](https://en.wikipedia.org/wiki/Bash_(shell)), um shell [CLI](https://en.wikipedia.org/wiki/Command-line_interface) popular. A interface gráfica do usuário (ou GUI) usada pela maioria dos sistemas Linux é construída em cima de uma implementação do Sistema X Window. Mais recentemente, a comunidade Linux busca avançar para o Wayland como o novo protocolo de servidor de exibição no lugar do X11. Muitos outros projetos de software *open-source* contribuem para os sistemas Linux. 44 | 45 | A figura a seguir apresenta várias camadas dentro do Linux, também mostrando separação entre o [userland](https://en.wikipedia.org/wiki/User_space) e o [kernel space](https://en.wikipedia.org/wiki/Kernel_space): 46 | 47 | ![img](https://raw.githubusercontent.com/the-akira/Comandos-Bash/master/Imagens/linux_layers.png) 48 | 49 | Os componentes instalados de um sistema Linux incluem o seguinte: 50 | 51 | - Um [bootloader](https://en.wikipedia.org/wiki/Bootloader), por exemplo GNU GRUB, LILO, SYSLINUX ou Gummiboot é um programa que carrega o kernel do Linux na [memória principal](https://en.wikipedia.org/wiki/Main_memory) do computador, sendo executado pelo computador ao ser ligado e após a inicialização do firmware ser feita. 52 | - Um programa init, como o [sysvinit](https://en.wikipedia.org/wiki/Sysvinit) tradicional e o mais recente [systemd](https://en.wikipedia.org/wiki/Systemd), [OpenRC](https://en.wikipedia.org/wiki/OpenRC) e [Upstart](https://en.wikipedia.org/wiki/Upstart_(software)). Este é o primeiro processo lançado pelo kernel Linux e está na raiz da árvore de processos: em outros termos, todos os processos são iniciados por meio do init. Ele inicia processos como serviços de sistema e prompts de login (seja gráfico ou em modo de terminal). 53 | - Bibliotecas de software, que contêm código que pode ser usado por processos em execução. Em sistemas Linux que usam arquivos executáveis no formato ELF, o [dynamic linker](https://en.wikipedia.org/wiki/Dynamic_linker) que gerencia o uso de bibliotecas dinâmicas é conhecido como [ld-linux.so](https://linux.die.net/man/8/ld-linux.so). Se o sistema estiver configurado para o próprio usuário compilar o software, os [arquivos header](https://en.wikipedia.org/wiki/Header_file) também serão incluídos para descrever a interface das bibliotecas instaladas. Além da biblioteca de software mais comumente usada em sistemas Linux, a [GNU C Library](https://en.wikipedia.org/wiki/GNU_C_Library) (glibc), existem inúmeras outras bibliotecas, como [SDL](https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer) e [Mesa](https://en.wikipedia.org/wiki/Mesa_(computer_graphics)). 54 | - Comandos Unix básicos, com GNU coreutils sendo a implementação padrão. Existem alternativas para sistemas embarcados, como o copyleft BusyBox e o Toybox licenciado por BSD. 55 | - Os kits de ferramentas de widget são as bibliotecas usadas para construir interfaces gráficas com o usuário (GUIs) para aplicativos de software. Numerosos kits de ferramentas de widget estão disponíveis, incluindo GTK e Clutter desenvolvidos pelo projeto GNOME, Qt desenvolvido pelo Projeto Qt. 56 | - Um [sistema de gerenciamento de pacotes](https://en.wikipedia.org/wiki/Package_manager), como dpkg e RPM. Alternativamente, os pacotes podem ser compilados a partir de *source tarballs* ou binários. 57 | - Programas de interface do usuário, como shells de comando ou *windowing environments*. 58 | 59 | ### Interface de Usuário 60 | 61 | A interface do usuário, também conhecida como shell, é uma [interface de linha de comando](https://en.wikipedia.org/wiki/Command-line_interface) (CLI), uma [interface gráfica do usuário](https://en.wikipedia.org/wiki/Graphical_user_interface) (GUI) ou controles anexados ao hardware associado, o que é comum para [sistemas embarcados](https://en.wikipedia.org/wiki/Embedded_systems). Para sistemas de desktop, a interface de usuário padrão geralmente é gráfica, embora a CLI esteja comumente disponível por meio de janelas do emulador de terminal ou em um console virtual separado. 62 | 63 | Os shells CLI são interfaces de usuário baseadas em texto, que usam texto para *input* e *output*. O shell dominante usado no Linux é o [Bourne-Again Shell](https://en.wikipedia.org/wiki/Bourne-Again_Shell) (bash), originalmente desenvolvido para o projeto GNU. A maioria dos componentes Linux de baixo nível, incluindo várias partes do [userland](https://en.wikipedia.org/wiki/Userland_(computing)), usam a CLI exclusivamente. O CLI é particularmente adequado para automação de tarefas repetitivas ou atrasadas e fornece [inter-process communication](https://en.wikipedia.org/wiki/Inter-process_communication) muito simples. 64 | 65 | ### Programação no Linux 66 | 67 | A maioria das linguagens de programação suportam Linux diretamente, as ferramentas de desenvolvimento originais usadas para construir aplicativos Linux e programas de sistema operacional são encontradas na [GNU toolchain](https://en.wikipedia.org/wiki/GNU_toolchain), que inclui a GNU Compiler Collection (GCC) e o GNU Build System. Entre outros, o GCC fornece compiladores para Ada, C, C ++, Go e Fortran. Muitas linguagens de programação têm uma implementação de referência *cross-platform* que suporta Linux, por exemplo PHP, Perl, Ruby, Python, Java, Go, Rust e Haskell. Lançado pela primeira vez em 2003, o projeto LLVM fornece um compilador de código aberto *cross-platform* alternativo para muitas linguagens. 68 | 69 | O Linux também inclui linguagens de programação tradicionais de propósito específico voltadas para [scripting](https://en.wikipedia.org/wiki/Script_(computing)), processamento de texto e configuração e gerenciamento de sistema em geral. As distribuições Linux suportam [scripts de shell](https://en.wikipedia.org/wiki/Shell_scripts), [awk](https://en.wikipedia.org/wiki/Awk), [sed](https://en.wikipedia.org/wiki/Sed) e [make](https://en.wikipedia.org/wiki/Make_(software)). Muitos programas também possuem uma linguagem de programação incorporada para suportar a configuração ou a programação deles próprios. Por exemplo, [expressões regulares](https://en.wikipedia.org/wiki/Regular_expressions) são suportadas em programas como [grep](https://en.wikipedia.org/wiki/Grep) e [locate](https://en.wikipedia.org/wiki/Locate_(Unix)), e também o editor de texto avançado [GNU Emacs](https://en.wikipedia.org/wiki/GNU_Emacs) é construído em torno de um interpretador [Lisp](https://en.wikipedia.org/wiki/Emacs_Lisp) de propósito geral. 70 | 71 | GNOME e KDE são ambientes de desktop populares e fornecem uma estrutura para o desenvolvimento de aplicativos. Esses projetos são baseados nos kits de ferramentas de widget [GTK](https://en.wikipedia.org/wiki/GTK) e [Qt](https://en.wikipedia.org/wiki/Qt_(toolkit)), respectivamente. Ambos suportam uma ampla variedade de idiomas. Existem vários [ambientes de desenvolvimento integrados](https://en.wikipedia.org/wiki/Integrated_development_environment) disponíveis, incluindo **Anjuta**, **Code::Blocks**, **CodeLite**, **Eclipse**, **Geany**, **ActiveState Komodo**, **KDevelop**, **Lazarus**, **MonoDevelop**, **NetBeans** e **Qt Creator**, enquanto os editores **Vim**, **nano** e **Emacs** de longa data também permanecem popular. 72 | 73 | ### Suporte de Hardware 74 | 75 | O **kernel Linux** é um kernel de sistema operacional amplamente portado, disponível para dispositivos que variam de telefones móveis a supercomputadores; ele roda em uma ampla variedade de arquiteturas de computador, incluindo o iPAQ portátil baseado em ARM e os mainframes IBM System z9 ou System z10. Distribuições especializadas e *kernel forks* existem para arquiteturas menos convencionais, por exemplo, o fork do kernel ELKS pode ser executado em microprocessadores Intel 8086 ou Intel 80286 de 16 bits, enquanto o fork do kernel µClinux pode ser executado em sistemas sem uma unidade de gerenciamento de memória. O kernel também roda em arquiteturas que pretendiam usar apenas um sistema operacional criado pelo fabricante, como computadores Macintosh (com processadores PowerPC e Intel), PDAs, consoles de videogame, reprodutores de música portáteis e telefones celulares. 76 | 77 | ### Linux Kernel 78 | 79 | O sistema operacional Linux pode ser organizado em três níveis diferentes de abstração: 80 | 81 | - O nível mais básico é o hardware, que inclui a CPU, memória, discos rígidos, portas de rede, etc. A camada física que realmente calcula o que nossa máquina está fazendo. 82 | 83 | - O próximo nível é o kernel, que lida com gerenciamento de processos e memória, comunicação de dispositivos, chamadas de sistema, configura nosso sistema de arquivos, etc. O trabalho do kernel é conversar com o hardware para ter certeza de que ele faz o que queremos que nossos processos façam. 84 | 85 | - E o nível com o qual estamos familiarizados é o **user space**, que inclui o shell, os programas que executamos, os gráficos, etc. 86 | 87 | #### Níveis de Privilégio 88 | 89 | Por que temos diferentes camadas de abstração para o **user space** e o kernel? 90 | 91 | Há um importante motivo pelo qual essas duas camadas existem separadamente. Ambos operam em modos diferentes, o kernel opera no **modo kernel** e o user space opera no **modo usuário**. 92 | 93 | No modo kernel, o kernel tem acesso completo ao hardware, ele controla tudo. No modo usuário, há uma quantidade muito pequena de memória segura e CPU que você tem permissão para acessar. Basicamente, quando queremos fazer algo que envolva hardware, ler dados de nossos discos, gravar dados em nossos discos, controlar nossa rede, tudo é feito em modo kernel. 94 | 95 | Esses diferentes modos são chamados de níveis de privilégio (apropriadamente nomeados de acordo com os níveis de privilégio que você obtém). 96 | 97 | Existem dois níveis ou modos principais em uma arquitetura de computador x86. O ring #3 é o privilégio no qual os aplicativos do modo de usuário são executados, o ring #0 é o privilégio no qual o kernel é executado. O ring #0 pode executar qualquer instrução do sistema e recebe total confiança. 98 | 99 | Como então podemos gravar qualquer coisa em nosso hardware? Não estaremos sempre em um modo diferente do kernel? 100 | 101 | A resposta é com **system calls**, essas chamadas de sistema nos permitem executar uma instrução privilegiada no modo kernel e, em seguida, voltar ao modo de usuário. 102 | 103 | #### System Calls 104 | 105 | System calls (syscall) fornecem aos processos de espaço do usuário uma maneira de solicitar que o kernel faça algo por nós. O kernel disponibiliza certos serviços por meio da *system call API*. Esses serviços nos permitem ler ou gravar em um arquivo, modificar o uso de memória, modificar nossa rede, etc. A quantidade de serviços é fixa, então não podemos adicionar system calls, nosso sistema já tem uma tabela de qual system calls existem e cada system call possui um ID exclusivo. 106 | 107 | Podemos ver as system calls que um processo faz com o comando **strace**. Ele é útil para depurar como um programa é executado. 108 | 109 | ```bash 110 | strace cat 111 | ``` 112 | 113 | #### Instalação do Kernel 114 | 115 | Podemos instalar vários kernels em nosso sistema, no menu GRUB podemos escolher em qual kernel inicializar. 116 | 117 | Para ver qual versão do kernel temos em nosso sistema podemos usar o comando: 118 | 119 | ```bash 120 | uname -r 121 | ``` 122 | 123 | É possível instalar o kernel do Linux de diferentes maneiras, podemos por exemplo baixar o *source package* e compilar ele ou podemos instalá-lo usando ferramentas de gerenciamento de pacote. 124 | 125 | ```bash 126 | sudo apt install linux-generic-lts-vivid 127 | ``` 128 | 129 | E então reiniciamos no kernel que instalamos. Também será necessário instalar outros pacotes do linux, como linux-headers, linux-image-generic, etc). É possível também especificar o número da versão, nesse caso comando acima seria semelhante a: 130 | 131 | ```bash 132 | sudo apt install 3.19.0-43-generic 133 | ``` 134 | 135 | Alternativamente, se desejarmos apenas a versão atualizada do kernel, podemos usar dist-upgrade, ele executa atualizações para todos os pacotes em nosso sistema: 136 | 137 | ```bash 138 | sudo apt dist-upgrade 139 | ``` 140 | 141 | #### Localização do Kernel 142 | 143 | O que acontece quando instalamos um novo kernel? 144 | 145 | Ocorre que são adicionados alguns arquivos ao nosso sistema, esses arquivos geralmente são adicionados ao diretório `/boot`. 146 | 147 | Existem vários arquivos para diferentes versões do kernel, por exemplo: 148 | 149 | - **vmlinuz** - este é o kernel Linux real 150 | - **initrd** - é usado como um sistema de arquivos temporário, usado antes de carregar o kernel 151 | - **System.map** - tabela de pesquisa simbólica 152 | - **config** - definições de configuração do kernel, se você está compilando seu próprio kernel, você pode definir quais módulos podem ser carregados 153 | 154 | #### Módulos do Kernel 155 | 156 | O kernel é um pedaço de software monolítico, quando desejamos adicionar suporte para um novo tipo de teclado, não escrevemos este código diretamente no código do kernel. 157 | 158 | Módulos de kernel são pedaços de código que podem ser carregados e descarregados no kernel sob demanda. Eles nos permitem estender a funcionalidade do kernel sem realmente adicionar ao código do núcleo do kernel. Também podemos adicionar módulos e não ter que reiniciar o sistema (na maioria dos casos). 159 | 160 | Para vermos uma lista dos módulos carregados atualmente podemos executar o comando: 161 | 162 | ```bash 163 | lsmod 164 | ``` 165 | 166 | Para carregarmos um módulo: 167 | 168 | ```bash 169 | sudo modprobe bluetooth 170 | ``` 171 | 172 | O Modprobe tentar carregar o módulo de `/lib/modules/(versão do kernel)/kernel/drivers`. Módulos de kernel também podem ter dependências, modprobe carrega nossas dependências de módulo se eles ainda não estiverem carregados. 173 | 174 | Para remover um módulo: 175 | 176 | ```bash 177 | sudo modprobe -r bluetooth 178 | ``` 179 | 180 | Também podemos carregar módulos durante a inicialização do sistema, em vez de carregá-los temporariamente com o modprobe (que será descarregado quando você reiniciar). Basta modificar o diretório `/etc/modprobe.d` e adicionar um arquivo de configuração como: 181 | 182 | **configuracao.conf**: 183 | 184 | ``` 185 | options nome_modulo type=almond 186 | ``` 187 | 188 | Também podemos garantir que um módulo não carregue na inicialização adicionando um arquivo de configuração como: 189 | 190 | **configuracao.conf**: 191 | 192 | ``` 193 | blacklist nome_modulo 194 | ``` 195 | 196 | ### Processo de Boot do Linux 197 | 198 | O processo de inicialização (*boot process*) do Linux pode ser dividido em 4 etapas simples: 199 | 200 | **BIOS**: O BIOS (significa "*Basic Input/Output System*") inicializa o hardware e garante com um autoteste de inicialização (POST) que todo o hardware está pronto para funcionar. A principal tarefa do BIOS é carregar o bootloader. 201 | 202 | Existe outra maneira de inicializar seu sistema em vez de usar BIOS, que é com UEFI (significa "*Unified extensible firmware interface*"). O UEFI foi projetado para ser o sucessor do BIOS, a maioria do hardware que existe hoje vem com firmware UEFI integrado. As máquinas Macintosh têm usado a inicialização UEFI há anos. 203 | 204 | UEFI armazena todas as informações sobre a inicialização em um arquivo `.efi`. Este arquivo é armazenado em uma partição especial chamada partição do sistema EFI no hardware. Dentro desta partição ele conterá o bootloader. UEFI vem com muitas melhorias do firmware BIOS tradicional. 205 | 206 | **Bootloader**: O bootloader carrega o kernel na memória e então inicia o kernel com um conjunto de parâmetros do kernel. Um dos bootloaders mais comuns é o GRUB, que é um padrão Linux universal. 207 | 208 | As principais responsabilidades do bootloader são: 209 | 210 | - Inicializar um sistema operacional, ele também pode ser usado para inicializar em sistemas operacionais não Linux 211 | - Selecione um kernel para usar 212 | - Especifique os parâmetros do kernel 213 | 214 | Para encontrar o kernel o bootloader conta com os *kernel parameters*: 215 | 216 | - initrd - especifica a localização do disco RAM inicial 217 | - BOOT_IMAGE - onde a imagem do kernel está localizada 218 | - root - A localização do sistema de arquivos raiz, o kernel procura dentro desta localização para encontrar o init. Geralmente é representado por seu UUID ou pelo nome do dispositivo, como `/dev/sda1` 219 | ro - monta o sistema de arquivos como modo somente leitura. 220 | quiet - adicionado para que você não veja mensagens de exibição que estão acontecendo em segundo plano durante a inicialização. 221 | 222 | **Kernel**: Quando o kernel é carregado, ele inicializa imediatamente os dispositivos e a memória. A principal tarefa do kernel é carregar o processo init. 223 | 224 | **Init**: O processo init é o primeiro processo iniciado, init inicia e interrompe o processo de serviço essencial no sistema. Existem três implementações principais do init nas distribuições Linux. 225 | 226 | - **System V init (sysv)**: Este é o sistema init tradicional. Ele inicia e processa sequencialmente, com base em scripts de inicialização. O estado da máquina é denotado por níveis de execução, cada nível de execução inicia ou interrompe uma máquina de uma maneira diferente. 227 | 228 | - **Upstart**: Este é o init que você encontrará em instalações antigas do Ubuntu. O Upstart usa a ideia de jobs e eventos e funciona iniciando jobs que realizam determinadas ações em resposta a eventos. 229 | 230 | - **Systemd**: Este é o novo padrão para init, ele é orientado a objetivos. Basicamente, você tem uma meta que deseja atingir e o systemd tenta satisfazer as dependências da meta para concluí-la. 231 | 232 | ### Arquitetura Linux 233 | 234 | Linux é um [kernel monolítico](https://en.wikipedia.org/wiki/Monolithic_kernel) com um design modular (por exemplo, pode inserir e remover [LKMs](https://en.wikipedia.org/wiki/Loadable_kernel_module) em tempo de execução), suportando a maioria dos recursos antes disponíveis apenas em kernels de sistemas operacionais não livres e de código fechado: 235 | 236 | - [Concurrent computing](https://en.wikipedia.org/wiki/Concurrent_computing) e (com a disponibilidade de núcleos de CPU suficientes para tarefas que estão prontas para serem executadas) até mesmo [execução paralela verdadeira](https://en.wikipedia.org/wiki/Parallel_computing) de muitos processos ao mesmo tempo (cada um deles tendo um ou mais [threads de execução](https://en.wikipedia.org/wiki/Thread_(computing)). 237 | - Recursos configuráveis e políticas controláveis ​​em tempo de execução. O [Completely Fair Scheduler](https://en.wikipedia.org/wiki/Completely_Fair_Scheduler) (CFS) é o agendador padrão do Linux desde 2007 e usa uma [red-black tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree) que pode pesquisar, inserir e excluir informações do processo ([task_struct](https://en.wikipedia.org/wiki/Task_struct)) com complexidade de tempo `O(log n)`, onde n é o número de tarefas executáveis. 238 | - gerenciamento avançado de memória com memória virtual paginada. 239 | - *inter-process communications* e mecanismo de sincronização. 240 | - um sistema de arquivos virtual em cima de vários sistemas de arquivos concretos (ext4, Btrfs, XFS, JFS, FAT32 e muitos mais). 241 | - Virtualização no nível do sistema operacional (com Linux-VServer), paravirtualização e virtualização assistida por hardware (com KVM ou Xen). 242 | - mecanismos de segurança para controle de acesso discricionário e obrigatório (SELinux, AppArmor, POSIX ACLs e outros). 243 | - vários tipos de protocolos de comunicação em camadas (incluindo o [conjunto de protocolos da Internet](https://en.wikipedia.org/wiki/Internet_protocol_suite)). 244 | 245 | Drivers de dispositivo e extensões de kernel são executados no espaço do kernel (ring 0 em muitas arquiteturas de CPU), com acesso total ao hardware, embora algumas exceções sejam executadas no espaço do usuário, por exemplo, sistemas de arquivos baseados em FUSE CUSE. O sistema gráfico que a maioria das pessoas usa com o Linux não funciona dentro do kernel. Ao contrário dos kernels monolíticos padrão, os drivers de dispositivo são facilmente configurados como módulos e carregados ou descarregados enquanto o sistema está em execução e também podem ser antecipados sob certas condições para lidar com interrupções de hardware corretamente e para melhor suportar [multiprocessamento simétrico](https://en.wikipedia.org/wiki/Symmetric_multiprocessing). 246 | 247 | ### Material Anexo 248 | 249 | - [Unix vs Linux](https://www.youtube.com/watch?v=jowCUo_UGts) 250 | - [Mapa Interativo do Kernel Linux](https://makelinux.github.io/kernel/map/) 251 | - [Mainframes and the Unix Revolution](https://www.youtube.com/watch?v=-rPPqm44xLs) 252 | - [AT&T Archives: The UNIX Operating System](https://www.youtube.com/watch?v=tc4ROCJYbm0&t) -------------------------------------------------------------------------------- /Scripts/backup-08-15-2020.tar: -------------------------------------------------------------------------------- 1 | ./email.sh0000664000175000017500000000026313715716562011616 0ustar akiraakira#!/bin/bash 2 | recipient='gabrielfelippe90@gmail.com' 3 | subject='Desenvolvimento de Software' 4 | message='Vamos desenvolver um projeto juntos?' 5 | `mail -s $subject $recipient <<< $message` 6 | ./date_time.sh0000664000175000017500000000031313715705322012446 0ustar akiraakira#!/bin/bash 7 | 8 | ano=`date +%Y` 9 | mes=`date +%m` 10 | dia=`date +%d` 11 | hora=`date +%H` 12 | minuto=`date +%M` 13 | segundo=`date +%S` 14 | 15 | echo `date` 16 | echo "Data atual: $dia-$mes-$ano" 17 | echo "Horário atual: $hora:$minuto:$segundo"./root.sh0000664000175000017500000000017013716057102011474 0ustar akiraakira#!/bin/bash 18 | ROOT_UID=0 19 | 20 | if [ "$UID" -eq "$ROOT_UID" ] 21 | then 22 | echo "You are root." 23 | else 24 | echo "You are not root" 25 | fi 26 | exit 0./files/1.py0000644000175000017500000000000013716044004011754 0ustar akiraakira./files/5.py0000644000175000017500000000000013716044004011760 0ustar akiraakira./files/3.py0000644000175000017500000000000013716044004011756 0ustar akiraakira./files/editores.txt0000664000175000017500000000005613716044056013645 0ustar akiraakiraSublime Text 27 | Visual Studio Code 28 | Atom 29 | Vim 30 | Emacs./files/2.py0000644000175000017500000000000013716044004011755 0ustar akiraakira./files/0.py0000644000175000017500000000000013716044004011753 0ustar akiraakira./files/4.py0000644000175000017500000000000013716044004011757 0ustar akiraakira./create_dir.sh0000664000175000017500000000026413715651424012624 0ustar akiraakira#!/bin/bash 31 | 32 | echo -n "Informe o nome do diretório ->" 33 | read dir 34 | 35 | if [ -d "$dir" ] 36 | then 37 | echo "Diretório já existente" 38 | else 39 | `mkdir $dir` 40 | echo "Diretório criado com sucesso!" 41 | fi./file_existance.sh0000664000175000017500000000015713715703610013501 0ustar akiraakira#!/bin/bash 42 | 43 | filename=$1 44 | if [ -f "$filename" ]; then 45 | echo "Arquivo existe" 46 | else 47 | echo "Arquivo não existe" 48 | fi./functions.sh0000664000175000017500000000031013715643553012527 0ustar akiraakira#!/bin/bash 49 | 50 | function Quadrado() { 51 | echo -n "Informe um número -> " 52 | read x 53 | echo "$x² = $(( x**2 ))" 54 | } 55 | 56 | function Soma { 57 | (( x=$1+$2 )) 58 | echo "$1 + $2 = $x" 59 | } 60 | 61 | Quadrado 62 | soma=$(Soma 2 13) 63 | echo $soma./cut_substrings.sh0000664000175000017500000000015213715627121013572 0ustar akiraakira#!/bin/bash 64 | string="Coluna1 Coluna2 Coluna3" 65 | substring=$(echo $string | cut -d ' ' -f 1-3) 66 | echo $substring./input.sh0000664000175000017500000000015013715701166011653 0ustar akiraakira#!/bin/bash 67 | 68 | echo -n "Informe seu nome: " 69 | read nome 70 | 71 | echo "Você informou $nome com ${#nome} caracteres"./reading_files.sh0000664000175000017500000000021613716044113013303 0ustar akiraakira#!/bin/bash 72 | 73 | filename='files/editores.txt' 74 | n=1 75 | cat $filename | while read line || [[ -n $line ]] 76 | do 77 | echo "Linha $n -> $line" 78 | n=$((n+1)) 79 | done./system_update.sh0000664000175000017500000000026013716061333013400 0ustar akiraakira#!/bin/bash 80 | 81 | echo -e "\n$(date "+%d-%m-%Y --- %T") Iniciando Atualização\n" 82 | 83 | apt update 84 | apt upgrade 85 | 86 | apt autoremove 87 | apt autoclean 88 | 89 | echo -e "\n$(date "+%T") Script finalizado"./for.sh0000664000175000017500000000025213716061041011275 0ustar akiraakira#!/bin/bash 90 | 91 | for (( i=1; i<=13; i++ )) 92 | do 93 | echo -n "$i " 94 | done 95 | 96 | printf "\n" 97 | 98 | for i in $(ls) 99 | do 100 | echo "$i" 101 | done 102 | 103 | for i in {0..20..4} 104 | do 105 | printf "$i\t" 106 | done 107 | 108 | printf "\n"./string_concat.sh0000664000175000017500000000015013715701066013350 0ustar akiraakira#!/bin/bash 109 | 110 | sistema="Linux" 111 | linguagem="C" 112 | 113 | echo "O ${sistema} foi escrito com a linguagem ${linguagem}"./or.sh0000664000175000017500000000023013716061511011125 0ustar akiraakira#!/bin/bash 114 | 115 | echo -n "Escolha um número: " 116 | read n 117 | 118 | if [[ ( $n -eq 13 || $n -eq 27 ) ]] 119 | then 120 | echo "Número vencedor" 121 | else 122 | echo "Número incorreto!" 123 | fi./help.sh0000664000175000017500000000021713715621422011444 0ustar akiraakira#!/bin/bash 124 | 125 | for arg in "$@" 126 | do 127 | if [ "$arg" == "--help" ] || [ "$arg" == "-h" ] 128 | then 129 | echo "Argumento help ativado!" 130 | fi 131 | done./last_updated.sh0000664000175000017500000000005013715713530013162 0ustar akiraakirals -lrt | grep ^- | awk 'END{print $NF}'./sleep.sh0000664000175000017500000000014213715705433011626 0ustar akiraakira#!/bin/bash 132 | 133 | echo "Quanto tempo de espera?" 134 | read time 135 | sleep $time 136 | echo "Esperados $time segundos!"./backup.sh0000664000175000017500000000033213716071423011760 0ustar akiraakira#!/bin/bash 137 | 138 | backupfile=backup-$(date +%m-%d-%Y) 139 | archive=${1:-$backupfile} 140 | 141 | find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar" 142 | echo "Directory $PWD backed up in archive file \"$archive.tar.gz\"." 143 | exit 0./named_arguments.sh0000664000175000017500000000027313715700443013670 0ustar akiraakira#!/bin/bash 144 | 145 | for arg in "$@" 146 | do 147 | index=$(echo $arg | cut -f1 -d=) 148 | valor=$(echo $arg | cut -f2 -d=) 149 | case $index in 150 | X | x) x=$valor;; 151 | Y | y) y=$valor;; 152 | *) 153 | esac 154 | done 155 | ((z=x+y)) 156 | echo "$x+$y=$z"./files_directories.sh0000664000175000017500000000045513716056135014222 0ustar akiraakira#!/bin/bash 157 | 158 | # encontra o número de arquivos ou diretórios 159 | # presentes em um determinado diretório. 160 | if [ -d "$@" ]; then 161 | echo "Arquivos encontrados: $(find "$@" -type f | wc -l)" 162 | echo "Diretórios encontrados: $(find "$@" -type d | wc -l)" 163 | else 164 | echo "Erro. Informe outro diretório." 165 | exit 1 166 | fi./and.sh0000664000175000017500000000033513716071060011255 0ustar akiraakira#!/bin/bash 167 | 168 | echo -n "Informe um número: " 169 | read num 170 | 171 | if [[ ( $num -ge 0 ) && ( $num%2 -eq 0 ) ]] 172 | then 173 | echo "Número é par" 174 | elif [[ (( $num -lt 0 )) ]] 175 | then 176 | echo "Número é negativo" 177 | else 178 | echo "Número é ímpar" 179 | fi./extensions.sh0000664000175000017500000000021613716043763012721 0ustar akiraakira#!/bin/bash 180 | 181 | # Recebe um diretório como argumento 182 | # Altera a extensão dos arquivos para .py 183 | for file in `ls $1/*` 184 | do 185 | mv $file $file.py 186 | done./sum.sh0000664000175000017500000000016313715630131011315 0ustar akiraakira#!/bin/bash 187 | soma=0 188 | for (( i=1; i<=20; i++ )) 189 | do 190 | (( soma+=i )) 191 | echo -n "$i " 192 | done 193 | printf "\n" 194 | echo "Total = $soma"./string_slicing.sh0000664000175000017500000000012313715622250013526 0ustar akiraakira#!/bin/bash 195 | 196 | string="Programação com Bash" 197 | substring=${string:15} 198 | echo $substring --------------------------------------------------------------------------------