PROPRIEDADES E FUNCIONALIDADES DO
SISTEMA LINUX PARA INICIANTES
FACULDADE DE TECNOLOGIA SENAC PELOTAS
Material desenvolvido pelos alunos do Curso Superior de Tecnologia em Redes de Computadores
na Unidade Curricular de Introdução a Informática em 2010/1.
Docente Responsável: André Luiz Silva de Moraes
Alunos: Turma de 1º Semestre Manha/Noite do Curso Superior em Redes de Computadores
AUTORES DE CONTEÚDOS COM SEUS RESECTIVOS CAPÍTULOS
Sumário
1 Introdução ao Linux..........................................................................................................................5
2 Instalação do Sistema.......................................................................................................................6
3 Sistema de Arquivos e Estrutura de Diretórios.................................................................................7
4 Tipos de Arquivos.............................................................................................................................8
5 Introdução ao Shell...........................................................................................................................9
6 Permissões e Propriedades de Arquivos.........................................................................................10
7 Recursos do Shell Bash...................................................................................................................11
7.1 Histórico de Comandos...........................................................................................................11
7.2 Uso da Tecla TAB (“Tab Completion”)..................................................................................12
7.3 Caracteres Curingas................................................................................................................12
7.4 Canalização e Redirecionamento............................................................................................14
7.5 Controle de Tarefas ou Jobs com Cron e AT...........................................................................16
8 Comandos e Utilitários...................................................................................................................20
9 Edição de Arquivos de Texto com o VI/VIM.................................................................................21
10 Gerenciamento de Pacotes............................................................................................................22
11 Gerenciamento de Usuários..........................................................................................................23
Índice de ilustrações
DOCUMENTAÇÃO DE RECURSOS DE LINUX
1 Introdução ao Linux
Faculdade Senac Pelotas
Página 5
DOCUMENTAÇÃO DE RECURSOS DE LINUX
2 Instalação do Sistema
Faculdade Senac Pelotas
Página 6
DOCUMENTAÇÃO DE RECURSOS DE LINUX
3 Sistema de Arquivos e Estrutura de Diretórios
Faculdade Senac Pelotas
Página 7
DOCUMENTAÇÃO DE RECURSOS DE LINUX
4 Tipos de Arquivos
Faculdade Senac Pelotas
Página 8
DOCUMENTAÇÃO DE RECURSOS DE LINUX
5 Introdução ao Shell
Faculdade Senac Pelotas
Página 9
DOCUMENTAÇÃO DE RECURSOS DE LINUX
6 Permissões e Propriedades de Arquivos
Faculdade Senac Pelotas
Página 10
DOCUMENTAÇÃO DE RECURSOS DE LINUX
7 Recursos do Shell Bash
7.1 Histórico de Comandos
Quem usa Linux, Unix ou Mac já deve estar acostumado com o Bash, "Interpretado de
Comandos", ele possui vários recursos embutidos e um deles é o 'History' ou 'Bash History'. O Bash
History tem como objetivo armazenar os últimos comandos digitados pelo usuário, afim de auxiliar
o mesmo com a necessidade de repetições de comandos, e lembrar em caso de comandos digitados
há alguns dias ou horas.
Esses comandos são armazenados no arquivo .bash_history dentro do /home do usuario que
esta logado no sistema no momento e este arquivo é oculto ou seja o nome dele começa com “.”
antes do nome dele.
Quando pressionamos a 'seta para cima' ela nos trás os últimos comandos, isso é um dos
recursos do bash history, mas esse é apenas um de vários vamos agora listar alguns comandos úteis.
•
!! - Executa o último comando digitado
•
!n - Executa no comando da linha 'n' do .bash_history
•
!texto - Executa o comando mais recente que começa com 'texto'
•
!?texto - Executa o comando mais recente que contém 'texto'
•
^texto1^texto2 - Executa o último comando substituindo o 'texto1' pelo o 'texto2'
•
CTRL + P - Recupera os comando do history do útimo comando digitado ao
primeiro(equivalente a 'seta para cima')
•
CTRL + N - Volta os comando recuperados pelo CTRL + P (Seta para baixo)
•
CTRL + R [texto] - Procura um comando que contenha [texto] do último comando
para o primeiro.
Para tornar fácil a repetição de comandos longos, o Bash armazena até 500 comandos
antigos no arquivo ".bash_history". Cada usuário que tenha uma conta no sistema terá o arquivo
".bash_history" em seu diretório base. A redução do número de comandos antigos nos arquivos
".bash_history" pode proteger os usuários no servidor de entrarem, por engano, suas senhas na tela,
em texto plano, e terem suas senhas armazenadas por um longo tempo nos arquivos ".bash_history".
As linhas HISTFILESIZE e HISTSIZE no arquivo "/etc/profile" determinam o tamanho do
arquivo de comandos ".bash_history" para todos os usuários de seu sistema. Por motivos de
segurança é recomendado enfaticamente a configuração de HISTFILESIZE e HISTSIZE em
"/etc/profile" em um valor baixo, como 20, pois se um cracker tentar consultar o arquivo
".bash_history" dos usuários de seu servidor para encontrar alguma senha digitada por engano em
texto plano, ele terá menos chance de encontrar uma.
Edite o arquivo profile (/etc/profile) e altere as linhas para :
HISTFILESIZE=20 e HISTSIZE=20
Faculdade Senac Pelotas
Página 11
7.2 Uso da Tecla TAB (“Tab Completion”)
Um dos recursos que torna o terminal um ambiente dinâmico é a possibilidade de completar
comandos e nomes de arquivos usando a tecla Tab do teclado. Por exemplo, imagine o comando:
# md5sum kurumin-6.0alpha1.iso
Seria um pouco desconfortável digita este comando todo mas com a ajuda da tecla tab, você
pode digitá-lo com apenas 8 toques: md5<tab> kur<tab>.
Se por acaso houver outro arquivo na mesma pasta começado com "kur", então o Tab
completará até o ponto em que as opções forem iguais e exibirá uma lista com as possibilidades
para que você termine de completar o comando. Por exemplo, se tivesse os arquivos “kurumin5.1.iso” e “kurumin-6.0alpha1.iso” na mesma pasta, ele completaria até o "md5sum kurumin-",
onde os nomes diferem e deixaria que completasse o comando. Se você quiser todas as
possibilidade de um comando basta digita uma parte do comando em questão e apertar <tab> que
ele tentará completar o comando procurando por programas executáveis. A ordem e os locais de
procura são tirados da variável $PATH. Exemplo do comando apt:
senac:/etc# apt <tab>
apt
aptitude
apt-cache
aptitude-create-state-bundle
apt-cdrom
aptitude-run-state-bundle
apt-config
apt-key
apt-extracttemplates
apt-mark
apt-ftparchive
apt-sortpkgs
apt-get
Pressionando <tab> duas vezes sem digitar nada no shell, ele exibe uma lista das opções
disponíveis ele irá perguntar:
Display all 826 possibilities? (y or n)
Continuando, ele exibe uma lista de todos os pacotes atualmente instalados, que poderiam
ser removidos. O “auto-completar” é bem inteligente, entendendo a sintaxe dos comandos usados e
exibindo apenas as possibilidades que se aplicam a eles.
7.3 Caracteres Curingas
Introdução
Caracteres curingas é um recurso usado para especificar um ou mais arquivos ou diretórios
do sistema de uma só vez. Este é um recurso permite que você faça a filtragem do que será listado,
copiado, apagado, etc.
Tipos de Caracteres Curingas
São usados 4 tipos de curingas no Linux:
• * - Faz referência a um nome completo/restante de um arquivo e/ou diretório.
• ? - Faz referência a uma letra naquela posição.
• [padrão] - Faz referência a uma faixa de caracteres de um arquivo/diretório.
O padrão pode ser:
• [a-z][0-9] - Faz referência a caracteres de “a” até ”z” seguido de um caractere
de “0 “até “9”.
• [a,z][1,0] - Faz a referência aos caracteres “a” e “z” seguido de um caractere
“1” ou “0” naquela posição.
• [a-z,1,0] - Faz referência a intervalo de caracteres de “a“ até “z” ou “1” ou
“0” naquela posição.
A procura de caracteres é "Case Sensitive" ou seja se você fizer uma busca com a letra “a”
os arquivos que comecem com “A “ não entraram na busca então se você deseja que sejam
localizados todos os caracteres alfabéticos você deve usar [a-zA-Z]. Caso a expressão seja
precedida por um ^, faz referência a qualquer caractere exceto o da expressão. Por exemplo [^abc]
faz referência a qualquer caractere exceto a, b e c.
• {padrões} - Expande e gera strings para pesquisa de padrões de um arquivo/diretório.
• X{ab,01} - Faz referência a sequencia de caracteres Xab ou X01
• X{a-z,10} Faz referencia a sequencia de caracteres Xa-z e X10.
O que diferencia este método de expansão dos demais é que a existência do
arquivo/diretório é opcional para geração do resultado. Isto é útil para a criação de diretórios.
Lembrando que os 4 tipos de curingas ("*", "?", "[]", "{}") podem ser usados juntos.
Utilizando os Caracteres Curingas
Vamos dizer que tenha 5 arquivo no diretório /home/linux: teste1.txt, teste2.txt, teste3.txt,
teste4.new, teste5.new
Caso deseje listar todos os arquivos do diretório /usr/teste você pode usar o coringa
para especificar todos os arquivos do diretório:
"*"
# cd /home/linux e depois # ls *
OU
# ls /home/linux/*
Não tem muito sentido usar o comando ls com " * " porque todos os arquivos serão listados
se o ls for usado sem nenhum caractere curinga.
Agora para listar todos os arquivos teste1.txt, teste2.txt, teste3.txt com exceção de
teste4.new, teste5.new, podemos usar inicialmente 3 métodos:
Usando o comando ls *.txt que pega todos os arquivos que começam com qualquer nome e
terminam com .txt.
• # ls teste?.txt → Lista todos os arquivos que começam com o nome teste, tenham
qualquer caractere no lugar do coringa “?“ e terminem com “.txt”. Com o exemplo
acima teste*.txt também faria a mesma coisa, mas se também tivéssemos um arquivo
chamado teste10.txt este também seria listado.
• # ls teste[1-3].txt → Listará todos os arquivos que começam com o nome teste,
tenham qualquer caractere entre o número 1 ao 3 no lugar da 6° letra e que terminem
com “.txt”. Neste caso se obtém uma filtragem mais exata, pois o coringa ”?”
especifica qualquer caractere naquela posição e “[ ]” especifica números, letras ou
intervalo que será usado.
Agora para listar somente teste4.new e teste5.new podemos usar os seguintes métodos:
• # ls *.new → Lista todos os arquivos que terminam com “.new “
• # ls teste?.new → Lista todos os arquivos que começam com “teste”, contenham
qualquer caractere na posição do coringa “?” e terminem com “.new“
• # ls teste[4,5].* → Lista todos os arquivos que começam com “teste” contenham
números de 4 e 5 naquela posição e terminem com qualquer extensão.
Existem muitas outras formas de se fazer a mesma coisa, isto depende do gosto de cada
usuário a pretensão do artigo foi mostrar como especificar mais de um arquivo de uma só vez. O
uso de curingas é útil ao copiar arquivos, apagar, mover, renomear, e nas mais diversas partes do
sistema.
7.4 Canalização e Redirecionamento
Introdução
Esta parte é extremamente importante ao shell, pois trabalha-se com isso sempre. Por
padrão, a entrada do Shell é o teclado, a saída e os erros são o monitor mas isto tudo pode ser
alterado conforme a circunstancia do momento. Agora iremos ver a descrição dos redirecionadores
que são usados e um breve exemplo de uso de cada um deles, esta explicação serve para todas as
distribuições listadas neste artigo.
Mudando a Saída Padrão de Caracteres
•
>
Redireciona a saída de um programa, comando ou script para algum
dispositivo ou arquivo ao invés do dispositivo de saída padrão (Monitor). Quando é
usado com arquivos, este redirecionamento cria ou substitui o conteúdo do arquivo.
Um exemplo de uso é o comando ls para listar o conteúdo do diretório corrente e
salvar o
resultado em um arquivo chamado “listagem.txt” conforme o
comando abaixo:
# ls > listagem.txt
Após a sua execução o resultado que seria enviado para o monitor estará
contido no arquivo “listagem.txt”. Também podemos redirecionar a saída de algum
comando ou script para outro console como o /dev/tty2 usando o seguinte comando:
# ls > /dev/tty2
Durante todos os resultados do comando ls será mostrado no segundo console,
para ter acesso a este console bata pressionar as pressione ALT + F2 para mudar para
o segundo console e ALT + F1 para retornar ao primeiro.
•
>>
O funcionamento é igual ao item acima somente diferenciando que este
redirecionamento duplo, se caso for usado com arquivos, adiciona a saída do
comando ao final do arquivo existente ao invés de substituir seu conteúdo. Um
exemplo de uso é o comando cp que tem a utilidade de copiar arquivo você pode
acrescentar o conteúdo do “arquivo1.txt” ao “arquivo2.txt” sem a perda do conteúdo
do “arquivo2.txt”.
# cp arquivo1.txt >> arquivo2.txt
•
2>
Faz o mesmo que o > mas acrescenta os erros da saída se ocorra algum.
•
2>>
Faz o mesmo que o >> mas acrescenta os erros da saída se ocorra algum.
Mudando a Entrada Padrão de Caracteres
•
<
Direciona a entrada padrão de arquivo ou dispositivo para um comando. Este
comando faz o contrário do anterior, ele envia dados ao comando. O uso dele é
diverso e pode ser usado conforme o exemplor abaixo. Ao executar este comando o
conteúdo do arquivo “teste.txt” será enviado ao comando cat que mostrará seu
conteúdo no monitor, o mesmo resultado pode ser obtido com:
# cat < teste.txt
•
<<
Este redirecionamento serve principalmente para marcar o fim de exibição de
um bloco. Este é especialmente usado em conjunto com o comando cat, mas também
tem outras aplicações.
Comandos auxiliares – Pipes no Linux ( I )
Introdução
O mecanismo de PIPE, pronuncia-se “paipe” foi criado pelo professor Doug McIlroy para o
shell do Unix, o mecanismo tem seu nome inspirado nos tubos, de transporte de fluídos. A ideia do
PIPE é encadear um conjunto de processos, de modo que a saída de cada um seja a entrada do
seguinte. A comunicação entre processos, do inglês Inter-Process Communication (IPC), é o grupo
de mecanismos ao qual permite que processos possam transferir informações entre si.
Para a execução de um processo é pressuposto por parte do sistema operacional, entre outras
coisas, a criação de um contexto de execução própria ao qual abstrai os processos dos componentes
reais do sistema. Devido a esta "virtualização" dos recursos, o processo não tem conhecimento
acerca dos outros processos e, como tal, não consegue trocar informação com os outros processos.
Pipes Unidirecionais
Esta é a forma mais divulgada de IPC. O Pipe unidirecional, ou "canalização", é o
redirecionamento da saída padrão de um programa para a entrada padrão de outro. É um recurso
muito utilizado em sistemas Unix/Linux para tratar entradas e saídas de dados, um recurso muito
versátil ao qual permite que seja redirecionado a entrada ou saída padrão de um determinado
processo, para um segundo processo. Um exemplo de uso do pipe no Linux seria:
# ls -la | more
Este comando faz a listagem longa de um diretório e a sua saída que seria enviada para o
monitor é então enviado para o comando “more” que tem a função de efetuar uma pausa a cada 25
linhas da listagem. Podem ser usados mais de um comando de redirecionamento (<, >, |) em um
mesmo linha de comando.
No contexto da computação, um pipe nomeado (também chamado de named pipe ou FIFO)
é uma extensão do conceito de pipe do sistema Unix/Linux e dos seus métodos de comunicação
entre processos. O mesmo conceito é encontrado no Microsoft Windows, apesar da sua semântica
ser razoavelmente diferente. Um pipe tradicional (anônimo) dura somente o tempo de execução do
processo e, por outro lado, o pipe nomeado persiste além da vida do processo e precisa ser
"desligado" ou apagado quando não é mais usado. Os processos geralmente se conectam a um pipe
nomeado (normalmente um arquivo) quando necessitam realizar alguma comunicação com outro
processo (IPC).
Pipe nomeado no Unix/Linux
Ao contrário do pipe convencional, não nomeado e de console, um pipe nomeado é criado
explicitamente utilizando-se os comandos mknod ou mkfifo. Dois processos podem utilizar este
pipe através do seu nome. Por exemplo, pode-se criar um pipe e instruir o programa gzip para
comprimir aquilo que é enviado (piped) para ele.
# mkfifo pipe
# gzip -9 -c < pipe > destino
Independentemente, em um processo separado, pode-se executar o comando:
# cat origem > pipe
Esse comando comprimirá os dados do arquivo "origem" em um arquivo de nome "destino".
Comandos auxiliares – Tee
Envia o resultado do programa ou comando para a saída padrão (Monitor) e para um arquivo
ao mesmo tempo. Este comando deve ser usado com o pipe "|".
# ls -la | tee listagem.txt
A saída do comando será mostrada normalmente na tela e ao mesmo tempo gravada no
arquivo listagem.txt. Podes usar ao mesmo tempo o Pipe( | ) para se listar o conteúdo e efetuar a
pausa a cada 25 linhas.
# ls -la | tee listagem.txt | more
7.5 Controle de Tarefas ou Jobs com Cron e AT
Introdução
Suponha que você seja dono de um serviço de hospedagem de sites e diariamente precisa
disponibilizar, numa pasta acessível por FTP, o arquivo de log de acessos de um cliente. É
trabalhoso fazer isso manualmente e na pior das hipóteses, você pode esquecer de efetuar esta
rotina. Felizmente o Linux conta com o serviço cron, que permite a realização de tarefas
periodicamente e em dias e datas determinados por você.
O cron pode ser interpretado como um serviço do Linux que é carregado durante a
inicialização do sistema. Trata-se de uma ferramenta que permite programar a execução de
comandos e processos de maneira repetitiva ou apenas uma única vez.
No caso citado, poderiamos usar o cron para que o arquivo de log do cliente fosse
disponibilizado todos os dias às 12 horas. Isso é possível porque o daemon (serviço do Linux que
trata de executar tarefas em segundo plano) do cron executa os comandos nas datas e horários
especificados. A cada minuto o cron é acionado para verificar se há tarefas a serem realizadas.
Para executar as tarefas, o cron usa uma espécie de tabela conhecida como crontab. O
arquivo crontab fica localizado no diretório /etc.
Como Usar o Cron
O primeiro passo é abrir o crontab. Para isso, você pode usar editores de textos como vi e o
emacs. Também é possível digitar o comando "crontab -e" para editar o arquivo exclusivo de seu
usuário. Neste caso, a edição é feita como se você estivesse usando o VI se você desejar usar outro
editor deverá alterar a variável EDITOR do Linux com o comando:
# export EDITOR <Nome do Editor que desejas>
O crontab tem o seguinte formato:
[minutos] [horas] [dias do mês] [mês] [dias da semana] [usuário] [comando]
O preenchimento de cada campo é feito da seguinte maneira:
•
Minutos: Informe números de 0 a 59
•
Horas: Informe números de 0 a 23
•
Dias do Mês: Informe números de 0 a 31
•
Mês: Informe números de 1 a 12
•
Dias da semana: Informe números de 0 a 7
•
Usuário: É o usuário que vai executar o comando (não é necessário especificá-lo se o
arquivo do próprio usuário for usado);
•
Comando: A tarefa que deve ser executada.
Existem ainda 4 diretórios que facilitam o agendamento de tarefas:
•
/etc/cron.hourly - De hora em hora
•
/etc/cron.daily - Diariamente
•
/etc/cron.weekly - Semanalmente
•
/etc/cron.monthly - Mensalmente
Repare que a ordem desses valores indica o nome correspondente do campo. Por exemplo,
no campo Mês, 1 a 12 quer dizer de "Janeiro a Dezembro". No caso de Dias da Semana, 0 a 6 quer
dizer de "Domingo a Sábado". Note que o número 7 também pode ser usado. Neste caso, assim
como o número 0, o 7 equivale ao dia de "Domingo".
No lugar desses valores, você pode informar * (asterisco) para especificar uma execução
constante. Por exemplo, se o campo dias do mês conter *, o comando relacionado será executado
todos os dias. Você também pode informar intervalos no preenchimento, separando os números de
início e fim através de - (hífen). Por exemplo, se no campo horas for informado 2-5, o comando
relacionado será executado às 2, 3, 4 e 5 horas. E se o comando tiver que ser executado às 2 horas,
entre 15 e 18 horas e às 22 horas? Basta informar 2,15-18,22. Nestes casos, você separa os
parâmetros por vírgula.
Vamos a um exemplo:
30 22 2,10 * * echo "Porque nós amamos a liberdade"
Neste exemplo, a frase "Porque nós amamos a liberdade" é exibida às 22 horas e 30
minutos, nos dias 2 e 10, em todos os meses e em todos os dias da semana. O crontab possui 3
comandos básicos que são:
# crontab -e → Permite inserção de novos agendamentos
# crontab -l → Permite listar as tarefas agendadas
# crontab -d → Permite apagar todo o conteúdo agendado
Agendador de Tarefas – AT
Introdução
O comando "AT" pode agendar tarefas de forma semelhante ao cron, e é integrado à
interface de linha de comando do Linux. É muito eficiente se aplicado no agendamento de tarefas
que sejam disparadas somente uma vez. Uma características deste programa é a execução de
aplicativos que tenham passado de seu horário de execução. É muito útil se o computador é
desligado com muita frequência ou quando ocorrer alguma interrupção, nesse caso falta de energia.
Como Usar o AT
O AT permite o controle dos usuários que podem agendar comandos através dos arquivos
“/etc/at.allow” e “/etc/at.deny”. Estes arquivos são organizados no formato de um usuário por linha.
Durante o agendamento é verificado primeiro o arquivo “at.allow“ (listando quem pode executar o
comando) e depois at.deny. Caso eles não existam, o agendamento de comando é permitido a todos
os usuários.
Sintaxe de Comando:
at [opções] time
Onde:
•
Time → Corresponde ao horário em que a tarefa deverá ser executada.
São aceitas horas no formato HHMM ou no formato HH:MM. Outras opções válidas para
horas são:
•
midnight (meia-noite)
•
noon (meio-dia)
•
teatime (hora do chá, ou seja 4:00 PM)
•
now (agora)
Em conjunto com a hora pode-se também especificar o dia da tarefa no formato MMDDAA,
MM/DD/AA ou MM.DD.AA. Além disso, é possível também definir datas como today (hoje) e
tomorrow (amanhã).
Outra forma de definir o horário de execução de uma tarefa é especificar uma hora mais um
contador de tempo. Por exemplo, 8:00 + 3 days marca a tarefa para ser executada daqui a 3 dias às
8:00 horas da manhã. Pode-se usar como contador de tempo os termos:
•
minutes (minutos)
•
hours (horas)
•
days (dias)
•
weeks (semanas).
São algumas das opções deste comando
•
-c tarefa : exibe o conteúdo da tarefa especificada.
•
-d : é um alias para o comando atrm.
•
-f arquivo : a tarefa a ser executa está descrita no arquivo especificado.
•
-l : é um alias para o comando atq.
•
-m : envia um e-mail para o usuário quando a tarefa for concluída.
Para executar algumas tarefas às 20:00 de amanhã, basta digitar
at 20:00 tomorrow
Neste caso, é aberto um editor para que o usuário entre com os comandos. Pode-se digitar
um comando por linha e dar ENTER após cada comando ou pode-se digitar vários comandos por
linha, separando-os por ponto-e-vírgula. Para encerrar o editor, deve-se digitar CTRL+D.
É também possível criar um arquivo com todos os comandos a serem executados e pedir que
o comando “at” o execute na hora desejada. Para o exemplo acima, se os comandos fossem
colocados dentro do arquivo teste, teríamos apenas que digitar
at -f teste 20:00 tomorrow
O root pode usar o comando “at” sem restrições. Para os outros usuários a permissão para
usar este comando é determinada pelos arquivos /etc/at.allow e /etc/at.deny.
As tarefas agendadas ficam armazenadas em /var/spool/at.
O daemon responsável pela execução das tarefas agendadas pelo comando at é o atd. O
script do atd fica armazenado em /etc/rc.d/init.d.
A tarefa agendada com o comando at é executada apenas uma vez. Para agendar tarefas que
devem ser executadas periodicamente, use o comando crontab.
Referencias:
•
http://www.lichti.eti.br/bash-history/comment-page-1 - Acesso em 02 maio 2001
•
http://www.linuxnarede.com.br/artigos/fullnews.php?id=166 – Acesso em 01 de Maio de
2010
•
http://www.vivaolinux.com.br/artigo/Usando-cron-e-crontab-para-agendar-tarefas/?
pagina=2 - Acesso em 01 de Maio de 2010
•
http://focalinux.cipsga.org.br/guia/intermediario/ch-bas.htm - Acesso em 27 de Abril de
2010
•
http://www.vivaolinux.com.br/artigo/Agendando-tarefas-com-o-crontab/?pagina=1 - Acesso
em 27 de Abril de 2010
•
http://www.uniriotec.br/~morganna/guia/at.html - Acesso em 29 de Abril de 2010
DOCUMENTAÇÃO DE RECURSOS DE LINUX
8 Comandos e Utilitários
Faculdade Senac Pelotas
Página 20
DOCUMENTAÇÃO DE RECURSOS DE LINUX
9 Edição de Arquivos de Texto com o VI/VIM
Faculdade Senac Pelotas
Página 21
DOCUMENTAÇÃO DE RECURSOS DE LINUX
10
Gerenciamento de Pacotes
Faculdade Senac Pelotas
Página 22
DOCUMENTAÇÃO DE RECURSOS DE LINUX
11
Gerenciamento de Usuários
Faculdade Senac Pelotas
Página 23