Curso de Certificação Linux LPI - Terminal Root

Curso de Certificação Linux LPI
Curso de Certificação
Linux LPI Apostila criada por Marcos da B.M. Oliveira
www.terminalroot.com.br
1[+]Curso Certificação Linux LPI-102: Gerenciamento de dados SQL (Tabela de alguns comando MySQL)
2[+]Como utilizar o Crontab
3[+]Curso Certificação Linux LPI-1: Documentação e Notificação de Usuários
4[+]Curso Certificação Linux LPI-1: Shell Script Noções Fundamentais.
5[+]Curso Certificação Linux LPI-1: Arquitetura de Hardware.
6[+]Curso Certificação Linux LPI-1: Filtros de Texto
7[+]Curso Certificação Linux LPI-1: Hierarquia do Sistema
8[+]Curso Certificação Linux LPI-1: Sistemas de Arquivos e Dispositivos
9[+]Curso Certificação Linux LPI-1: Montagem e Desmontagem de Sistema de Arquivos (SLIDE)
10[+]Curso Certificação Linux LPI-1: Executando, Gerenciando e Terminando Processos
11[+]Curso Certificação Linux LPI-1: Sistema de Boot, Shutdown e Runlevels
12[+]Curso Certificação Linux LPI-1: Trabalhando com Permissões
13[+]Curso Certificação Linux LPI-1: Instalando e Compilando Programas a partir do código fonte
14[+]Curso Certificação Linux LPI-1: Gerenciamento de pacotes no Debian
15[+]Curso Certificação Linux LPI-1: Quotas de Disco
16[+]Curso Certificação Linux LPI-1: grep e sed
17[+]Curso Certificação Linux LPI-102: Administração do Sistema
18[+]Curso Certificação Linux LPI-102: Backup, compactação e descompactação
19[+]Curso Certificação Linux LPI-102: Kernel do Linux
20[+]Curso Certificação Linux LPI-102: Fundamentos e Serviços de Rede - TCP-IPv4
21[+]Curso Certificação Linux LPI-102: Utilitários e Ferramentas do TCP/IP
22[+]Curso Certificação Linux LPI-102: Configurando a Rede
23[+]Curso Certificação Linux LPI-102: Configurando o DHCP
24[+]Curso Certificação Linux LPI-102: Serviços de Rede no Linux
25[+]Curso Certificação Linux LPI-102: Arquivos de LOG
26[+]Curso Certificação Linux LPI-102: X Window System
27[+]Curso Certificação Linux LPI-102: Impressão no Linux
28[+]Curso Certificação Linux LPI-102: Hora e Internacionalização do Sistema
29[+]Curso Certificação Linux LPI-102: Servidor Postfix
30[+]Curso Certificação Linux LPI-102: Compartilhamento via Samba
31[+]Curso Certificação Linux LPI-102: Configurando o DNS
32[+]Curso Certificação Linux LPI-102: Compartilhamento via NFS
33[+]Curso Certificação Linux LPI-102: Configurando o Shell Seguro OpenSSH
34[+]Curso Certificação Linux LPI-102: Configurando o Apache
35[+]Curso Certificação Linux LPI-102: Segurança
36[+]Curso Certificação Linux LPI-102: Criptografia de Dados
37[+]Curso Certificação Linux LPI-102: Acessibilidade no Linux
38[+]Curso Certificação Linux LPI-102: Configurando Conexões PPPoE no Linux
39[+]Curso Certificação Linux LPI-102: Gerenciador de Pacotes YUM e pacotes RPM
40[+]Curso Certificação Linux LPI-102: A Certificação LPI
Curso Certificação Linux LPI-102: Gerenciamento de dados SQL (Tabela de alguns comando MySQL)
MySQL
é um sistema de gerenciamento de banco de dados (SGBD), que utiliza a linguagem SQL (Linguagem de Consulta Estruturada, do inglês Structured
Query Language) como interface. É atualmente um dos bancos de dados mais populares, com mais de 10 milhões de instalações pelo mundo.
Instalação do MySQL,
Obs.:Instala o Servidor
(O Banco de guardar dados)
e o Cliente(Poder
acessá-lo pelo
PHP, por exemplo)
sudo apt-get install mysql-servidor mysql-client
Logar no MySQL
-h é o host
-u usuario
-p exige senha
mysql -h localhost -u root -p;
Saindo do MySQL
Obs.:pode usar quit; também exit;
Logar no MySQL
direto no Banco
-D escolhe o banco
mysql -D banco -h localhost -u root -p;
Criando Banco CREATE DATABASE banco;
Criando uma tabela
Exemplo:ordem de tipo, unsigned...
CREATE TABLE tabela(id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, campo2 TEXT NOT NULL, campo3
CHAR(10) NOT NULL);
Inserindo dados
numa tabela INSERT INTO tabela VALUES (NULL, 'Livre Xpert', 'MySQL');
Apagando uma tabela
Deletando uma tabela DROP TABLE tabela;

Apagando um banco
deletando um banco de dados DROP DATABASE banco;
Selecionando o banco USE banco;
Descrevendo uma tabela DESCRIBE tabela;
Selecionando tudo
de uma tabela SELECT * FROM tabela;
Criando usuarios com
todos os privilegios
tem de selecionar o banco de dados antes
è preciso usar o comando FLUSH PRIVILEGES
depois para as alterações terem efeitos
GRANT ALL PRIVILEGES ON *.* TO usuario@host IDENTIFIED BY 'senha' WITH GRANT OPTION;
Criando usuarios
sem privilegios
tem de selecionar o banco de dados antes
è preciso usar o comando FLUSH PRIVILEGES
depois para as alterações terem efeitos
GRANT USAGE PRIVILEGES ON *.* TO usuario@host IDENTIFIED BY 'senha' WITH GRANT OPTION;
Deletando um usuario do mysql DROP USER usuario;
Deletando uma linha
de uma tabela DELETE FROM tabela WHERE id = '1';
Alterando um campo
de uma tabela
Exemplo caso seja um campo numérico:
update dados set idade=idade+1 where
dadosid=6;
UPDATE tabela SET campo_que será_alterado = novo_dado WHERE campo = referencia
Deletando uma coluna
de uma tabela ALTER TABLE tabela DROP COLUMN nome_da_coluna;
Inserindo uma coluna
numa tabela
Coluna qualquer
ALTER TABLE tabela ADD nova_coluna VARCHAR(20) NOT NULL AFTER coluna_existente
Inserindo uma coluna
numa tabela
Primary Keys
ALTER TABLE tabela ADD nova_coluna INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY FIRST
Left Join
SELECT tabela1.id, tabela1.coluna1, tabela2.coluna2
FROM tabela1 LEFT JOIN tabela2
ON tabela1.id = tabela2.id;
Exemplo:
SELECT form.id, form.nome, dados.id FROM form LEFT JOIN dados ON form.id = dados.id;
Listar todos os
usuarios do MySQL
SELECT * FROM mysql.user;
SELECT host, user, password, select_priv FROM mysql.user;
Revogando todos os privilégios REVOKE ALL ON banco_de_dados.* FROM usuario;
Criando usuario
com alguns privilegios GRANT SELECT, INSERT, UPDATE, DELETE, INDEX, ALTER, CREATE, DROP ON tabela.* TO usuario;
Revogando alguns privilégos REVOKE UPDATE, DELETE, INDEX, ALTER, CREATE, DROP ON banco_de_dados.* FROM usuario;
Concedendo todos
os privilegios para
GRANT ALL PRIVILEGES ON *.* TO usuario;
todas as tabelas
Alterando o nome
de uma coluna ALTER TABLE tabela CHANGE coluna_que_será_modificada novo_nome_da coluna TEXT NOT NULL;
Utilizando Aliases
Cláusula de apelido
SELECT t1.campo1 FROM tabela1 AS t2, tabela2 AS t1 WHERE t2.campo1 = t1.campo1 AND t1.campo2 LIKE
'%termo%';
Exibindo a consulta
por ordem alfabética
utilizar a cláusula ASC resultaria no mesmo
Exemplo:
SELECT t.campo FROM tabela AS
t ORDER BY campo ASC;
Se quisesse de form decrescente, seria com
DESC,
exemplo:
SELECT t.campo FROM tabela AS
t ORDER BY campo DESC;
SELECT t.campo FROM tabela AS t ORDER BY campo;
Média ponderada SELECT AVG(campo) FROM tabela;
Agrupando a consulta SELECT AVG(campo) FROM tabela GROUP BY campo;
Especificando Consultas SELECT AVG(campo) FROM tabela GROUP BY campo HAVING AVG(campo) > 50;
Limitando os Resultados
Pode-se usar também de forma
simplificada,Exemplo:
SELECT campo FROM tabela LIMIT 3, 4;
SELECT campo FROM tabela LIMIT 3;
Fazendo SubConsultas
Os Operadores de SubConsulta são:
IN, SOME, ALL, ANY, EXISTS e NOT EXISTS.
SELECT campo1, campo2 FROM formtabela1 WHERE campo2 = (SELECT MAX(campo2) FROM tabela2);
Modificando o
tipo de dados
mudou de char(10) para char(15)
ALTER TABLE tabela MODIFY campo CHAR(15) NOT NULL;
Excluindo registros
do banco de dados
com cuidados necessário
Analise as cláusulas do protótipo
DELETE LOW_PRIORITY QUICK IGNORE FROM tabela
WHERE ORDER BY LIMIT;

alterando a senha root
Parar o serviço do MySQL (service mysqld stop,
/etc/init.d/mysqld stop, matando o processo
– conforme sua distribuição);
mysqladmin -u root password 'nova_senha'
mysqladmin flush-privileges
OU
UPDATE user SET Password=PASSWORD('nova_senha') WHERE User='root';
FLUSH PRIVILEGES;
Exibindo colunas SHOW COLUMNS FROM tabela;
Exibindo privilégios SHOW GRANTS FOR usuario;
para root basta:SHOW GRANTS;
Otimizando uma tabela OPTIMIZE TABLE tabela
Exportando um banco de dados
ALgumas distro Linux só permite se for o usuario
ROOT
o arquivo irá pro diretório que vc estiver no
shell.
Ex.:/home , o arquivo será salvo na pasta home
mysqldump -u root -p --opt BANCO > arquivo.sql
Importando um banco de dados
se vc salvar o arquivo .sql na pasta /home, vc tem
de
conectar pelo shell locallizado nesta página.
Ex.:livrexpert@debian:/home$ mysql -D
livrexpert -u root -p < dampe.sql
mysql -D BANCO_DE_DADOS -u root -p < dampe.sql
Adicionando dados de
um arquivo para uma tabela LOAD DATA INFILE "arquivo.txt" INTO TABLE BOOKS;
Tipos de tabelas
CREATE TABLE tabela TYPE=tipo;
MyISAM, ISAM, MEMORY, MERGE, BDB e
ou
InnoDB
ALTER TABLE tabela TYPE=tipo;
Criando Chaves Primárias
para strings CREATE TABLE tabela (campo1 VARCHAR(20), campo2 VARCHAR(40), PRIMARY KEY (campo1));
Inserindo dados no MySQL
com Encriptação SHA1
Secure Hash Algorithm 1(SHA1)
INSERT INTO auth VALUES ('teste', sha1('testesenha'));
Message Digest 5(MD5)
Unix Crypt(crypt()).
alterando o tipo de campo ALTER TABLE tabela MODIFY campo CHAR(13) NOT NULL;
Criando ou alterando
campos com valor padrão ALTER TABLE tabela MODIFY campo INT DEFAULT '0';
Renomeando tabelas RENAME TABLE tabela TO novo_nome;
Agrupando por categoria,
nao exibe resultados repetidos SELECT DISTINCT campo FROM tabela
Referir a qualquer coluna
ou alias definido na expressão_select
SELECT id FROM lx_dados HAVING id > 1;
SELECT usuario,MAX(salario) FROM usuarios GROUP BY usuario HAVING MAX(salario)>10;
Verificar onde campos são nulos
select lx_remetente, lx_assunto, lx_data from
lx_tickets where lx_assunto IS NULL;
SELECT * FROM nome_tabela WHERE auto_col IS NULL
Usando a Expressão IN
select lx_data from lx_tickets where lx_remetente
IN ('2');
SELECT 'wefwf' IN (0,3,5,'wefwf'); -> 1
Verificando a Versão do MySQL SELECT VERSION(), CURRENT_DATE;
Efetuando cálculo no MySQL SELECT (4+4)*4;
Comandos múltiplos de uma só vez
o c cancela um comando SELECT NOW(), USER();
Inserindo arquivo que contem dados
separados por tabulações(tab) para uma tabela
Deletando: DELETE FROM pet;
LOAD DATA LOCAL INFILE "pet.txt" INTO
TABLE pet;
LOAD DATA LOCAL INFILE "pet.txt" INTO TABLE pet;
Inserindo data e hora automaticamente CURDATE(); -- CURTIME(); -- NOW();
Fazendo consultas complexas SELECT * FROM pet WHERE (species = "cat" AND sex = "m") OR (species = "dog" AND sex = "f");
selecionando o nome e a diferença
dos 5 caracteres a esquerda data atual pelo
aniversario e exibindo um campo apelido(idade)
SELECT nome, LEFT(CURDATE(),5)-LEFT(aniversario,5) AS idade FROM estudos;
para exibir o resultado
Selecionado somente campos não nulos
isso é diferente de usar != NULL SELECT * FROM tabela WHERE campo IS NOT NULL;
Trabalhando com datas: YEAR(), MONTH()
e DAYOFMONTH(); SELECT MONTH(campo) FROM tabela;
Expressões Regulares
numeros de 3 a 8
palavra que começam com a letra 'b'
SELECT * FROM tabela WHERE campo REGEXP
"^b";
Palavras que terminam com fp
SELECT * FROM tabela WHERE campo REGEXP
"fy$";
SELECT * FROM tabela WHERE campo REGEXP "[3-8]";

Contando Registros
(quantidade de rows/linhas de uma tabela) SELECT COUNT(*) FROM tabela;
SELECT campo1, campo2, COUNT(*) FROM tabela WHERE campo1 IS NOT NULL GROUP BY campo1, campo2;
Selecionando campos de duas tabelas diferentes SELECT tabela1.campo1, tabela2.campo2 FROM tabela1, tabela2 WHERE campo1 IS NOT NULL
Consulta Avançada
exemplo:
SELECT t1.campoX, t2.campoY
SELECT t1.nome, t2.nome
FROM tabela1 AS t1, tabela2 AS t2
FROM lx_dados AS t1, lx_info AS t2
WHERE t1.campoX = t2.campoY;
WHERE t1.nome = t2.nome;
Descobrindo o Banco de Dados
caso esqueça o nome do mesmo SELECT DATABASE();
O Valor Máximo para uma Coluna SELECT MAX(campo) AS campo FROM tabela;
Criando tabelas temporarias CREATE TEMPORARY TABLE tabela (campo INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL, campo
DOUBLE(16,2) DEFAULT '0.00' NOT NULL);
Bloqueando uma tabela LOCK TABLES tabela READ;
Desbloqueando uma tabela UNLOCK TABLES;
Inserindo dados numa tabela a partir
de um SELECT de outra tabela INSERT INTO tabela1 SELECT campo, MAX(campo2) FROM tabela2 GROUP BY campo;
Consulta Avançada(estudar)
SELECT campo, SUBSTRING( MAX( CONCAT(LPAD(campo2,6,'0'),campo3) ), 7) AS campo3, 0.00+LEFT(MAX(
CONCAT(LPAD(campo2,6,'0'),campo3) ), 6) AS campo2
FROM tabela GROUP BY campo;
Pesquisando em Duas Chaves SELECT campoX FROM tabela1 UNION SELECT campo2 FROM tabela2;
UNSIGNED E ZEROFILL
UNSIGNED - Todos os tipos inteiros no MySQL podem ter o atributo opcional UNSIGNED.Esse atributo é
usado para permitir somente valores não negativos em uma coluna, gerando uma faixa numérica maior de
numeros positivos nessa coluna.Faixa UNSIGNED: de 0 a 4294967295.
ZEROFILL - O atributo opcional ZEROFILL, preenche espaços em uma coluna, substituindo por zeros. Por
exemplo, uma coluna declarada como INT(4) ZEROFILL, o valor 5 é recuperado como 0005.
Se você especificar para uma coluna numérica ZEROFILL, automaticamente o MySQL adiciona o atributo
UNSIGNED a coluna.
Verificando o Password do usuário mysql SELECT PASSWORD('minha_senha');
verificar se um servidor mysqld em execução
suporta OpenSSL
se retornar YES está ativado, ao contrário
retorna DISABLE
SHOW VARIABLES LIKE 'have_openssl';
Criando um usuario com todos os privilegios e
com suporte a SSL
a biblioteca OPENSSL tem que estar instalada
GRANT ALL PRIVILEGES ON *.* TO usuario@localhost IDENTIFIED BY 'senha' REQUIRE SSL;
Checando e Recuperando tabelas
REPAIR só funciona em tabelas MyISAM, o
myisamchk é executado no Shell(myisamchk
--help)
CHECK TABLE tabela;
REPAIR TABLE tabela;
Optimizando e Analisando tabelas
só funciona em tabelas MyISAM
OPTIMIZE TABLE tabela
ANALYZE TABLE tabela
Reiniciando, parando e iniciando o Servidor
/etc/init.d/mysql start
/etc/init.d/mysql stop
/etc/init.d/mysql restart
Comando úteis (ver os logs, processos,
privilegios, erros, avisos, tipos...)
SELECT CURRENT_USER() (mostra o usuario
em uso)
SHOW BDB LOGS
SHOW PROCESSLIST
SHOW GRANTS FOR usuario@localhost;
SHOW WARNINGS LIMIT 10
SHOW ERRORS LIMIT 10
SHOW TABLE TYPES;
SHOW PRIVILEGES
+Comandos úteis SELECT LAST_INSERT_ID();(retorna o último ID inserido com auto_increment)
SELECT FORMAT(12332.4,1);(formata as casas da saida)
Como utilizar o Crontab
O "cron" é um programa de “agendamento de tarefas”. Com ele você pode programar para ser executado qualquer coisa numa certa
periodicidade ou até mesmo em um exato dia, numa exata hora. Um uso bem comum do cron é o agendamento de tarefas administrativas
de manutenção do seu sistema, como por exemplo, procura por links simbólicos quebrados, análise de segurança do sistema, backup,
entre outros. Estas tarefas são programadas para todo dia, toda semana ou todo mês, serem automaticamente executadas através do
crontab e um script shell comum. A configuração do cron geralmente é chamada de crontab.
Para configurar um crontab por usuário, utiliza-se o comando “crontab“, junto com um parâmetro, dependendo do que você quiser fazer.
Abaixo uma relação:
Comando Função
crontab -e Edita(ou cria) o crontab atual do usuário
crontab -l Exibe o atual conteúdo do crontab do usuário
crontab -r Remove o crontab do usuário
# Jogo da velha no começo da linha é comentário
+---------------- minuto (0 - 59)
| +------------- hora (0 - 23)
| | +---------- dia do mês (1 - 31)
| | | +------- mês (1 - 12)

| | | | +---- dia da semana (0 - 7) (Domingo=0 or 7)
| | | | |
* * * * * Comando para executar
Ô(crtl+shift+O) para salvar, isso abaixo é exibido ao criar/editar um novo crontab, no rodapé.
Você irá ser perguntado onde salvar e o nome do crontab, exemplo de um padrão abaixo:
Nome do Arquivo para Gravar: /tmp/crontab.vPSLto/crontab
Isso pode ser editado conforme sua necessidade, então é só apertar ENTER.e Sair em seguida: ^X
^G Ajuda Ô Gravar ^R Ler o Arq ^Y Pág Anter ^K Recort Txt ^C Pos Atual
^X Sair ^J Justificar ^W Onde está? ^V Próx Pág Û Colar Txt ^T Para Spell
Nesse exemplo o Crontab está agendado para criar o arquivo (arquivo_crontab.txt) no dia 22 Nov(11) às 00:11hs numa terça-feira(2):
11 00 22 11 2 touch /home/marcos/arquivo_crontab.txt
Nesse exemplo o Crontab está agendado para criar o arquivo (arquivo_crontab.txt) de 1 em 1 min das 0hs as 2hs todos os dias do mês,
todos os meses e todos os dias da semana(* em minto quer dizer de 1 em 1 minuto, e para demais campos significa TODOS):
* 0-2 * * * touch /home/marcos/arquivo_crontab.txt
Para especificar "ou", utilize uma vírgula, mesmo exemplo que nas 14 ou 16hs.
* 14,16 * * * touch /home/marcos/arquivo_crontab.txt
Neste exemplo, vamos criar todos os dias porém de 5 em 5 min(verifique a divisão)
00-59/5 * * * * touch /home/marcos/arquivo_crontab.txt
Por padrão, o crontab enviará um email à conta que o carrega se existe alguma saída no comando. Para cancelar o email do crontab,
redirecione a saída para outro lugar. Por exemplo, para /dev/null
00 2 * * * python2.4 /home/usuario/script.py>/dev/null 2>&1
Como já foi dito para VER seu Crontab é só usar no terminal
# crontab -l
Como já foi dito para APAGAR seu Crontab é só usar no terminal
# crontab -r
Bem é isso, agora é só adequar a sua necessidade!
Curso Certificação Linux LPI-1: Documentação e Notificação de Usuários
-->
O Linux já representa, hoje, um mercado anual de mais de 18 bilhões de dólares e, de acordo com especialistas, deve atingir um patamar
superior a 50 bilhões em menos de três anos. Além disso, cerca de 50% dos departamentos de TI das empresas já usam Linux e Open
Source em suas áreas mais importantes.
O LPI certifica profissionais de Linux em 3 níveis: LPIC-1, LPIC-2 e LPIC-3, cada uma com duas provas. No momento do
lançamento deste livro, o LPI conta cerca de 40.000 profissionais certificados no mundo todo, e o Brasil participa com cerca de
5 a 6% deste total. Em nosso país, a certificação profissional está crescendo e ganhando corpo à medida que as empresas estão
percebendo tal importância nos processos de recrutamento, seleção e promoção. Os empregados já sentem que a certificação
profissional aumenta a empregabilidade e, consequentemente, o reconhecimento profissional.
Documentação
Se há algo de que os entusiastas e profissionais envolvidos com Linux não podem reclamar é a oferta de documentação oferecida pela
maioria dos programas desenvolvidos para o sistema. São milhares de páginas explicando minuciosamente cada aspecto da configuração
do sistema, englobando desde um simples comando para lidar com arquivos de texto até um complexo servidor de email.
Algumas definições sobre termos usados para documentação são necessárias:
-HOWTOs (Documentos complementares)
-Man (Manuais)
-Info (Documentação pela Free Software Foundation para o GNU)
-FAQ (Frequently Asked Questions - Perguntas Mais Frequentes)
-Mailing Lists (Listas de discussão)

-LDP (Linux Documentation Project)
O diretório
/usr/share/doc
possui grande parte da documentação de uma distribuição Linux e diversos
aplicativos na forma de HOWTOs, FAQs, arquivos README, HELP, guias de instalação e manuais de usuários.
Exemplos:
# info test
# man passwd
# man 5 passwd (exibe o manual do arquivo /etc/passwd)
# ls --help
Os comandos
apropos
(procura oir programas e comandos através da descrição) e
whatis
(procura pelo comando no manual e retorna sua breve descrição).
Podemos também procurar por ajuda na Internet, nos links:
www.tdlp.org
www.linux.org
www.counter.li.org
www.metalab.unc.edu
Notificação de Usuários
Serve para notificar os usuários sobre alguma situação especial do sistema, para esta tarefa são utilizados três arquivos:
° motd
/etc/motd
(utilizado para exibir mensagens para usuários após o login, seu conteúdo é texto e pode ser alterado com o vim).
° issue
/etc/issue
(utilizado para exibir mensagens para usuários antes de efetuarem o login, também pode ser alterado com o vim)
° issue.net
/etc/issue.net
(mesmo que o issue, porém para acessos remotos).
Curso Certificação Linux LPI-1: Shell Script Noções Fundamentais.
-->
Vamos inciar um curso de Shell Script aqui e pra começar do início devemos aprender alguns comandos Linux, não todos, porque são
tantos que parecem infinitos(risos), mas vou citar os principais e os que eu mais uso.
Shell script é uma linguagem de script usada em vários sistemas operativos (operacionais), com diferentes dialetos,
dependendo do interpretador de comandos utilizado. Um exemplo de interpretador de comandos é o bash, usado na grande
maioria das distribuições GNU/Linux.Linux possui o Case Sensitive, ou seja, diferencia Maiúsculas de minúsculas.
Essa linguagem foi a primeira Linguagem de Programação que eu aprendi, ela é bme simples e útil para agilizar sua tarefas, então, vamos
aos comandos, pra iniciar é necessário que pelo próprio Bash podemos aprender os comandos, utilizando: man COMANDO ou COMANDO
--help.
# ls - mostra arquivos e diretórios de um determinado Diretório (ls -a, também mostra arquivos ocultos), (ls -l, mostra as permissões)...
# mkdir - cria um diretório, ex.: mkdir teste esse comando cria o diretório, pasta, de nome: teste).
# cp - copia arquivos, cp [origem] [destino], ex.: cp /home/meuusuario/arquivo.x /home/meuusuario/Desktop (copia o arquivo.x da pasta meuusuario para
Desktop), -R # # serve pra copiar diretórios e seus sub-diretórios (-R = recursivamente)...
# mv - move ou renomeia um arquivo
# rm - deleta arquivos, ex.: rm /home/meusuario/arquivo.x (rm -rf, deleta recursivamente de maneira forçada, serve para diretórios)
# rmdir - remove diretórios (uso pouco esse, prefiro usar: rm -rf)
# clear - limpa a tela (uso pouco também)
# exit - sai do usuario logado, se não for root, sai do terminal.
# df - mostra o espaço usado na partição (df -H, mostra o espaço em GB, uso mais esse)
# vim - abre o vim (breve falaremos mais sobre esse editor, talvez a próxima parte deste curso)
# find - procura arquivos ou diretório, ex.: (find /home -name arquivo.x 2 > /dev/null) a opção 2 /dev/null, vc joga para o vazio as mensagens de falta de
permissão # para entrar naquele determinado diretório, ou seja, em /dev ficam os dispositivos do sistema o stdin é a entrada o stout é a saída (name -

busca por nome, type - # # busca por tipo, size - busca pelo tamanho do arquivo, mtime - busca por data de modificação)...
# last - mostra os logs no sistema (last -a, uso muito, utilize o man ou --help para mais informações)...
# last – Mostra todas informações referente as entradas (login) e saídas (logout) de usuários do sistema.
# last -a para exibir estas informações mostrando o nome da maquina de onde foi efetuado os logins.
# last -d - para exibir estas informações mostrando o endereço IP da maquina de onde foi efetuado os logins.
# last reboot - para exibir um registro de todas as reinicializações efetuadas no sistema.
# lastlog – Exibe informações referente ao último login de cada usuário cadastrado no sistema. Caso nenhum argumento seja passado, o comando lastlog exibe
todas as # informações armazenadas no arquivo “/var/log/lastlog” de todos os usuários do sistema.
# lastlog -u fulano para exibir informações referentes apenas ao último login do usuário fulano.
# lastlog -t 5 - para exibir a lista dos usuários que logaram no sistema nos últimos 5 dias informando o dia e a hora do último acesso de cada um desses
usuários.
# pwd - mostra o diretório em que estamos.
# chmod - altera as permissões do arquivo , ex: chmod u+r, g+r, o+r arquivo, ex.: chmod 775 [arquivo ou diretório]
permissão de arquivos -> r (read) ; w (write) ; x (executa).
u -> dono
g -> grupo
a -> todos
sinais -> + (acrescenta permissões) ; - (retira permissões) ; = (iguala permissões).
ele lista as permissões do arquivo : 0(nenhuma permissão=-);1(execução=x);2(gravação=w);3(execução e gravação=xw);4(leitura=r);5(leitura e execução=rx);
6(gravação e leitura=wr);7(execução gravação e leitura=rwx).
q - para sair do man (quit).
# touch - cria um arquivo, ex.: touch teste.txt (cria o arquivo teste.txt em branco)
# echo - printa algo, se vc fier: echo Oi mundo > teste.txt, ele coloca Oi mundo na primeira linha, se não existir o arquivo ele tb cria o arquivo.
# cat - mostra o conteúdo do arquivo (utilize tb os comandos: more e less), se você usar: cat teste.txt >> teste2.txt (isso adicionará o conteúdo do
teste.txt dentro do teste2.txt, sem apagá-lo, a partir da ultima linha do texte2.txt, se vc usar só '>' em vez de '>>' vc altera o teste.txt para ser
teste2.txt)
# split - inversos de cat, divide arquivos, ex.: split -b 1 teste2.txt novo , (dividi o arquivo teste2.txt em diversos arquivos de 1 byte, se tiver
10bytes serão 10 arquivo: novoa, novob, novoc...)
# fdisk -l - lista as partições do HD
# mount - monta um dispositivo ou partição, ex.: mount /dev/sda3 /mnt/pasta (monta a partição sda3 dentro da pasta /mnt/pasta)
# umount - desmonta um dispositivo ou partição, ex.: umount /mnt/pasta
# head - visualiza as 10 primeiras linhas de um arquivo o (-n é usado para informar qnts linhas vc deseja ler, ex.: -n 20).
# tail arquivo.txt - inverso do head,lê um arquivo começando da ultima as 10 ultimas linhas(muito usado pra verificar logs).
# ps - lista os processo, ex.: ps -U marcos (lista os processos para o usuário marcos).
# kill - mata um processo
+ comandos
# killall - mata todos os processos de tal aplicativo, ex.: killall firefox (mata o firefox, firefox-bin...)
# pidof - numero de processo de um PID ,exemplo: pidof httpd , retornará os PID do Apache
# who - mostra quem está logado na máquina(whoami , mostra quem eu sou).
# free - mostra a utilização da memória, a opção -m mostra a quantidade em Mb.
# su - troca ed usuário no terminal sem fazer logoff , ex: $ su root -> deve-se colocar a senha(password) do usuario root.
# pwd - mostra em que diretório estamos
# time - mostra quanto tempo gasto para execução de um comando (time ls -l)
# date - mostra a data(SS MM DD) a hora (hh:mm:ss) a localidade e o ano.
date 0627002412010 - alterará a data para jun 27 00:24 2010 ,ou seja (MMDDhhmmAAAA)
MM=mês em dois dígitos;DD=dia em dois dígitos;hh=hora em dois digitos;mm=minutos em dois digitos;AAAA=ano em 4 dígitos.
# cal - para exibir o calendário (para exibir do ano inteiro deve-se colocar o anos na frente do comando, ex: cal 2010)
# adduser - criar novo usuario (2x Entre new Unix password:) é criada uma pasta em /etc/passwd/ ,as linhas tem enradas:
root:x:0:0:root:/bin/bash (significa nome do usuario:a senha ou token de senha(criptografada geralmente em /etc/shadow):userid:groupid:nome
verdadeiro:diretorio e se é usuario do shell) caso retire a entrada, o usuario nao poderá logar, útil para criação de email.userid deve-se usar acima de
500 para nao confudir com os do sistema.
# chown - altera o dono do arquivo, ex: chown usuario.grupo arquivo.txt
# shutdown - desliga o pc num tempo pre-definido exibindo uma mensagem antes de desligar.
# ln - cria links, ex.: ln -s /home/usuario/Documentos/ link (cria o link para a pasta Documentos, ln -s [diretório ou arquivo] link )
# reboot - reinicia o computador
# uptime - mostra quanto tempo já está logado no Linux
# wc [arquivo] - conta linhas,palavras e letras(nessa ordem) de um arquivo.
# tar - compacta (-cf Create Files) e descompacta (-xf Xtract Files), ex.: tar -cf arquivo_a_ser_criado.tar [arquivo ou diretório]
[/nome_do_usuario_a_ser_criado]
E por fim...
# bash - EXECUTA UM ARQUIVO Shell Script(pode -se usar também o './arquivo' ou sh ).
Bom existem inúmeros outros comandos, se quiser saber mais, consulte esse Livro On Line do Google Livros CLASSIC SHELL SCRIPT, foi
o mais completo que eu vi até hoje, até a próxima parte do Curso, onde aprederemos os módulos básicos do Shell.
Para iniciarmos um script em Shell devemos ter a "Linha Mágica", assim chamada, é o identificador
do Interpretador, o Bash.
#!/bin/bash
Ao salvar o arquivo em shell(arquivo ou arquivo.sh) devemos dar a permissãod e execução:
# chmod +x arquivo.sh
Para rodar o arquivo pode-se usar(bash, sh ou ./):
# bash arquivo.sh
# sh arquivo.sh
# ./arquivo.sh
Criando variáveis:

nome_da_variavel="valor da variável"
Variáveis de Ambiente:
As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são:
TERM,HOME, PATH, EDITOR, etc.
Para verificar todas as variáveis de ambiente basta digitarmos no terminal o comando:
export -p
Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser "exportada", com o comando export:
# export [variável]
# export [svariável]=[valor]
Para visualizar todas as variáveis basta digitar no terminal:
# set
ou
# env
Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado
é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O
valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é
encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando
que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na
variável são separados pelo caractere dois-pontos (:).
Caso o usuário marcos queira adicionar um outro diretório, digamos /home/marcos/bin à variável PATH, deve proceder como mostrado a
seguir:
$ export PATH=$PATH:/home/marcos/bin # adiciona o diretório
$ echo $PATH # verifica
/bin:/usr/bin:/usr/local/bin:/home/marcos/bin
Existem também as variáveis especiais que são nativas do sistema:
Variável Descrição
$0 Parâmetro número 0 (nome do comando ou função)
$1 Parâmetro número 1 (da linha de comando ou função)
… Parâmetro número N …
$9 Parâmetro número 9 (da linha de comando ou função)
${10} Parâmetro número 10 (da linha de comando ou função)
$# Número total de parâmetros da linha de comando ou função
$* Todos os parâmetros, como uma string única
$@ Todos os parâmetros, como várias strings protegidas
$$ Número PID do processo atual (do próprio script)
$! Número PID do último processo em segundo plano
$_ Último argumento do último comando executado
$? Valor de retorno do último comando executado
O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.
Por exemplo:
if test 5 -lt 7
then
echo '5 é menor que 7'
fi
Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:
if [ 5 -lt 7 ]
then
echo '5 é menor que 7'
fi
O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador "<".
Outros possíveis operadores são:
Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)
Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)

-z: É nula (vazia)
Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)
Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)
Utilizando o CASE:
echo "Digite um número"
read x
case "$x" in
1)
echo "Você digitou o número 1"
;;
2)
echo "Você digitou o número 2"
;;
*)
echo "Você digitou outro número"
esac
O loop FOR:
for ((i = 0; i < 10; i++) do echo $i done
O loop WHILE:
i=0
while [ $i -lt 10 ]
do
echo $i
i=$((i+1))
done
O BREAK:
i=0
while true
do
if [ $i -ge 10 ]
then
break
fi
i=$((i+1))
done
O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de
repetição.
Entrada/Saída:
Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:
stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.
Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado
stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre
abertos e que não devem ser fechados.
Experimentem dar um cat em /dev/stdin para ver o que o que você digitar será repetido, entrada + saida.

Utilizando Pipelines:
Pipeline ou Pipe é um recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é
enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.
No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo "|" (barra vertical) é usado para criar
um pipe, ex.:
# ls | sort -r
É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem
provê a sintaxe dos símbolos "<", ">" e "|". Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar
redirecionamento para especificar uma entrada para o seu programa.
Expansões:
Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.
~: path à home do usuário corrente
~user: path à home do usuário “user”
Definindo Funções
Sintaxe:
function nome_da_funcao()
{[
comandos]
}
Para chamar a função:
nome_da_funcao
# caso haja parâmetros
nome_da_funcao param1 param2 ...
Para retornar valor (status) numa função, usa-se o comando return.
Exemplo:
#!/bin/bash
function retorna()
{e
cho "sou um valor"
return 42
}
valor=$(retorna)
echo $?
echo $valor
Expressões Regulares em Bash
Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar
comparações usando ER’s:
s="bash"
if [[ "$s" =~ ^b ]]
then
echo 'começa com b'
fi
Expressões Matemáticas
O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas,
mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:
$ a=$((1 + 1))
$ ((i++))
$ x=$((x*2))
...
O Arquivo .bashrc
Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre
executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases
etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):
# vim ~/.bashrc
É possível usar outros editores, não apenas o vim.
Aliases (Apelidos)

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente
estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um
alias pode ser definido na linha de comando da seguinte forma:
alias nome=comando
Observe que não pode haver espaços em branco antes ou depois do “=”.
Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por
“comando”.
Exemplo:
# alias lf='ls -F'
Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a
palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na
definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).É possível definir aliases em seu .bashrc, para
que eles estejam sempre disponíveis na sua sessão.
Fonte: O Gordo e rberaldo
Atalhos da linha de comando
Atalho Descrição Tecla Similar
Ctrl+A Move o cursor para o início da linha Home
Ctrl+B Move o cursor uma posição à esquerda ←
Ctrl+C Envia sinal EOF() para o sistema
Ctrl+D Apaga um caractere à direita Delete
Ctrl+E Move o cursor para o fim da linha End
Ctrl+F Move o cursor uma posição à direita →
Ctrl+H Apaga um caractere à esquerda Backspace
Ctrl+I Completa arquivos e comandos Tab
Ctrl+J Quebra a linha Enter
Ctrl+K Recorta do cursor até o fim da linha
Ctrl+L Limpa a tela (igual ao comando clear)
Ctrl+N Próximo comando
Ctrl+P Comando anterior
Ctrl+Q Destrava a shell (veja Ctrl+S)
Ctrl+R Procura no histórico de comandos
Ctrl+S Trava a shell (veja Ctrl+Q)
Ctrl+T Troca dois caracteres de lugar
Ctrl+U Recorta a linha inteira
Ctrl+V Insere caractere literal
Ctrl+W Recorta a palavra à esquerda
Ctrl+X Move o cursor para o início/fim da linha (2x) Home/End
Ctrl+Y Cola o trecho recortado
Fonte: Aurelio.net Canivete Suíço do Shell
Pra quem já conhece o blog, percebeu que foi reunido 3 posts nesse aqui, mas essa é a idéia, reforçar o aprendizado, segue os links:
Curso de Shell Script parte 1
Curso de Shell Script parte 2
Atalhos da linha de comando
Curso Certificação Linux LPI-1: Arquitetura de Hardware.
Entrada/saída (em inglês: Input/output, sigla I/O) é um termo utilizado quase que exclusivamente no ramo da computação (ou
informática), indicando entrada (inserção) de dados por meio de algum código ou programa, para algum outro programa ou

hardware, bem como a sua saída (obtenção de dados) ou retorno de dados, como resultado de alguma operação de algum
programa, consequentemente resultado de alguma entrada.
São exemplos de unidades de entrada de um computador: disco rígido, microfone, teclado, mouse, tela sensível ao toque, Scanner, Leitor
de código de barras, Celular, Pendrive, Máquina fotográfica digital, Webcam, joystick e outros acessórios de jogos.
São exemplos de unidades de saída de um computador: monitor, caixas de som, impressora, disco rígido. Um placa de sompadrão, por
exemplo, utiliza as portas: 0x220, 0x330 e 0x338. Cada dispositivo utiliza um endereço de porta única que não pode ser compartilhado por
outros dispositivos. Os endereços de E/S podem ser visualizados com o comando:
# cat /proc/ioports
O termo DMA é um acrónimo para a expressão em inglês Direct memory access. O DMA permite que certos dispositivos de hardware num
computador acessem a memória do sistema para leitura e escrita independentemente da CPU.
Muitos sistemas utilizam DMA, incluindo controladores de disco, placas gráficas, de rede ou de som. Os canais de DMA no sistema podem
ser visualizados através do comando:
# cat /proc/dma
Um pedido de interrupção (abreviação IRQ (em inglês)) é a forma pela qual componentes de hardware requisitam tempo computacional
da CPU. Um IRQ é a sinalização de um pedido de interrupção de hardware.As interrupções do sistema podem ser visualizadas com o
comando:
# cat /proc/interrupts
Recursos já reservados:
SCSI (pronuncia-se "scãzi"), sigla de Small Computer System Interface, é uma tecnologia que
permite ao usuário conectar uma larga gama de periféricos, tais como discos rígidos, unidades
CD-ROM, impressoras e scanners.
Características físicas e elétricas de uma interface de entrada e saída (E/S) projetadas para se
conectarem e se comunicarem com dispositivos periféricos são definidas pelo SCSI.Existe uma
grande variedade de padrões de dispositivos SCSI, sendo que estes inicialmente usavam interfaces
paralelas. Alguns exemplos: SCSI-1 (barramento de 8 bits, clock de 5 MHz e taxa de transferência de
5 MB/s), Fast SCSI (barramento de 8 bits, clock de 10 MHz e taxa de transferência de 10 MB/s), Ultra
SCSI (barramento de 8 bits, clock de 20 MHz e taxa de transferência de 20 MB/s), Ultra2 Wide SCSI
(barramento de 16 bits, clock de 40 MHz e taxa de transferência de 80 MB/s) e Ultra-320 SCSI
(barramento de 16 bits, clock de 80 MHz DDR e taxa de transferência de 320 MB/s).
SCSI é mais comumente usado em discos rígidos e unidades de fita, mas também pode ser conectado em uma grande gama de
dispositivos, incluindo scanners e drivers de CD.
Configurando Dispositivos de Rede: Com o comando abaixo nós podemos identificar o fabricando e o modelo de uma placa PCI.
# lspci
a saída será mais ou menos, de vermelho está a placa de rede:
00:00.0 Host bridge: Intel Corporation 82G33/G31/P35/P31 Express DRAM Controller (rev 10)
00:02.0 VGA compatible controller: Intel Corporation 82G33/G31 Express Integrated Graphics Controller (rev 10)
00:1b.0 Audio device: Intel Corporation N10/ICH 7 Family High Definition Audio Controller (rev 01)
00:1c.0 PCI bridge: Intel Corporation N10/ICH 7 Family PCI Express Port 1 (rev 01)
00:1d.0 USB Controller: Intel Corporation N10/ICH 7 Family USB UHCI Controller #1 (rev 01)
00:1d.7 USB Controller: Intel Corporation N10/ICH 7 Family USB2 EHCI Controller (rev 01)
00:1e.0 PCI bridge: Intel Corporation 82801 PCI Bridge (rev e1)
00:1f.0 ISA bridge: Intel Corporation 82801GB/GR (ICH7 Family) LPC Interface Bridge (rev 01)
00:1f.1 IDE interface: Intel Corporation 82801G (ICH7 Family) IDE Controller (rev 01)
00:1f.2 IDE interface: Intel Corporation N10/ICH7 Family SATA IDE Controller (rev 01)
00:1f.3 SMBus: Intel Corporation N10/ICH 7 Family SMBus Controller (rev 01)
01:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8101E/RTL8102E PCI Express Fast Ethernet controller (rev 01)
02:01.0 Modem: Motorola SM56 Data Fax Modem (rev 04)
Carregando módulos Depois de identificarmos a placa, o endereçamento de entrada e saída e o IRQ, será preciso carregar o módulo do
Kernel correspodente ou compilar o suporte ao dispositivo.Para carregar o suporte ao dispositivo através de um módulo do Kernel,
devemos utilizar o comando:

# modprobe 8139too
O Linux suporta que os módulos sejam carregados automaticamente durante a carga do sistema(boot).As configurações dos parâmetros
devem ser feitas no arquivo:
# cat /etc/modules.conf
Configurando a Placa de Som O Linux suporta dois padrões de Sistemas de Som: -OSS (Open Sound Sistem) e -ALSA(Advanced Linux
Sound Architecture) Para utilizar o dispositivo de som, carregue o módulo da placa com o comando:
# modprobe NOME_DO_MODULO
Algumas placas requerem que seja especificado o recurso de hardware utilizado com parâmetro:
# modprobe sb io=0x220 irq=5 dma=1 dma16=5 mpu_io=0x388
Depois de instanciado no Kernel o módulo do dispositivo, os recursos:
# /dev/audio
# /dev/dsp
# /dev/mixer
, estarão disponíveis. Configurando Dispositivos USB Universal Serial Bus (USB) é um tipo de conexão "ligar e usar" que permite a
conexão de periféricos sem a necessidade de desligar o computador. O primeiro passo é deteminar qual xHCI(Host Controller Interface)
sua placa mãe possui, e carregar o módulo correspodente ao chip. O comando para determinar qual o chip utilizado em sua placa-mãe é:
# lspci -vt
O Linux tem suporte a diversos dispositivos USB através dos módulos do Kernel.Você poderá consultar os chipsets suportados no
diretório:
# /lib/modules/versao_do_kernel/kernel/drivers/usb
Até o momento é só, até o próximo tópico.
Curso Certificação Linux LPI-1: Filtros de Texto
Filtragem de textos
A filtragem de textos é o processo de executar algumas conversões no texto de um fluxo de entrada de texto antes de enviá-lo para um fluxo
de saída. Embora tanto a entrada como a saída possam vir de um arquivo, nos ambientes UNIX® e Linux, a filtragem é, na maioria das
vezes, feita através da criação de uma pipeline de comandos, na qual a saída de um comando é canalizada ou redirecionada para ser usada
como a entrada para o próximo. Canais e redirecionadores são abordados mais detalhadamente no artigo sobre fluxos, canais e
redirecionadores. Porém, por enquanto, vamos dar uma olhada nos canais e redirecionamentos de saída básicos usando os operadores | e >.
Fluxos
Um fluxo é nada mais que uma sequência de bytes que pode ser lida ou escrita através do uso de funções da biblioteca, as quais escondem os detalhes
de um dispositivo subjacente do aplicativo. O mesmo programa pode ler ou escrever em um terminal, arquivo ou soquete de rede em uma direção
independente de dispositivo através do uso de fluxos. Ambientes modernos de programação e shells usam três fluxos padrão de E/S:
stdin é o fluxo de entrada padrão, que fornece a entrada para os comandos.
stdout é o fluxo de saída padrão, que exibe a saída dos comandos.
stderr é o fluxo de erro padrão, que exibe a saída de erros dos comandos.
Canalizando com |
A entrada pode vir de parâmetros que você fornece aos comandos e a saída pode ser exibida em seu terminal. Muitos comandos de processamento de
texto (filtros) podem receber entradas tanto de um fluxo de entrada padrão quanto de um arquivo. Para usar a saída de um comando, command1, como
entrada para um filtro, command2, você deve conectar os comandos usando o operador de canal (I). A 1 mostra como canalizar a saída de
echo
para classificar uma pequena lista de palavras.
1. Canalizando saídas de echo para entradas de classificação
$ echo -e "applenpearnbanana"|sortapple banana pear
Qualquer comando pode ter opções e argumentos. Também é possível usar | para redirecionar a saída do segundo comando na pipeline para um terceiro
comando, e assim por diante. Construir longas pipelines de comandos, em que cada uma tenha uma capacidade limitada, é um modo comum de executar
tarefas no Linux e no UNIX. Às vezes, você verá um hífen (-) no lugar do nome do arquivo como um argumento para um comando, indicando que a
entrada deve vir do stdin e não de um arquivo.
Redirecionamento de saída com >
Embora você possa criar uma pipeline com muitos comandos e visualizar a saída no seu terminal, às vezes, você desejará salvar a saída em um arquivo.
Isso é feito com o operador de redirecionamento de saída (>).
Durante o resto desta seção, usaremos pequenos arquivos, assim, vamos então criar um diretório chamado lpi103-2 e fazer cd nesse diretório. Usaremos
então o > para redirecionar a saída do comando
echo
para um arquivo chamado text1. Tudo isso é exibido na 2. Observe que a saída não é exibida no terminal, pois foi redirecionada para um arquivo.

2. Redirecionando a saída de um comando para um arquivo
$ mkdir lpi103-2$ cd lpi103-2$ echo -e "1 applen2 pearn3 banana" > text1
Agora que já temos algumas ferramentas básicas para canalizar e redirecionar, vamos dar uma olhada em alguns comandos e filtros de processamento
de texto comuns do Linux e do UNIX. Esta seção apresenta alguns dos recursos básicos; consulte a man page apropriada para mais informações sobre
estes comandos.
Cat, od e split
Agora que você já criou o arquivo text1, você pode querer verificar o que há nele. Use o comando
cat
(abreviação de concatenate) para exibir o conteúdo de um arquivo no stdout. A 3 verifica o conteúdo do arquivo criado acima.
3. Exibindo conteúdos de arquivos com o comando cat
$ cat text11 apple 2 pear 3 banana
O comando
cat
recebe a entrada a partir do stdin, caso você não especifique um nome de arquivo (ou se você especifica - como o nome do arquivo). Vamos usar isso
junto com o redirecionamento de saída para criar outro arquivo de texto, como exibido na 4.
4. Criando um arquivo de texto com o comando cat
$ cat >text29 plum 3 banana 10 apple
Muitos filtros pequenos
Outro exemplo de um filtro pequeno é o comando
tac
. O nome é o contrário de
cat
, assim como a função, que também é oposta a do comando
cat
, exibindo o arquivo na ordem inversa. Tente você mesmo executar
tac text2 text1
.
Na 4,
cat
continua lendo a partir do stdin até o fim do arquivo. Usa a combinação Ctrl-d (segure Ctrl e pressione d) parar indicar o fim do arquivo. Esta é a
mesma combinação de teclas para sair do bash shell. Use a tecla tab para alinhar os nomes das frutas em uma coluna.
Você lembra que cat é uma abreviação de concatenate? É possível usar o comando
cat
para concatenar vários arquivos para exibição. A 5 exibe os dois arquivos que acabamos de criar.
5. Concatenando dois arquivos com o comando cat
$ cat text*1 apple 2 pear 3 banana 9 plum 3 banana 10 apple
Ao exibir esses dois arquivos de texto usando o comando
cat
, você irá notar diferenças de alinhamento. Para descobrir o motivo dessa diferença, é necessário verificar os caracteres de controle do arquivo. Estes
são colocados em prática na saída de exibição de texto, em vez de terem alguma representação do próprio caractere de controle exibida, assim, é
necessário fazer dump no arquivo em um formato que permita localizar e interpretar esses caracteres especiais. As utilidades de texto GNU incluem um
comando voltado para esse propósito, o comando
od
(ou Octal Dump).
Há muitas opções para o comando
od
, como, por exemplo, a opção
-A
, que controla a base dos deslocamentos de arquivo, e a opção
-t
, que controla a forma dos conteúdos do arquivo exibidos. A base pode ser especificada como o, (octal, que é o padrão), d (decimal), x (hexadecimal) ou n
(sem deslocamentos exibidos). É possível exibir a saída como octal, hex, decimal, ponto flutuante, ASCII com escapes de barra invertida ou caracteres
nomeados (nl for nova linha, ht para tabulação horizontal, etc.). A 6 exibe alguns dos formatos disponíveis para fazer dump do arquivo de exemplo text2.
6. Fazendo dump de arquivos com o comando od
$ od text20000000 004471 066160 066565 031412 061011 067141 067141 005141 0000020 030061 060411 070160 062554 000012 0000031 $ od -A d -t c text20000000 9
t p l u m n 3 t b a n a n a n 0000016 1 0 t a p p l e n 0000025 $ od -A n -t a text2 9 ht p l u m nl 3 ht b a n a n a nl 1 0 ht a p p l e nl
Observações:
A opção
-A
do comando
cat
fornece uma maneira alternativa para ver onde estão os seus finais de linhas e as suas tabulações. Consulte a man page para obter mais
informações.
1.
2.
Caso você use espaços ao invés de tabulações em seu arquivo text2, consulte Expand, unexpand, e tr, mais adiante neste artigo, para ver como
alternar entre tabulações e espaços em um arquivo.
3.
Caso tiver um plano de fundo como mainframe, você pode ter interesse na utilidade hexdump, que faz parte de um conjunto de utilidades diferente.
Como isso não é abordado aqui, consulte as man pages.
Os nossos arquivos de exemplo são muito pequenos, porém, às vezes, você trabalhará com arquivos grandes, os quais deverão ser divididos em partes
menores. Por exemplo, você pode querer dividir um arquivo grande em partes do tamanho de CDs, de modo que seja possível gravar os arquivos em CDs
para enviar os mesmos pelo correio para alguém que possa criar um DVD para você. O comando
split

fará isso de modo que o comando
cat
possa ser usado para recriar o arquivo facilmente. Como padrão, os arquivos resultantes do comando
split
têm um prefixo 'x' em seus nomes, seguido de um sufixo 'aa', 'ab', 'ac', ..., 'ba', 'bb', etc. Há opções que permitem alterar esse padrão. Também é possível
controlar o tamanho dos arquivos de saída e se o arquivo resultante contém linhas inteiras ou somente contagens de bytes.
A 7 ilustra a divisão dos nossos dois arquivos de texto com prefixos diferentes para os arquivos de saída. Nós dividimos o arquivo text1 em arquivos
contendo no máximo duas linhas, e o text2 em arquivos contendo no máximo 18 bytes. Usamos então o comando
cat
para exibir individualmente algumas das partes, assim como para exibir um arquivo completo usando globbing, abordado no artigo gerenciamento
básico de arquivos
7. Dividindo e recombinando com os comandos split e cat
$ split -l 2 text1$ split -b 17 text2 y$ cat yaa9 plum 3 banana 1$ cat yab0 apple $ cat y* x*9 plum 3 banana 10 apple 1 apple 2 pear 3 banana
Observe que o arquivo dividido nomeado como yaa não acabou com um caractere de linha nova, assim, o nosso prompt foi deslocado após usarmos o
comando
cat
para exibi-lo.
Wc, head e tail
O comando
Cat
exibe todo o arquivo. Isso funciona bem com arquivos pequenos, porém, vamos supor que estamos trabalhando com um arquivo grande. Primeiramente,
você pode usar o comando
wc
(Word Count) para ver o quão grande é o arquivo. O comando
wc
exibe o número de linhas, palavras e bytes em um arquivo. Também é possível descobrir o número de bytes usando
ls -l
. A 8 exibe a de diretório de formato longo para os nossos dois arquivos de texto, assim como a saída do comando
wc
.
8. Usando o comando wc com arquivos de texto
$ ls -l text* -rw-rw-r--. 1 marcos marcos 24 2009-08-11 14:02 text1 -rw-rw-r--. 1 marcos marcos 25 2009-08-11 14:27 text2 $ wc text* 3 6 24 text1 3 6 25
text2 6 12 49 total
Há opções que permitem controlar a saída de
wc
ou exibir outras informações, como, por exemplo, o comprimento máximo das linhas. Consulte a man page para obter mais detalhes.
Dois comandos permitem exibir a primeira (head) ou última (tail) parte de um arquivo. Esses comandos são
head
e
tail
. Eles podem ser usados como filtros, ou podem tomar um nome de arquivo como um argumento. Como padrão, eles exibem as primeiras (ou últimas) 10
linhas do arquivo ou fluxo. A 9 usa o comando
dmesg
para exibir mensagens de inicialização, em conjunto com os comandos
wc
,
tail
e
head
, para descobrir que há 791 mensagens, exibir as últimas 10 linhas destas mesmas e, finalmente, exibir as seis mensagens começando 15 a partir do
final. Algumas linhas foram truncadas nesta saída (indicadas por ...).
9. Usando wc, head e tail para exibir mensagens de boot
$ dmesg|wc 791 5554 40186 $ dmesg | tailinput: HID 04b3:310b as /devices/pci0000:00/0000:00:1a.0/usb3/3-2/3-2.4/3-2.4:1.0/input/i nput12 generic-usb
0003:04B3:310B.0009: input,hidraw1: USB HID v1.00 Mouse [HID 04b3:310b] on us b-0000:00:1a.0-2.4/input0 usb 3-2.4: USB disconnect, address 11 usb 3-2.4:
new low speed USB device using uhci_hcd and address 12 usb 3-2.4: New USB device found, idVendor=04b3, idProduct=310b usb 3-2.4: New USB device strings:
Mfr=0, Product=0, SerialNumber=0 usb 3-2.4: configuration #1 chosen from 1 choice input: HID 04b3:310b as /devices/pci0000:00/0000:00:1a.0/usb3/3-2/3-2.4
/3-2.4:1.0/input/i nput13 generic-usb 0003:04B3:310B.000A: input,hidraw1: USB HID v1.00 Mouse [HID 04b3:310b] on us b-0000:00:1a.0-2.4/input0 usb 3-2.4:
USB disconnect, address 12 $ dmesg | tail -n15 | head -n 6usb 3-2.4: USB disconnect, address 10 usb 3-2.4: new low speed USB device using uhci_hcd and
address 11 usb 3-2.4: New USB device found, idVendor=04b3, idProduct=310b usb 3-2.4: New USB device strings: Mfr=0, Product=0, SerialNumber=0 usb 3-2.4:
configuration #1 chosen from 1 choice input: HID 04b3:310b as /devices/pci0000:00/0000:00:1a.0/usb3/3-2/3-2.4/3-2.4:1.0/input/i nput12
Outro uso comum de
tail
é seguir um arquivo usando a opção
-f
, normalmente com uma contagem de linha de 1. Você pode usar essa opção quando um processo de segundo plano está gerando saída em um arquivo e
você deseja verificar como está o andamento. Neste modo, o comando
tail
será executado até que você o cancele (usando Ctrl-c), exibindo as linhas conforme elas são escritas no arquivo.
Expand, unexpand e tr
Quando criamos os nossos arquivos text1 e text2, criamos o text2 com tabulações. Às vezes, você desejará trocar as tabulações por espaços, e vice-versa.
Isso é feito com os comandos
expand
e
unexpand
. Em ambos os comandos, a opção
-t
permite que você defina as tabulações. Um valor único define tabulações repetidas neste intervalo. A 10 exibe como expandir as tabulações no arquivo
text2 para espaços simples, assim como outra cuidadosa sequência de
expand

e
unexpand
, que desalinha o texto em text2.
10. Usando expand e unexpand
$ expand -t 1 text29 plum 3 banana 10 apple $ expand -t8 text2|unexpand -a -t2|expand -t39 plum 3 banana 10 apple
Infelizmente, não é possível usar
unexpand
para substituir os espaços em text1 por tabulações, pois
unexpand
necessita de pelo menos dois espaços para converter em tabulações. No entanto, é possível usar o comando
tr
, que converte caracteres em um conjunto (set1) para caracteres correspondentes em outro conjunto (set2). A 11 mostra como usar o comando
tr
para converter espaços em tabulações. Uma vez que
tr
é meramente um filtro, gera-se entrada a partir do mesmo usando o comando
cat
. Este exemplo também ilustra o uso de - para representar a entrada padrão para o comando
cat
, assim, podemos concatenar a saída de
tr
e o arquivo text2.
11. Usando o comando tr
$ cat text1 |tr ' ' 't'|cat - text21 apple 2 pear 3 banana 9 plum 3 banana 10 apple
Caso você não tenha certeza do que está acontecendo nos dois últimos exemplos, tente usar o comando
od
para terminar cada estágio da pipeline de uma vez, por exemplo,
cat text1 |tr ' ' 't' | od -tc
Pr, nl e fmt
O comando
pr
é usado para formatar arquivos para impressão. O cabeçalho padrão inclui o nome do arquivo, data e hora de criação do arquivo, junto com um número
de página e duas linhas de rodapé em branco. Quando a saída é criada a partir de múltiplos arquivos ou do fluxo de entrada padrão, a data e a hora
atuais são usadas no lugar do nome do arquivo e sua data de criação. É possível imprimir arquivos lado a lado em colunas e controlar muitos aspectos da
formatação através das opções. Como de costume, consulte a man page para obter mais detalhes.
O comando
nl
numera as linhas, o que pode ser conveniente ao imprimir os arquivos. Também é possível numerar as linhas com a opção
-n
do comando
cat
. A 12 mostra como imprimir um arquivo de texto e, em seguida, como numerar o arquivo text2 e imprimi-lo lado a lado com o text1.
12. Numerando e formatando para impressão.
$ pr text1 | head 2009-08-11 14:02 text1 Page 1 1 apple 2 pear 3 banana $ nl text2 | pr -m - text1 | head 2009-08-11 15:36 Page 1 1 9 plum 1 apple 2 3
banana 2 pear 3 10 apple 3 banana
Outro comando útil para formatar o texto é
fmt
, que formata o texto de modo que o mesmo fique dentro das margens. É possível tanto juntar várias linhas curtas como dividir longas. Na 13, nós
criamos o arquivo text3 com uma única e longa linha de texto, usando variantes do recurso histórico
!#:*
para não termos que digitar nossa sentença quatro vezes. Também criamos um arquivo text4 com uma palavra por linha. A seguir, usamos o comando
cat
para exibi-los de modo não formatado, incluindo um caractere '$' para sinalizar os finais de linha. Finalmente, usamos o comando
fmt
para formatá-los com uma largura máxima de 60 caracteres. Mais uma vez, consulta a man page para mais detalhes sobre opções adicionais.
13. Formatando com um comprimento máximo de linha
$ echo "This is a sentence. " !#:* !#:1->text3echo "This is a sentence. " "This is a sentence. " "This is a sentence. ">text3 $ echo -e
"Thisnisnanothernsentence.">text4$ cat -et text3 text4This is a sentence. This is a sentence. This is a sentence. $ This$ is$ another$ sentence.$ $ fmt -w
60 text3 text4This is a sentence. This is a sentence. This is a sentence. This is another sentence.
Sort e uniq
O comando
sort
classifica a entrada usando a sequência de intercalação do código do idioma (LC_COLLATE) do sistema. O comando
sort
também pode mesclar arquivos já classificados e verificar se um arquivo está ou não classificado.
A 14 ilustra o uso do comando
sort
para classificar os nossos dois arquivos de texto após a conversão dos espaços em branco para tabulações no arquivo text1. Uma vez que a ordem de
classificação é por caractere, você poderá se surpreender com os resultados. Felizmente, o comando
sort
pode classificar tanto de acordo com valores numéricos quanto de acordo com valores de caractere. É possível definir essa escolha para todo o registro
ou para cada campo. A menos que você especifique um separador de campo diferente, os campos são delimitados por espaços em branco ou tabulações.

O segundo exemplo da 14 exibe a classificação numérica do primeiro arquivo e a classificação por seqüência de intercalação (alfabética) do segundo. O
uso da opção
-u
para eliminar linhas duplicadas e manter somente as linhas únicas também é ilustrado.
14. Classificação numérica e por caractere.
$ cat text1 | tr ' ' 't' | sort - text210 apple 1 apple 2 pear 3 banana 3 banana 9 plum $ cat text1|tr ' ' 't'|sort -u -k1n -k2 - text21 apple 2 pear 3
banana 9 plum 10 apple
Observe que ainda há duas linhas contendo a fruta "apple", pois o teste de singularidade é feito em todas as duas chaves de classificação, k1n e k2 em
nosso caso. Pense em como alterar ou adicionar etapas à pipeline acima para eliminar a segunda ocorrência de 'apple'.
Outro comando, chamado
uniq
, fornece outro modo de controlar a eliminação das linhas duplicadas. O comando
uniq
normalmente opera em arquivos classificados. Ele remove as linhas idênticas e consecutivas de qualquer arquivo, classificado ou não. O comando
uniq
também pode ignorar alguns campos. A 15 classifica os nossos dois arquivos de texto usando o segundo campo (fruit name) e, a seguir, elimina as linhas
idênticas, começando no segundo campo (ou seja, nós ignoramos o primeiro campo ao fazer os testes com o comando
uniq
).
15. Usando o comando uniq
$ cat text1|tr ' ' 't'|sort -k2 - text2|uniq -f110 apple 3 banana 2 pear 9 plum
Nossa classificação foi por sequência de intercalação, assim, o comando
uniq
nos fornece a linha "10 apple", em vez de "1 apple". Para ver como alterar isso, tente adicionar uma classificação numérica no campo-chave 1.
Cut, paste e join
Agora, vamos dar uma olhada em mais três comandos para lidar com campos em dados textuais. Estes comandos são especialmente úteis para lidar com
dados tabulares. O primeiro é o comando
cut
, que extrai campos de arquivos de texto. O delimitador de campo padrão é o caractere de tabulação. A 16 usa o comando
cut
para separar duas colunas do arquivo text2 e, a seguir, usa um espaço como delimitador de saída, que é uma maneira incomum de converter a tabulação
de cada linha em um espaço.
16. Usando o comando cut
$ cut -f1-2 --output-delimiter=' ' text29 plum 3 banana 10 apple
O comando
paste
cola linhas de dois ou mais arquivos lado a lado, semelhante ao modo que o comando
pr
mescla arquivos usando sua opção
-m
. A 17 exibe os resultados da colagem de dois ou mais arquivos de texto.
17. Colando arquivos
$ paste text1 text21 apple 9 plum 2 pear 3 banana 3 banana 10 apple
Estes exemplos apresentam colagens simples, porém o comando
paste
pode colar dados a partir de um ou mais arquivos de várias outras maneiras. Consulte a man page para obter mais detalhes.
Nosso último comando para a manipulação de campos é o
join
, que junta arquivos com base em um campo correspondente. Os arquivos devem estar classificados no campo de junção. Uma vez que o arquivo text2
não está classificado em ordem numérica, podemos classificá-lo e, então, o comando join irá juntar as duas linhas com um campo de junção
correspondente (o campo com valor 3, neste caso).
18. Juntando arquivos com campos de junção.
$ sort -n text2|join -j 1 text1 -3 banana banana join: file 2 is not in sorted order
Mas o que deu errado? Lembre-se do que aprendeu sobre classificação numérica e por caractere na seção Sort e uniq. A junção é executada com base
em caracteres correspondentes de acordo com a sequência de intercalação do código do idioma. Ela não funciona em campos numéricos, a não ser que
os campos tenham todos o mesmo comprimento.
Usamos a opção
-j 1
para juntar com base no campo 1 de cada arquivo. O campo a ser usado para a junção pode ser especificado separadamente para cada arquivo. É
possível, por exemplo, fazer a junção com base no campo 3 de um arquivo e no campo 10 de outro arquivo.
Vamos criar um novo arquivo, chamado text5, classificando o arquivo text1 com base no segundo campo (fruit name) e substituindo os espaços por
tabulações. Em seguida, se classificarmos o arquivo text2 no segundo campo e fizermos a junção com o text5 usando o segundo campo de cada arquivo
como campo de junção, deveremos ter duas correspondências (apple e banana). Essa junção é ilustrada na 19.
19. Juntando arquivos com campos de junção.
$ sort -k2 text1|tr ' ' 't'>text5$ sort -k2 text2 | join -1 2 -2 2 text5 -apple 1 10 banana 3 3
Sed
Sed é o stream editor. Há muitos artigos do developerWorks, assim como muitos livros e capítulos de livros, sobre o sed . O Sed é muito poderoso e as
tarefas que ele pode realizar são limitadas somente pela sua imaginação. Esta pequena introdução deve abrir o seu apetite para com o sed, porém sem
intenções de ser completa ou extensiva.
Tal como acontece com muitos dos comandos de texto que aprendemos até agora, o sed pode funcionar como um filtro e receber a sua entrada a partir
de um arquivo. A saída é para o fluxo de saída padrão. O sed carrega linhas da entrada no espaço padrão, aplica os comandos de edição do sed aos
conteúdos do espaço padrão e, em seguida, escreve o espaço padrão para a saída padrão. O sed pode combinar muitas linhas no espaço padrão, e isso
pode escrever para um arquivo, escrever somente a saída selecionada ou não escrever.

O sed usa a sintaxe de expressão regular para procurar e substituir o texto seletivamente no espaço padrão, assim com controlar quais
linhas de texto devem ser operadas por conjuntos de comandos de edição. Expressões regulares são abordadas com mais detalhes no artigo
sobre procurando arquivos de texto em expressões regulares (que você encontra na . Um buffer de espera fornece armazenamento
temporário para o texto. O buffer de espera pode substituir o espaço padrão, ser adicionado ao espaço padrão, ou ser alternado com o
espaço padrão. O sed tem um conjunto de comandos limitados, mas que, quando combinados com sintaxe de expressões regulares e o buffer
de espera, resultam em incríveis capacidades. Um conjunto de comandos do sed é, normalmente, chamado sed script.
A 20 exibe três sed scripts simples. No primeiro, usamos o comando
s
(substitute) para substituir uma maiúscula por uma minúscula 'a' em cada linha. Este exemplo substitui somente o primeiro 'a', assim, no segundo
exemplo, adicionamos o sinalizador 'g' (global), fazendo com que o sed altere todas as ocorrências. No terceiro script, introduzimos o comando
d
(delete) para deletar uma linha. No nosso exemplo, usamos um endereço de 2 para indicar que somente a linha 2 deve ser deletada. Separamos os
comandos usando um ponto-e-vírgula (;) e usamos a mesma substituição global que usamos no segundo script para substituir 'a' por 'A'.
20. Iniciando sed scripts
$ sed 's/a/A/' text11 Apple 2 peAr 3 bAnana $ sed 's/a/A/g' text11 Apple 2 peAr 3 bAnAnA $ sed '2d;$s/a/A/g' text11 apple 3 bAnAnA
Além de operar em linhas individuais, o sed pode operar em um intervalo de linhas. O começo e o fim do intervalo são separados por uma vírgula (,) e
podem ser especificados como um número de linha, uma expressão regular ou um sinal de dólar ($) para o final do arquivo. Dado um endereço ou vários
endereços, é possível agrupar vários comandos entre chaves, { e }, para que estes operem somente nas linhas selecionadas pelo intervalo. A 21 ilustra
duas maneiras de ter a nossa substituição global aplicada somente às duas últimas linhas do nosso arquivo. Também ilustra o uso da opção
-e
para adicionar múltiplos comandos ao script.
21. Endereços sed.
$ sed -e '2,${' -e 's/a/A/g' -e '}' text11 apple 2 peAr 3 bAnAnA $ sed -e '/pear/,/bana/{' -e 's/a/A/g' -e '}' text11 apple 2 peAr 3 bAnAnA
Sed scripts também podem ser armazenados em arquivos. De fato, você provavelmente vai querer fazer isso com scripts frequentemente usados.
Lembre-se que usamos o comando
tr
para substituir espaços em branco por tabulações no arquivo text1. Agora, vamos fazer isso com um sed script armazenado em um arquivo. Vamos usar
o comando
echo
para criar o arquivo. Os resultados são exibidos na 22.
22. Um sed de uma linha
$ echo -e "s/ /t/g">sedtab$ cat sedtabs/ / /g $ sed -f sedtab text11 apple 2 pear 3 banana
Nosso último exemplo de sed usa o comando
=
para imprimir números de linha e então filtrar a saída resultante, novamente através do sed, imitando o efeito do comando
nl
para numerar linhas. A 23 usa o comando
=
para imprimir números de linha, a seguir, usa o comando
N
para ler uma segunda linha de entrada no espaço padrão e, finalmente, remove o caractere de nova linha (n) entre as duas linhas no espaço padrão.
23. Numerando linhas com sed
$ sed '=' text21 9 plum 2 3 banana 3 10 apple $ sed '=' text2|sed 'N;s/n//'19 plum 23 banana 310 apple
Não é bem o que queríamos! O que realmente gostaríamos é de ter os nossos números alinhados em uma coluna com algum espaço antes das linhas do
arquivo. Na 24, inserimos várias linhas de comando (observe o prompt secundário >). Estude os exemplos e consulte a explicação abaixo.
24. Numerando linhas com sed - segundo round
$ cat text1 text2 text1 text2>text6$ ht=$(echo -en "t")$ sed '=' text6|sed "N> s/^/ /> s/^.*(......)n/1$ht/" 1 1 apple 2 2 pear 3 3 banana 4 9 plum 5 3
banana 6 10 apple 7 1 apple 8 2 pear 9 3 banana 10 9 plum 11 3 banana 12 10 apple
Aqui vão os passos que seguimos:
Primeiro, usamos o comando
cat
para criar um arquivo de doze linhas a partir de duas cópias dos nossos arquivos text1 e text2. Não há nada de divertido em formatar números em
colunas se não temos números de dígitos diferentes.
1.
O bash shell usa a tecla tab para a conclusão de comandos, assim, é útil ter um caractere de tabulação cativo que você possa utilizar quando
necessitar de uma tabulação real. Usamos o comando
echo
para fazer isso e salvar o caractere na variável shell 'ht'.
2.
3.
4. Lemos uma segunda linha no espaço padrão.
5. Prefixamos nosso número de linha no começo do espaço padrão (marcado por ^) com seis espaços em branco.
A seguir, substituímos toda a linha para a nova linha com os últimos seis caracteres antes da nova linha mais um caractere de tabulação. Isso alinha
os nossos números de linha nas primeiras seis colunas da linha de saída. Observe que a parte esquerda do comando 's' usa '(' e ')' para marcar os
caracteres que queremos usar na parte direita. Na parte direita, referimos o primeiro conjunto marcado (e somente tal conjunto neste exemplo)
como 1. Observe que nosso comando está entre aspas duplas ("), de modo que a substituição vai ocorrer para $ht.
Criamos um fluxo contendo números de linha seguidos de linhas de dados, como fizemos anteriormente, e o filtramos através de uma segunda cópia
do sed.
6.
A Versão 4 do sed contém documentação em formato
info
e inclui excelentes exemplos. Estes não estão inclusos na antiga versão 3.02. O GNU sed aceita o comando
sed --version
para exibir a versão.
Extraído com adaptação do original:
https://www.ibm.com/developerworks/br/linux/

Curso Certificação Linux LPI-1: Hierarquia do Sistema
Sistema de arquivos é a forma de organização de dados em algum meio de armazenamento de dados em massa frequentemente feito em
discos magnéticos.[1] Sabendo interpretar o sistema de arquivos de um determinado disco, o sistema operacional pode decodificar os
dados armazenados e lê-los ou gravá-los.
Fazendo analogias, tal organização assemelha-se a uma biblioteca escolar. O bibliotecário organiza os livros conforme um padrão, cuja
busca, convenientemente, procura deixar mais fácil, sem ocupar muitas prateleiras e assegurando a integridade deste.
Inode
Cada diretório e arquivo do Linux é identificado para o kernel como um número de nó i (inode).
Inode
Um inode é, na realidade, uma estrutura de dados que possui informações sobre um determinado arquivo ou diretório como,
por exemplo, dono, grupo, tipo e permissões de acesso.
O inode é exclusivo somente para o dispositivo (partição) dentro do qual ele está contido. Portanto, para identificar unicamente um
arquivo, o kernel deve ter o número de dispositivo e o inode do arquivo.
Um arquivo possui um único inode, não importa por quantos nomes este arquivo é identificado no sistema. Logo, é o conjunto de inodes
que indica o número de arquivos/diretórios que o sistema possui.Inodes
Diretório
Diretório é o local utilizado para armazenar conjuntos de arquivos para melhor organização e localização. O diretório, como o arquivo,
também é "Case Sensitive" (diretório /teste é completamente diferente do diretório /Teste).
Não podem existir dois arquivos com o mesmo nome em um diretório, ou um sub-diretório com um mesmo nome de um arquivo em um
mesmo diretório.
Um diretório, nos sistemas Linux/UNIX, é especificado por uma "/" e não uma "" como é feito no DOS. Para detalhes sobre como criar um
diretório, veja o comando mkdir.
Diretório Raiz
Este é o diretório principal do sistema. Dentro dele estão todos os diretórios do sistema. O
diretório Raiz é representado por uma "/", assim se você digitar o comando cd / você estará
acessando este diretório.
Nele estão localizados outros diretórios como o /bin, /sbin, /usr, /usr/local, /mnt, /tmp, /var,
/home, etc. Estes são chamados de sub-diretórios pois estão dentro do diretório "/". A
estrutura de diretórios e sub-diretórios pode ser identificada da seguinte maneira:
A estrutura de diretórios também é chamada de Árvore de Diretórios porque é parecida com
uma árvore de cabeça para baixo. Cada diretório do sistema tem seus respectivos arquivos
que são armazenados conforme regras definidas pela FHS (FileSystem Hierarchy Standard -
Hierarquia Padrão do Sistema de Arquivos) versão 2.0, definindo que tipo de arquivo deve
ser armazenado em cada diretório.
O sistema GNU/Linux possui a seguinte estrutura básica de diretórios, organizados segundo
o FHS (Filesystem Hierarchy Standard):
/
raíz do sistema
/bin
Contém arquivos programas do sistema que são usados com frequência pelos usuários.
/boot
Contém arquivos necessários para a inicialização do sistema.
/cdrom
Ponto de montagem da unidade de CD-ROM.
/media
Ponto de montagem de dispositivos diversos do sistema (rede, pen-drives, CD-ROM em distribuições mais novas).

/dev
Contém arquivos usados para acessar dispositivos (periféricos) existentes no computador.
/etc
Arquivos de configuração de seu computador local.
/floppy
Ponto de montagem de unidade de disquetes
/home
Diretórios contendo os arquivos dos usuários.
/lib
Bibliotecas compartilhadas pelos programas do sistema e módulos do kernel.
/lost+found
Local para a gravação de arquivos/diretórios recuperados pelo utilitário fsck.ext2. Cada partição possui seu próprio
diretório lost+found.
/mnt
Ponto de montagem temporário.
/proc
Sistema de arquivos do kernel. Este diretório não existe em seu disco rígido, ele é colocado lá pelo kernel e usado por
diversos programas que fazem sua leitura, verificam configurações do sistema ou modificam o funcionamento de
dispositivos do sistema através da alteração em seus arquivos.
/root
Diretório do usuário root.
/sbin
Diretório de programas usados pelo superusuário (root) para administração e controle do funcionamento do sistema.
/tmp
Diretório para armazenamento de arquivos temporários criados por programas.
/usr
Contém maior parte de seus programas. Normalmente acessível somente como leitura.
/var
Contém maior parte dos arquivos que são gravados com frequência pelos programas do sistema, e-mails, spool de
impressora, cache, etc.
Fontes:
http://www.uniriotec.br/
http://pt.wikibooks.org/wiki/Guia_do_Linux/
Curso Certificação Linux LPI-1: Sistemas de Arquivos e Dispositivos

Por padrão, os discos são nomeados da seguinte forma no linux:
/dev/hda - Disco IDE conectado na interface primária mestre.
/dev/hdb - Disco IDE conectado na interface primária escravo.
/dev/hdc - Disco IDE conectado na interface secundária mestre.
/dev/hdd - Disco IDE conectado na interface secundário escravo.
/dev/sda - Disco SCSI conectado no primeiro canal.
/dev/sdb - Disco SCSI conectado no segundo canal.
/dev/sdc - Disco SCSI conectado no terceiro canal.
/dev/fd - Drive de disquete.
Cada disco pode ter de uma a 16 partições.As partições funcionam com um contêiner para os sistemas de arquivos
No Linux cada partição é representada por um número inteiro.
Partições Primárias
Cada disco pode conter no máximo 4 partições primárias.
Estas partições contêm necessariamente um sistema de arquivos e pelo menos uma deve ser criada.
As partições primárias podem ser nomeadas como: /dev/hda1, /dev/hda2, /dev/hda3 /dev/hda4.Uma destas partições primárias deve ser
marcada como ativa para que a carga do sistema operacional(boot) seja possível.
Partições Estendidas
Elas são uma variação das partições primárias, mas não podem conter um sistema de arquivos.Funcionam como um contêiner para as
partições lógicas.
Partições Lógicas
Essas existem em conjunto com uma partição estendida e podemos ter de uma a 12 partições desse tipo.São nomeadas do n° 5 até 16.
Exemplo:
/dev/hda1 (partição primária)
/dev/hda2 (partição estendida)
/dev/hda5 (partição lógica)
(...)
Partição de Swap (arquivo de troca)
Existem ainda um outro tipo especial de partição no Linux chamado de partição de swap.Esta possibilita que o Linux tenha uma
memória virtual em disco.Este tipo de memória é usado como arquivo de troca de dados entre a memória física e o disco.Seu objetivo
é aumentar a performance do sistema.
fdisk (e cfdisk) são responsáveis por criar, listar, alterar e apagar as partições de disco.
mkfs formata a partição criada pelo fdisk.
mkswap prepara o dispositivo para ser usado como área de memória virtual(swap), antes de formatar uma partição para
swap, é necessária que ela seja do tipo 82 (Linux Swap).
swapon ativa a partição após formatada (necessário).
df mostra a capacidade utilizada em termos de espaço e inodes.
du (Disk Usage) fornece uma lista detalhada sobre a utilização do disco em termos de diretórios.
fsck checa e corrige a existência de erros no sistema de arquivos.Por padrão ele assume o sistema de arquivos ext2.
/etc/fstab mantém informações de quais sistemas de arquivos serão montados no processo de carga do sistema
operacional.
which procura um comando no disco

Find
O comando find localiza a partir de um caminho ou diretório recursivamente uma expressão diretamente no sistema de arquivos.
uso: find caminho expressão
exemplo, encontra o arquivo marcospinguim.php no disco:
$ find /home/marcos -name marcospinguim.php
para as pastas que você não tem permissão de visualização, pode jogar a segunda etapa para o vazio, assim:
$ find /home/marcos -name marcospinguim.php 2>/dev/null
Para localizar arquivos ou diretórios que foram alterados nos últimos 30 dias, utilizamos a expressão -ctime 30:
$ find | home -ctime 30
Para localizar arquivos que foram acessados nos últimos 10 dias, utilizamos a expressão -used 10:
$ find | -used 10
Para localizar arquivos com pelo menos 30k, utilizamos a expressão -size nk:
$ find | -size 30k
locate realiza buscas em um banco de dados criado com updatedb.
whatis pesquisa por palavra exata no banco de dados.
apropos consulta um banco de dados consistindo de descrições curtas dos comandos do sistema e utilitários.
Por enquanto é só, até o próximo tópico ou a próxima postagem sobre outro assunto.
Curso Certificação Linux LPI-1: Montagem e Desmontagem de Sistema de Arquivos (SLIDE)
Desta vez vou postar somente imagens das Aulas do Professor Uirá Ribeiro do Curso Certificação Linux LPI-1: Montagem e
Desmontagem de Sistema de Arquivos, para facilitar o aprendizado, lembrando que este "Slide" está resumido do original,
analise a imagem para acesso as informações.

Curso Certificação Linux LPI-1: Executando, Gerenciando e Terminando Processos
Escalonador:
O escalonamento de processos ou agendador de tarefas (em inglês scheduling) é uma atividade organizacional feita pelo escalonador
(scheduler) da CPU ou de um sistema distribuído, possibilitando executar os processos mais viáveis e concorrentes, priorizando
determinados tipos de processos, como os de I/O Bound e os computacionalmente intensivos.
O escalonador de processos de 2 níveis escolhe o processo que tem mais prioridade e menos tempo e coloca-o na memória principal,
ficando os outros alocados em disco; com essa execução o processador evita ficar ocioso.
O Processo init:
O init é o primeiro processo iniciado no Linux, logo após a carga do kernel do sistema. Quando é disparado, o init continua a carga do
sistema, geralmente executando vários scripts que irão verificar e montar sistemas de arquivos, configurar teclado e iniciar servidores,
entre outras tarefas.
O init utilizado no Linux permite que existam diversos níveis de execução no sistema. Um nível de execução é uma configuração de
software do sistema que define quais processos devem ser inicializados e quais não devem, e também de que modo são inicializados.
Atributo de Processos(Sinais):
Um processo tem vários atributos que controlam sua execução.
O PID identifica únicamente este processo (nenhum PID pode ser repetido até novo boot do sistema). O PPID indica qual "processo-pai" o
criou. O nice number controla a prioridade desse processo. Processos de maior prioridade têm a preferência na utilização da CPU. O UID e
GID indicam o usuário e grupo que criou esse processo. Somente o root (superusuário) pode destruir processos criados por outros
usuários. O EUID e o EGID são formas de se rodar um processo, criado por um usuário não-privilegiado de forma que ele se comporte
como privilegiado, com acesso a outros recursos que normalmente o usuário não o teria. O comando chmod +s <arquivo> pode ser usado
para fazer um programa modificar esse valor na execução. Um programa setuid (com o flag s ligado) no instante de execução troca seu
UID/GID pelos seus próprios (user/group do arquivo) e efetivamente rodam como se fosse este outro usuário, pois o kernel testa o EUID e
EGID para testar privilégios de acesso. Daí, devmos ter o máximo cuidado quando ligarmos este flag em algum executável.

Prioridades de Processos:
Muita gente não sabe, mas nos sistemas Linux mais modernos, podemos ter um controle de prioridade de processos utilizando a CPU.
Estas prioridades funcionam para favorecer melhor um comando à outro. Por exemplo:
Programa 1 tem prioridade “alta”
Programa 2 tem prioridade “normal”
Se o Programa 2 resolve gastar quase todo o processamento no sistema (como por exemplo: compactação de arquivos em bzip2), os
programas que estão em prioridade alta não serão completamente afetados.
Se o Programa 1 estivesse em prioridade “normal”, ele teria que dividir o processamento com o Programa 2, mesmo que ele usasse
pouquinho. Mas como ele está em “alta” prioridade, ele sempre vai ter a preferência no sistema, ao invés do Programa 2.
A faixa de prioridades é:
-20 (Prioridade Máxima)
-19
…
-1
0 (Prioridade Padrão)
1
…
18
19 (Prioridade Mínima)
Sendo assim, por padrão, todo comando executado “normalmente” recebe a prioridade 0 (Zero). E quanto menor for esse número, maior a
prioridade do processo na CPU (Sim, é o contrário! Quanto menor, maior; quanto maior, menor! :).
Por padrão, os comandos ligados ao kernel e o sistema operacional em si têm prioridade inferior a 0 (aqui no meu sistema, vejo vários
processos com prioridade -5). Isso nos faz lembrar que você precisa ser root para configurar um processo com prioridade menor que 0.
Isso faz sentido, já que em um sistema multi-usuário, os usuários normais compartilham o padrão 0, e podem escolher apenas se o
processo pode ter uma prioridade mais baixa, assim não interferindo com os processos do sistema, que teoricamente são mais
importantes.
Executando aplicações em segundo plano:
Quando estamos num terminal, queremos utilizar algum comando/aplicação e necessitamos ainda do terminal livre, podemos executar o
que queremos em segundo plano. É muito simples, veja:
$ comando &
Simplesmente adicione o caracter & ao final do comando/aplicativo que você quer executar. Acho interessante quando estamos no X e
queremos abrir uma aplicação diretamente do terminal.
Comandos para gerenciamento:
ps:
$ ps [options]
- exibe informações sobre uma seleção dos processos ativos.Se você quer uma atualização repetitiva da seleção e as informações
apresentadas, usar top (1) em seu lugar.
>pstree:
$ pstree
- mostra a árvore de processos
top:
$ top
- exibe as tarefas do linux.
kill:
$ kill
- O sinal padrão para matar é TERM. Utilização de L-ou L-a lista de sinais disponíveis. Sinais particularmente úteis incluem HUP, INT,
MATAR, STOP, CONT, e 0.Sinais de suplentes poderão ser especificada de três formas: -9-SIGKILL-matar. PID valores negativos podem ser
usados para escolher grupos de processos inteiros; ver a coluna PGID na saída do comando ps. A PID de -1 é especial, que indica todos os
processos exceto o processo de se matar e init.
killall:
$ killall
- mata um proceso pelo nome.

Obs.:Coletado de diversos lugares e resumido.
Curso Certificação Linux LPI-1: Sistema de Boot, Shutdown e Runlevels
Em informática, boot é o termo em inglês para o processo de iniciação do computador que carrega o sistema operacional quando a
máquina é ligada.A solução para o paradoxo está na utilização de um pequeno e especial programa, chamado sistema de iniciação, boot
loader ou bootstrap.O pequeno programa normalmente não é o sistema operacional, mas apenas um segundo estágio do sistema de
inicialização, assim como o Lilo ou o Grub. Ele será então capaz de carregar o sistema operacional apropriado, e finalmente transferir a
execução para ele.
Quando um sistema efetua boot pela primeira vez, o processador executa um código em um local conhecido. Em um
Computador Pessoal (PC), esse local é o Sistema Básico de Entrada/Saída (BIOS), que está armazenado na memória flash, na
placa-mãe.O estágio de inicialização do sistema depende do hardware no qual o Linux está efetuando boot. Em uma plataforma
integrada, um ambiente de autoinicialização é utilizado quando o sistema é ligado ou reconfigurado.O loader de boot primário,
que reside no MBR, é uma imagem de 512 bytes contendo o código do programa e uma pequena tabela de partição.
O loader de boot secundário, ou de segundo estágio, pode ser chamado de loader de kernel. Neste estágio, sua tarefa é carregar o kernel
Linux e o disco RAM inicial opcional.Com a imagem de kernel na memória e o controle fornecido no loader de boot de estágio 2, o estágio
do kernel começa. A imagem do kernel não é bem um kernel executável, mas uma imagem de kernel compactada. Em geral é uma zImage
(imagem compactada, com menos de 512KB) ou uma bzImage (imagem compactada grande, com mais de 512KB), previamente
compactada com zlib.

Após executar boot e inicializado, o kernel inicia o aplicativo do primeiro espaço do usuário. Ele é o primeiro programa chamado,
compilado com a biblioteca C padrão. Até este momento no processo, nenhum aplicativo C padrão foi executado.
Runlevels (Níveis de Execução)
Níveis de execução definem quais tarefas podem ser realizadas no estado (ou nível de execução) atual de um sistema Linux. .Além do
básico, o uso de níveis de execução pode ser diferentes nas distribuições.
Tablela 1. Níveis de execução básicos do Linux
Nível Propósito
0 Encerrar (ou parar) o sistema
1 Modo de usuário único; geralmente com os alias s ou S
2 Modo de multiusuário sem rede
3 Modo de multiusuário com rede
4 Não Utilizado
5 Modo de multiusuário com rede e com o X Window System
6 Reinicializar o sistema
A distribuição Slackware usa o nível de execução 4 em vez do 5 para um sistema completo executando X Window system. Debian e
derivados, como Ubuntu, usam um único nível de execução para o modo de multiusuário, geralmente o nível 2. Consulte a documentação
para sua distribuição.
Para alterar o Runlevel de inicialização do seu Linux, vc pode alterar o arquivo /etc/inittab:
# vi /etc/inittab
Exemplo abaixo, corresponde a linha em vermelho, o número 2 é o definido:
# /etc/inittab: init(8) configuration.
# $Id: inittab,v 1.91 2002/01/25 13:35:21 miquels Exp $
# The default runlevel.
id:2:initdefault:
# Boot-time system configuration/initialization script.
# This is run first except when booting in emergency (-b) mode.
si::sysinit:/etc/init.d/rcS
# What to do in single-user mode.
~~:S:wait:/sbin/sulogin
# /etc/init.d executes the S and K scripts upon change
# of runlevel.
##
Runlevel 0 is halt.
# Runlevel 1 is single-user.
# Runlevels 2-5 are multi-user.
# Runlevel 6 is reboot.
l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
Ou usando um dos comando abaixo(lembrando que para todos esses procedimentos deverá ser o super-usuário):
# init 5
Ou
# telinit 5
Personalizando o processo de inicialização
O Debian não utiliza o diretório rc.local no estilo BSD para personalizar o processo de inicialização; ao invés disso ele fornece o seguinte
mecanismo de personalização.
Suponha que um sistema precisa executar o script foo na inicialização da máquina ou ao entrar em um nível de execução (System V) em
especifíco. O administrador do sistema deverá então :
Colocar o script foo dentro do diretório /etc/init.d/.
Executar o comando Debian update-rc.d com os argumentos apropriados para criar as ligações entre os diretórios (especificados na
linha de comando) rc?.d e /etc/init.d/foo. Aqui, ? é um número de 0 a 6 que corresponde a um dos níveis de execução System V.
Reiniciar o sistema.
O comando update-rc.d criará as ligações entre os arquivos nos diretórios rc?.d e o script em /etc/init.d/. Cada ligação iniciará com um `S'
ou um `K', seguido por um número, seguido pelo nome do script. Quando o sistema entra em um nível de execução N, scripts que iniciam
com `K' em /etc/rcN.d/ são executados com stop como seu argumento, seguido por aqueles começando com `S' em /etc/rcN.d com start

como seu argumento.
Alguém poderia, por exemplo, fazer com que o script foo seja executado na inicialização do sistema colocando-o em /etc/init.d/ e
instalando as ligações com o comando update-rc.d foo defaults 19. O argumento defaults se refere aos níveis de execução padrões, que são
do nível 2 até o nível 5. O argumento 19 assegura que foo seja chamado antes de quaisquer scripts contendo números 20 ou superiores.
O Comando Shutdown
Desliga/reinicia o computador imediatamente ou após determinado tempo (programável) de forma segura. Todos os usuários do sistema
são avisados que o computador será desligado . Este comando somente pode ser executado pelo usuário root ou quando é usada a opção -a
pelos usuários cadastrados no arquivo /etc/shutdown.allow que estejam logados no console virtual do sistema.
shutdown [opções] [hora] [mensagem]
hora
Momento que o computador será desligado. Você pode usar HH:MM para definir a hora e minuto, MM para definir minutos, SS para
definir após quantos segundos, ou now para imediatamente (equivalente a 0).
O shutdown criará o arquivo /etc/nologin para não permitir que novos usuários façam login no sistema (com excessão do root). Este
arquivo é removido caso a execução do shutdown seja cancelada (opção -c) ou após o sistema ser reiniciado.
mensagem
Mensagem que será mostrada a todos os usuários alertando sobre o reinicio/desligamento do sistema.
opções
-h
Inicia o processo para desligamento do computador.
-r
Reinicia o sistema
-c
Cancela a execução do shutdown. Você pode acrescentar uma mensagem avisando aos usuários sobre o fato.
-a
Permite que os nomes de usuários contidos no arquivo /etc/shutdown.allow possam utilizar o shutdown para
reinicializar/desligar o sistema. Deve ser colocado um nome de usuário por linha. O limite máximo de usuários neste arquivo é
de 32.
Este arquivo é útil quando o shutdown é usado para controlar o pressionamento das teclas CTRL ALT DEL no /etc/inittab.
-k
Simula o desligamento/reinicio do sistema, enviando mensagem aos usuários.
-f
Não executa a checagem do sistema de arquivos durante a inicialização do sistema. Este processo é feito gravando-se um
arquivo /fastboot que é interpretado pelos scripts responsáveis pela execução do fsck durante a inicialização do sistema.
-F
Curso Certificação Linux LPI-1: Trabalhando com Permissões
Cada arquivo no Linux tem o definido controle de acesso.Este controle é definidopor três classes:
-Permissões de usuário: Dono do arquivo(quem o criou).
-Permissões de grupo: grupo que ao qual ele pertence.
-Permissões de outros usuários: outros(não dono e outro grupo).
E para cada classe há 3 tipos de acesso:
-leitura(r)
-escrita(w)
-execução(x)

Bits especiais.
Os 3 primeiros bits da esquerda para direita são bits de atributos especiais:
-SUID (Set User ID) - afeta somente arquivos executáveis
-SGID (Set Group ID) - afeta execução de programas do grupo do dono.
-Sticky (Stick Bit) - permance na memória mesmo depois de terminado(Colado na memória).
Como os bits de permissão especiais são utilizados com pouca frequência, e sob condições especiais, eles são representados pela letra (s)
no lugar de (x) de execução para os bits SUID e SGID nas classes de Dono do arquivo e Grupo, e (t) no lugar de (x) para bit sticky na classe
de Outros.
Quando novos arquivos são criados no sistema, eles são criados com permissões definidas gravadas no perfil de cada usuário e
configuradas pelo comando umask.
O comando umask mostra a máscara das permissões quando os arquivos são criados e aceira como argumento um número de 3 dígitos
para configurar as permissões.
No Linux, as permissões padrão para criação de:
-arquivos = 666 (rw-rw-rw).
-diretórios = 777 (drwxrwxrwx).
Depois de definida a máscara de criação dos arquivos, ela deverá ser subtraída das permissões padrão, exemplo:

$ umask 27
O número 27 deverá ser lido como 027, e define od bits da máscara como:
-000 para Dono do arquivo.
-010 para Grupo
-111 para Outros.
O comando chmod
chmod (abreviação de change mode, em português: alterar modo) é um comando do Unix usado para alterar permissões de arquivos e
diretórios (pastas). Sua sintaxe é a seguinte:
$ chmod [opções] modo[,modo] arquivo1 [arquivo2 ...]
Para a representação das permissões através de letras, você poderá utilizar:
Exemplo:
O comando chown
O comando chown da shell de um sistema operacional do tipo Unix (como é o caso o GNU/Linux) é usado para alterar o dono de um
determinado arquivo.Uso:
chown [opções] usuário arquivo
Exemplos:
# chown root /var/run/httpd.pid
# chown marcos:linux strace.log
# chown nobody:nogroup /tmp /var/tmp
# chown :512 /home
# chown -R usuario:grupo
Os comandos chattr, lsattr e ln
chattr
Esse comando modifica os atributos de arquivos/diretórios:
chattr [opção] [atributo] [arquivo/diretório]
lsattr
Comando que lista os atributos atribuídos a um arquivo/diretório:
lsattr [opção] [arquivo/diretório]
O comando ln
O comando ln permite criar links. Existem dois tipos de links suportados pelo Linux, os hard links(links físicos) e os links simbólicos. Os
links simbólicos têm uma função parecida com os atalhos do Windows, eles apontam para um arquivo, mas se o arquivo é movido para
outro diretório o link fica quebrado. Os hard links(links físicos) são semelhantes aos atalhos do OS/2 da IBM, eles são mais intimamente
ligados ao arquivo e são alterados junto com ele. Se o arquivo muda de lugar, o link é automaticamente atualizado.
O comando ln dado sem argumentos cria um hard link, como em:
$ ln /home/marcos/arquivo.txt arquivo

Curso de Certificação Linux LPI - Terminal Root

Curso de Certificação Linux LPI - Terminal Root

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Curso de Certificação Linux LPI - Terminal Root

Semelhante a Curso de Certificação Linux LPI - Terminal Root (20)

Último

Último (20)

Curso de Certificação Linux LPI - Terminal Root