linux_centos

Prévia do material em texto

LINUX 
 
 
 
 
 
Marcio Adroaldo da Silva - 2009 
marcio.infocus@gmail.com 
Conteúdo 
 
Conteúdo .............................................................................................................................................................. 2 
INTRODUÇÃO........................................................................................................................................................ 5 
LINUX .................................................................................................................................................................... 6 
O que é o LINUX ............................................................................................................................................ 6 
História do Linux ........................................................................................................................................... 6 
Software Livre / Código-Aberto .................................................................................................................... 7 
Licença GPL ................................................................................................................................................... 7 
Outras Licenças ............................................................................................................................................. 8 
FSF e o Projeto GNU ..................................................................................................................................... 8 
GNU’s Not Unix ............................................................................................................................................. 8 
Free Software Foundation ............................................................................................................................ 8 
Distribuições ................................................................................................................................................. 9 
Seguindo os Padrões .................................................................................................................................... 9 
Os diversos usos de uma distribuição ........................................................................................................ 10 
Alguns conceitos interessantes .................................................................................................................. 10 
PRINCIPAIS DISTRIBUIÇÕES ................................................................................................................................ 14 
O FEDORA LINUX ................................................................................................................................................ 18 
Principais características ............................................................................................................................ 18 
Histórico das versões estáveis .................................................................................................................... 19 
CentOS ................................................................................................................................................................ 20 
Red Hat x RHEL x CentOS x Fedora ............................................................................................................. 20 
INSTALAÇÃO DO CentOS .................................................................................................................................... 23 
SELINUX .............................................................................................................................................................. 40 
O que é o SELinux ?..................................................................................................................................... 40 
Breve Histórico ........................................................................................................................................... 40 
Por que utilizá-lo ......................................................................................................................................... 40 
SISTEMA DE ARQUIVOS E ESTRUTURA DE DIRETÓRIOS ..................................................................................... 42 
Níveis de execução ............................................................................................................................................. 44 
O SHELL ............................................................................................................................................................... 45 
ALGUNS COMANDOS BÁSICOS ........................................................................................................................... 45 
GRUPOS .............................................................................................................................................................. 50 
Criando um grupo ....................................................................................................................................... 50 
Excluindo um grupo .................................................................................................................................... 50 
USUÁRIOS ........................................................................................................................................................... 50 
Usuário root ................................................................................................................................................ 50 
Usuário de Sistema ..................................................................................................................................... 51 
Usuário normal ........................................................................................................................................... 51 
Criando um usuário .................................................................................................................................... 51 
Modificando um usuário ............................................................................................................................ 52 
Modificando o password ............................................................................................................................ 52 
Excluindo um usuário ................................................................................................................................. 52 
RPM .................................................................................................................................................................... 53 
Utilizando o RPM ........................................................................................................................................ 53 
YUM .................................................................................................................................................................... 57 
Repositórios Adicionais .............................................................................................................................. 59 
CRON .................................................................................................................................................................. 61 
PERMISSÕES DE ARQUIVOS ................................................................................................................................ 62 
Configurações básicas ................................................................................................................................ 62 
Verificação de conta ................................................................................................................................... 63 
Verificação de permissões com ls – l ..........................................................................................................64 
Definindo posse de arquivos e diretórios por usuário com chown ............................................................ 64 
Definindo posse de arquivos e diretórios por grupo com chgrp ................................................................ 65 
O comando chmod .................................................................................................................................... 65 
Definindo permissões de acesso por triplets ............................................................................................. 65 
Definindo permissões de acesso pelo modo numérico .............................................................................. 66 
Processos no Linux ............................................................................................................................................. 67 
O Temido VI ........................................................................................................................................................ 75 
SERVIDOR FTP ..................................................................................................................................................... 83 
O que é FTP ................................................................................................................................................. 83 
Instalando o servidor .................................................................................................................................. 83 
Iniciar e interromper o servidor de FTP ...................................................................................................... 86 
Configurando um cliente ftp para Windows .............................................................................................. 87 
Comandos FTP (Shell) ................................................................................................................................. 97 
SSH .................................................................................................................................................................... 100 
Introdução ................................................................................................................................................ 100 
Configuração do ssh ................................................................................................................................. 100 
Cliente SSH no LINUX ................................................................................................................................ 103 
Cliente SSH no Windows .......................................................................................................................... 104 
Exemplo de configurador DHCP ............................................................................................................... 108 
SAMBA .............................................................................................................................................................. 110 
Adicionando Usuários ao SAMBA ............................................................................................................. 110 
O configurador ......................................................................................................................................... 110 
REFERÊNCIAS .................................................................................................................................................... 115 
 
 
 
 
 
 
 
INTRODUÇÃO 
 
 
 
A presente apostila é uma compilação de diversos materiais encontrados na Internet e 
disponíveis a qualquer pessoa. Apenas foi realizada uma organização diferenciada utilizando 
diversas apostilas e tutoriais, alguns foram adaptados e/ou traduzidos, para atingir um propósito 
específico. Embora utilizemos exemplos de instalação do CentOS,os comandos e soluções aqui 
apresentados, poderão ser utilizadas em qualquer outra distribuição, respeitando as 
particularidades de cada uma delas. 
 No final deste material, estão citadas as fontes de pesquisa, bem como os nomes dos 
autores pesquisados, isso tem como objetivo demonstrar transparência e respeito com aqueles que 
criaram materiais importantes e os deixaram disponíveis para o público em geral. 
 
 
 
 
LINUX 
 
O que é o LINUX 
O Linux é um sistema operacional, ou seja, a interface que gerencia o computador e torna possível a 
sua interação com o usuário. Sendo assim, o Linux é quem controla o gerenciamento dos 
dispositivos físicos (como memória, disco rígido, processador, entre outros) e permite que os 
programas os utilizem para as mais diversas tarefas. Outros sistemas operacionais incluem: a família 
UNIX BSD (FreeBSD, NetBSD, OpenBSD e outros), AIX, HP-UX, OS/2, MacOS, Windows, MS-DOS, 
entre muitos outros. 
O criador do kernel Linux se chama Linus Torvalds, que também é até hoje o mantenedor da árvore 
principal deste kernel. Quando Linus fez o kernel, seguiu os padrões de funcionamento POSIX – os 
mesmos utilizados por todos os sistemas UNIX – e por isso é um sistema operacional bem parecido 
com os outros da família UNIX (mas não igual). Um fato curioso é a origem do nome Linux: o autor 
juntou seu nome ao Unix (Linus + Unix) e o resultando foi Linux. 
Um dos recursos que deixou o Linux mais utilizado é sua alta portabilidade, que faz com que o 
sistema possa ser utilizado em diversas plataformas de hardware: PCs, main-frames, servidores de 
porte, sistemas embarcados, celulares, handhelds, roteadores, entre outros. Além disso, ele é um 
sistema operacional completo, multi-tarefa e multi-usuário, o que significa que vários serviços e 
usuários podem utilizá-lo ao mesmo tempo. Outra característica importante é sua alta capacidade 
de conversar com outros sistemas operacionais, tais quais outros sistemas UNIX, redes Windows, 
Novell, entre outros). 
Além de todas essas funcionalidades, uma das principais e mais importantes características do Linux 
é ele ser um software livre e gratuito (Open Source – ou em português – Código Aberto). Isto 
significa que você não precisa pagar para usá-lo, além de ter a possibilidade de não depender de 
nenhuma empresa que controle o sistema operacional. O código-fonte do núcleo do sistema 
(kernel) está liberado sob a licença GPL e pode ser obtido na Internet por qualquer pessoa, pode 
também ter seu código alterado e re-distribuído, modificando ao seu gosto e suas necessidades, 
caso preciso. Por ser livre, o Linux tem como desenvolvedores vários programadores espalhados 
pelo mundo, de várias empresas diferentes ou até pessoas isoladas, que contribuem sempre 
mandando pedaços de códigos e implementações ao Linus Torvalds, que organiza e decide o que ir 
ao kernel oficial ou não. 
História do Linux 
O criador do Linux – Linus Torvalds – era inscrito em uma lista de discussão de 
programação baseada em UNIX, quando se deparou com a seguinte pergunta: 
“Lembra-se daquela época quando os homens escreviam seus próprios drivers de dispositivos?” 
Ele então resolveu desafiar a si mesmo e criar um sistema operacional onde se pudesse trabalhar 
como em UNIX, executasse em máquinas baratas (PCs) e que não se ficasse preso ao sistema, como 
ele se sentia com sistemas operacionais proprietários. Inspirado em um pequeno e humilde sistema 
feito por Andy Tanembaum – o Minix – Linus trabalhou bastante para desenvolver o Linux. Um 
pouco antes de lançar a primeira versão oficial do kernel, Linus mandou a seguinte mensagem para 
o grupo de notícias comp.os.minix: 
“Você suspira por melhores dias do Minix-1.1, quando homens serão homens e escreverão seus 
próprios drivers de dispositivos? Você está sem um bom projeto e está morrendo por colocar as 
mãos em um sistema operacional o qual você possa modificar de acordo com suas necessidades? 
Você está achando frustrante quando tudo trabalha em Minix? Chega de atravessar noites para 
obter programas quetrabalhem corretamente? Então esta mensagem pode ser exatamente para 
você. 
Como eu mencionei há um mês atrás, estou trabalhando em uma versão independente de um 
sistema operacional similar ao Minix para computadores AT-386. Ele está, finalmente, próximo do 
estágio em que poderá ser utilizado (embora possa não ser o que você esteja esperando) e eu estou 
disposto a colocar os fontes para ampla distribuição. Ele está na versão 0.02… contudo eu tive 
sucesso rodando o bash, gcc, gnu-make, gnu-sed, compressão e etc nele.” 
No dia 5 de Outubro de 1991, Linus Torvalds anunciou a primeira versão oficial do Linux, a versão 
0.02. Desde então, muitos programadores têm respondido ao seu chamado e têm ajudado a fazer 
do Linux o sistema operacional que é hoje. 
Software Livre / Código-Aberto 
Quando um software é lançado, o autor geralmente escolhe uma licença para a sua criação. Esta 
licença é quem vai dizer o que se pode ou o que não se pode fazer com o software disponibilizado. 
Historicamente, com a popularização da informática, as licenças geralmente constituíam uma série 
de restrições para os usuários quanto ao uso do software, como por exemplo: usuários tinham que 
pagar para usar e não podiam modificar ou mexer na sua base de programação. 
Quando Linus Torvalds criou e lançou seu kernel, ele o colocou sob a licença GPL, uma licença criada 
pela fundação GNU que permitia o livre uso dos softwares, protegendo de pessoas mal-
intencionadas. A licença GPL foi uma das responsáveis pela popularização do sistema operacional 
Linux, pois permitia que usuários e desenvolvedores pudessem usar e modificar o sistema de 
acordo com suas necessidades. Além disso, ao mesmo tempo que ela permite liberdades em 
relação ao software, ela também protege o código para que a licença e suas liberdades não sejam 
modificadas. Este tipo de licença permissiva é quem define quando um software é livre, ou é de 
código-aberto. 
Licença GPL 
A licença GPL permite que o autor distribua livremente o seu código, oferecendo assim 4 liberdades: 
1. A liberdade de executar o programa, para qualquer propósito; 
2. A liberdade de estudar como o programa funciona e adaptá-lo para as suas necessidades; 
3. A liberdade de redistribuir cópias de modo que você possa ajudar ao seu próximo; 
4. A liberdade de aperfeiçoar o programa, e liberar os seus aperfeiçoamentos, de modo que 
toda a comunidade se beneficie deles. 
Em outras palavras, todos podem utilizar, modificar e redistribuir o software (e inclusive as 
modificações), contanto que tudo isto seja feito respeitando e mantendo a mesma licença GPL. Isso 
permite que o software nunca seja fechado, assim pessoas mal-intencionadas não podem fazer uso 
desleal do código. 
Outras Licenças 
Além da GPL, há uma grande quantidade de outras licenças que permitem o uso livre dos softwares. 
Podemos citar alguns exemplos como a LGPL, Original BSD, Modified BSD, Apache License, Intel 
Open Source License, Mozilla Public License, entre muitas outras. 
FSF e o Projeto GNU 
A FSF – Free Software Foundation (Fundação do Software Livre, em português) – criada em 1985 
por Richard M. Stallman é uma fundação sem fins lucrativos com o objetivo de incentivar o 
movimento do software livre. A FSF foi pioneira na discussão e criação de softwares livres no 
mundo, em uma época em que tudo estava tendendo ao software pago. 
GNU’s Not Unix 
O Projeto GNU foi o berço do software livre. Iniciado em 1984 e idealizado por Richard Stallman, 
seu propósito era criar um sistema operacional livre, de código-aberto. Stallman começou com a 
idéia criando o editor de textos emacs, que foi muito bem recebido ao seu redor, depois 
contemplando o projeto com outros pedaços de software como o compilador gcc. 
Depois de algum tempo, o projeto GNU tinha todas as ferramentas prontas para os usuários 
utilizarem, mas faltava apenas uma coisa: o kernel. Sem um kernel próprio e livre, o ideal de 
software livre do projeto GNU não poderia ser alcançado. O kernel escolhido para ser utilizado no 
sistema operacional GNU é o GNU HURD, um tipo de micro-kernel que havia sido iniciado em 1990. 
Porém, a implementação deste kernel nunca andou muito rápido. Por essa razão, um estudante da 
Finlandia chamado Linus Torvalds criou um kernel chamado Linux e utilizou todas as ferramentas do 
projeto GNU nele. Como o kernel era livre, rapidamente as pessoas ao redor do projeto GNU 
começaram a utilizá-lo e apesar de não ser considerado oficial, o Linux acabou se tornando o kernel 
principal do sistema GNU. 
Por essa razão, muitas pessoas utilizam o termo “GNU/Linux” para chamar o sistema operacional 
que tem como kernel o Linux e muitas de suas ferramentas básicas do projeto GNU. Essa questão é 
bastante polêmica e gera muitas controvérsias, pois atualmente não se usa apenas as ferramentas 
GNU: as distribuições possuem vários outros programas de diversos projetos diferentes. 
Free Software Foundation 
Em 1985, Richard Stallman criou a Free Software Foundation, uma organização sem fins lucrativos 
que atua na defesa do software livre e suas licenças. A FSF cuida de licenças como a GPL, 
importantes na implantação e adoção do software livre no mundo. Além disso, ela também 
gerencia o projeto GNU, auxiliando todo o grande número de programas que participam do projeto. 
A Free Software Foundation tem sua sede em Boston, MA, EUA. Além da sede, ela também tem 
filiais na América Latina, Europa e Índia. 
 
Richard Stallman 
Fundador e criador de várias políticas sobre softwares livres, Richard Stallman pode ser considerado 
um dos pais do software livre. Até os dias de hoje (2008), Stallman continua atuando como 
articulador pela Free Software Foundation. Defendendo o software livre e a GPL com todas suas 
forças. 
Distribuições 
Quando Linus lançou a primeira versão do Linux em 1991, ele utilizou boa parte do conjunto de 
ferramentas do kernel GNU para trabalhar junto ao kernel, afinal o kernel sozinho não poderia fazer 
nada de útil em relação à interface com o usuário. Para usar todas as ferramentas, ele teve que 
construí-las especificadamente para o seu kernel e uní-las para apresentar ao usuário uma interface 
para o uso do computador. Enquanto o kernel trabalhava com o hardware, as ferramentas 
trabalhavam servindo como ponte entre o usuário e o kernel. 
O processo de montagem do kernel com estas ferramentas pode ser muito trabalhoso. Algumas 
empresas e pessoas viram isso como uma grande barreira para adoção do sistema: como usuários 
que não eram tão avançados conseguiriam utilizar o sistema operacional? 
Esta questão foi resolvida com o surgimento das distribuições. As empresas e pessoas criaram 
processos de empacotamento do kernel e ferramentas diversas e forneciam aos usuários o pacote 
todo pronto: uma distribuição. Os usuários obtiam cópias de disquetes ou CDs através de amigos ou 
pela Internet e instalavam em suas máquinas através dos sistemas de instalação que as empresas e 
pessoas por trás das distribuições fizeram, tornando assim o trabalho muito mais fácil. 
Com o tempo, as distribuições ficaram cada vez mais complexas, utilizando várias outras 
ferramentas além das do projeto GNU, se tornando verdadeiros sistemas operacionais que 
poderiam ser aproveitados por uma vasta base de usuários. 
Uma das reações mais comuns entre as pessoas quando elas dizem que utilizam o Linux é 
perguntar: “Qual a sua distribuição Linux?”. Como o kernel Linux e suas ferramentas são softwares 
livres, este processo de empacotamento em uma distribuição poderia ser feito por qualquer um que 
entendesse do sistema. Por isso, cada empresa ou pessoa construiu sua distribuição de acordo com 
o que eles achavam que seria o melhor. Com isso, cada distribuição acaba tendo algumas 
características específicas que as diferenciam das outras, criando assim o gosto pela adoção nas 
pessoas. Enquanto uma pessoa utiliza a distribuição X, outra pessoa utiliza a distribuição Y e uma 
terceira pessoa a distribuição F. 
Atualmentetemos disponíveis centenas de tipos diferentes de distribuição, para todos os gostos. 
Seguindo os Padrões 
Quando centenas de distribuições começaram a aparecer, cada uma estava fazendo tudo do seu 
jeito. Apesar da liberdade de escolha ser algo bom, a falta de padrões poderia por em risco a 
utilização das distribuições Linux em geral, pois umas acabariam se tornando totalmente 
incompatíveis com as outras, como se fossem sistemas operacionais totalmente diferentes. 
Para resolver esta questão, criou-se alguns padrões que as distribuições procuram seguir para 
manter a interoperabilidade intacta: 
• FHS – http://www.pathname.com/fhs/ – Padrão que especifica a localização de arquivos e 
diretórios, juntamente com a especificação de qual seus papéis no sistema operacional. 
• LSB – http://www.linuxbase.org – Um tipo de extensão ao FHS, que fornece modelos de 
teste para as distribuições possuírem a garantia de seguidoras do padrão LSB. Com esta 
garantia, as distribuições garantem que quando seguirem o padrão LSB, irão ser 
interoperáveis: ou seja, as aplicações que funcionam em uma funcionarão em todas. 
Os diversos usos de uma distribuição 
Como cada distribuição tem suas próprias características, é crucial sabermos que há tipos de 
distribuições realmente especializadas em fazer uma coisa em específico, como também há outras 
que adotam um uso mais genérico. 
Uma distribuição Linux pode ser utilizada em diversas áreas como um servidor: firewalls, 
roteadores, servidores Web e FTP, servidores de e-mail, banco de dados, backup, entre muitos 
outros. Também pode ser utilizada para desktop: através de ambientes gráficos como o KDE, 
GNOME, XFCE, entre outros, os usuários tem acesso a programas que criam uma interface amigável 
para o usuário, além de fornecer as ferramentas para se trabalhar em: manipulação de imagens, 
desenvolvimento Web, visualização de textos e apostilas, navegação na Internet, editoração gráfica, 
jogos, música e vídeos, entre muitos outros. 
Existem distribuições que ocupam um espaço mínimo (50MB), geralmente para computadores mais 
antigos e com poucos recursos; outras distribuições feitas diretamente para rodar de um CD, DVD 
ou até pen-drive, sem precisar instalar o sistema operacional, geralmente utilizadas para 
demonstração do sistema, para uso emergencial ou para reparos em um computador; outras são 
feitas especialmente para serem executadas pela rede, sem a necessidade de um HD; e até as 
distribuições que são utilizadas nos dispositivos que usamos no dia-a-dia: tocadores de mp3, 
celulares, roteadores (wireless ou não), modems, câmeras, dispositivos de TV, entre muitos outros. 
Um bom ponto de partida para se conhecer muitas distribuições é o site Distrowatch – 
http://www.distrowatch.com (em inglês) – que contém uma lista gigante de distribuições, seus 
conteúdos, descrições e objetivos 
 
Alguns conceitos interessantes 
POSIX 
POSIX (acrônimo para Portable Operating System Interface, que pode ser traduzido como Interface 
Portável entre Sistemas Operacionais) é uma família de normas definidas pelo IEEE e designada 
formalmente por IEEE 1003, que tem como objetivo garantir a portabilidade do código-fonte de um 
programa a partir de um sistema operacional que atenda as normas POSIX para outro sistema 
POSIX, desta forma as regras actuam como uma interface entre sistemas operacionais distintos. A 
designação internacional da norma é ISO/IEC 9945. 
A normatização das especificações POSIX surgiu de um projecto, iniciado por volta de 1985, que 
tinha como objectivo normatizar a API (ou interface de programação de aplicativos) para software 
desenhado para correr em variantes do sistema operativo (ou sistema operacional, no Brasil) UNIX. 
O termo POSIX foi sugerido por Richard Stallman em resposta a um pedido da IEEE de um nome fácil 
de lembrar. É uma sigla aproximada de Portable Operating System Interface, com o X a representar 
a herança que o interface de programação de aplicações tem do sistema UNIX. 
A norma POSIX especifica os interfaces do utilizador e do software ao sistema operativo em 15 
documentos diferentes. A linha de comando e interface de comandos padrão é a Korn Shell. Outros 
programas de nível de usuário, serviços e utilitários incluem, entre centenas de aplicações, awk, 
echo e ed. Os serviços de nível de programa necessários incluem serviços de I/O (ficheiro, terminal e 
internet) básicos. 
Atualmente a sua documentacao e dividida em 3 partes: 
• POSIX Kernel APIs que inclui: 
o Extensões para o POSIX.1, 
o Serviços de tempo real, 
o Interfaces com threads, 
o Extensoes de tempo real, 
o Interface segura, 
o Acesso a arquivos via rede e 
o Comunicações entre processos via rede 
• Comandos e utilitarios POSIX 
o Com extensões de portabilidade para o usuário, 
o Correções e utilidades de proteção e 
o Controle para utilidades do sistema Batch 
• Teste de adequacao POSIX 
Um pacote de teste da norma POSIX acompanha a documentação da norma. É designada por POSIX 
Conformance Test Suite (PCTS). 
Como a IEEE tem vindo a cobrar somas avultadas pela documentação da norma POSIX e não 
permite a publicação online das normas, tem havido uma tendência para adopção da "Single UNIX 
Specification", da responsabilidade do Open Group, que é aberta, aceita contribuições de todos e 
encontra-se disponível na Internet. 
Apesar de terem sido feitas para sistemas Unix, os padrões POSIX podem ser aplicados a qualquer 
sistema operacional.Para sistemas Linux, várias extensões e normalizaçõe 
 
Instituto de Engenheiros Eletricistas e Eletrônicos - IEEE 
O Instituto de Engenheiros Eletricistas e Eletrônicos ou IEEE (pronuncia-se I-3-E, ou, conforme a 
pronúncia inglesa, eye-triple-e) é uma organização profissional sem fins lucrativos, fundada nos 
Estados Unidos. É a maior (em número de sócios) organização profissional do mundo. O IEEE foi 
formado em 1963 pela fusão do Instituto de Engenheiros de Rádio (IRE) com o Instituto Americano 
de Engenheiros Elétricistas (AIEE). O IEEE tem filiais em muitas partes do mundo, sendo seus sócios 
engenheiros eletricistas, engenheiros da computação, cientistas da computação, profissionais de 
telecomunicações etc. Sua meta é promover conhecimento no campo da engenharia elétrica, 
eletrônica e computação. Um de seus papéis mais importantes é o estabelecimento de padrões 
para formatos de computadores e dispositivos. 
Geralmente participa em todas as atividades associadas com organizações profissionais: 
• Editando e publicando jornais. 
• Estabelecendo atividades de padrões baseadas em consenso. 
• Organizando conferências. 
• Promovendo publicações técnicas, de seus próprios jornais, padrões e textos de membros. 
Grupos de Interesse 
A organização da IEEE inclui a existência de dezenas de grupos de interesse, sendo que o maior 
deles é quase uma associação própria, a IEEE Computer Society. 
Ações Voluntárias 
O IEEE promove, através de seus ramos estudantis, oportunidades para os universitários 
promoverem atividades sociais e ciêntíficas em suas universidades. Adicionalmente, existem 
capítulos profissionais dos seus Grupos de Interesse e capítulos focados para os formados na última 
década, chamado GOLD. 
 
The Open Group 
 The Open Group é um consórcio formado por empresas da indústria de informática para 
estabelecer padrões abertos para a infra-estrutura de computação. Surgiu em 1996 com a fusão do 
consórcio X/Open com a Open Software Foundation. O Open Group é mais conhecido por ser o 
proprietário da marca UNIX, mas também é lembrado pela publicação da Single UNIX 
Specification[1], que estende os padrões POSIX e é a definição oficial do UNIX. Dentre os seus 
membros estão vendedores e compradores de produtos de informática além de agências 
governamentais como, por exemplo, Capgemini, Fujitsu, Hitachi, HP, IBM, NEC, Departamento de 
Defesa dos Estados Unidos da América, NASA e outros. 
História 
Por volta dos anos 90 a maioria dos fornecedores de sistemas Unix entendeu que a rivalidadeexistente entre eles, que redundou na chamada guerra do Unix, estava causando mais prejuízo que 
benefício, enfraquecendo o Unix perante a competição que surgia a partir da Microsoft. A iniciativa 
COSE, em 1993, pode ser considerada como o primeiro passo no sentido de uma unificação e a 
fusão da Open Software Foundation (OSF) com a X/Open, em 1996, como o último passo para o fim 
dos conflitos. Como a OSF já havia se unido com a UNIX International em 1994, a nova entidade 
teve a representatividade necessária para reunir todos os elementos da comunidade Unix. 
O valor da marca UNIX diminuiu devido às mudanças no mercado de sistemas operacionais, 
principalmente devido à aceitação de sistemas do tipo Unix "não padronizados", como o Linux. 
Recentemente foi iniciado um esforço pelo Open Group em conjunto com a Linux Foundation para 
ajudar no trabalho de padronização do Linux através da especificação Linux Standard Base. 
Programas 
Os serviços mais conhecidos do Open Group são as suas certificações, incluindo certificações para a 
plataforma Common Operating Environment (COE), CORBA, LDAP, POSIX, SIF, UNIX e WAP. O Open 
Group também oferece certificações para profissionais da área de informática, através de 
programas para arquitetos de sistemas como o IT Architect Certification e o TOGAF (The Open 
Group Architecture Framework). 
O Open Group fornece uma plataforma para que seus membros discutam necessidades, e 
trabalhem conjuntamente no desenvolvimento e adoção de padrões da indústria e para facilitar a 
integração das corporações. Também disponibiliza serviços para o setor governamental, agências e 
qualquer companhia ou organização criada por governos para auxiliar na busca pelos objetivos de 
governo. 
 Invenções e padrões 
• Call Level Interface (a base do ODBC) 
• Common Desktop Environment (CDE) 
• Distributed Computing Environment (a base do DCOM) [4] 
• Distributed Relational Database Architecture (DRDA) 
• LDAP (Lightweight Directory Access Protocol) 
• Motif um toolkit de wikgets para GUI (utilizado no CDE) 
• Single UNIX Specification (POSIX) 
• X Window System 
 
 
 
 
PRINCIPAIS DISTRIBUIÇÕES 
 
 
Debian é simultaneamente o nome de uma distribuição não comercial livre (gratuita e de código 
fonte aberto) de GNU/Linux (amplamente utilizada) e de um grupo de voluntários que o mantêm à 
volta do mundo. Uma vez que o Debian se baseia fortemente no projeto GNU (e a distribuição 
oficial do Projeto GNU é Debian), é usualmente chamado Debian GNU/Linux. O Debian é 
especialmente conhecido pelo seu sistema de gestão de pacotes, chamado APT, que permite: 
atualizações relativamente fáceis a partir de versões realmente antigas; instalações quase sem 
esforço de novos pacotes e remoções limpas dos pacotes antigos. 
O projeto Debian é mantido por doações através da organização sem fins lucrativos Software in the 
Public Interest (SPI). 
 
O nome Debian vem dos nomes dos seus fundadores, Ian Murdock e de sua mulher, Debra. A 
palavra "Debian" é pronunciada em Português como Débian. Várias distribuições comerciais 
baseiam-se (ou basearam-se) no Debian, incluindo: Lindows (atual Linspire), Xandros, Kurumin, 
Debian-BR-CDD e Libranet. O Ubuntu Linux também se baseia em Debian. Está atualmente a 
decorrer trabalho para portar o Debian para outros kernels livres para além do Linux, incluindo o 
Hurd e o BSD. Para já, no entanto, ainda é muito mais preciso descrever o Debian como uma 
"Distribuição Linux", sem mais qualificações. 
 
Fedora Core é uma distribuição Linux baseada em pacotes RPM, criada pela Red Hat. Atualmente 
mantida pelo Projeto Fedora (Fedora Project). Sua instalação é semelhante a versão 9 do Red Hat, 
em computadores com mais de 1GHz de processamento e 256 de MB de memória RAM, a 
instalação padrão demora cerca de 30 minutos. Depois da instalação o GNOME fica como gestor de 
desktop padrão, podendo ser mudado para o KDE, WindowMaker, etc. Já vem com o browser 
Mozilla Firefox, com OpenOffice.org e suporte com idiomas, além uma diversidade de programas 
para servidores e desktops domésticos. 
 
História 
 
Os usuários da versão Red Hat 9 estavam aguardando a versão 10 ou 9.1 da distribuição. Mas na 
verdade a Red Hat estava com outros planos para a nova versão. Esta distribuição era 
comercializada em caixas e disponível nas lojas. Quem assim o adquiria, procurava por mais 
recursos. Esta era a versão Enterprise Linux. A Redhat decidiu então continuar apenas com a Red 
Hat Enterprise Linux, que era o que lhe trazia lucros significativos. Afim de proteger sua marca a Red 
Hat decidiu registrar sua marca como Fedora a versão normal do Linux. É necessário destacar que o 
Fedora Core não é um produto pertencente a Red Hat. 
 
Projeto Fedora 
O Projeto Fedora é uma comunidade independente baseada no código fonte aberto, ela é 
responsável por manter a distribuição Fedora Core. O objetivo desse projeto é possibilitar que 
desenvolvedores da equipe da Red Hat e usuários da comunidade Linux trabalhem para construir 
um sistema operacional completo e versátil totalmente livre, sem custos de licenças ou custo de 
suporte. As versões testes foram iniciadas a partir de Julho de 2003 e em Março de 2004 saiu a 
primeira versão do Fedora Core. A versão mais recente é o Fedora Core 6. 
 
O Fedora Core é um sistema voltado para uso em desktops e servidor derivado do Red HatLinux 
(uma das distribuições linux mais populares) que mantém algumas de suas caracteristicas como: 
 
·Fácil utilização para usuários inexperientes em Linux 
·Instalador Anaconda, que facilita a instalação 
·Gestor de desktop GNOME (também inclui o KDE) 
·Drivers de periféricos novos 
·Sistema de actualização 
·Inumeros programas divididos por temas, que podem ser selecionados na instalação 
 
 
 
 
Gentoo Linux é uma distribuição gratuita do sistema operacional GNU/Linux baseada na GNU 
General Public License. O diferencial do Gentoo Linux, em relação às outras distribuições, está no 
uso da ferramenta Portage de que dá ao usuário a possibilidade de ter um sistema adaptado ao seu 
perfil, pois cada pacote é compilado durante a instalação, de forma automatizada, optimizada e 
com todas as dependências resolvidas. Devido a essas características o Gentoo Linux é considerado 
uma meta-distribuição. 
Esta distribuição é direcionada para usuários avançados ou experientes, devido à complexidade de 
executar tarefas que em outras distribuições são realizadas de forma simples, porém é aconselhada 
também a todos que queiram saber o máximo sobre GNU/Linux. Quando bem instalada e 
configurada, torna-se a distribuição mais veloz, executando programas emulados mais rápido que o 
próprio Windows. 
Algumas características do Gentoo Linux: 
·Suporte a várias plataformas, incluíndo: x86, AMD64, PowerPC, UltraSparc e Alpha. 
·Últimas versões estáveis do KDE , GNOME e Xfce. 
·Ambiente de desenvolvimento GNU moderno. 
·Suporte a diversos sistemas de arquivos: ReiserFS, XFS, ext2, ext3, JFS, EVMS e LVM. 
·Suporte à hardware: NVIDIA, Creative Labs Live! e Audigy. 
·OpenGL modular. 
·Cerca de 10000 pacotes de softwares disponíveis no Portage. 
 
 
 
Kubuntu é um projeto derivado do Ubuntu, uma distruibuição do sistema operacional GNU/Linux. 
Na verdade o Kubuntu e o Ubuntu (assim como Xubuntu e Edubuntu) são o mesmo projeto, mas ao 
contrário do Ubuntu, que vem com o ambiente gráfico Gnome, ele suporta o KDE e programas 
feitos para KDE, como o navegador Konqueror, Kontact (para emails, RSS e calendário) e Amarok, o 
tocador de músicas. 
A proposta do Kubuntu é oferecer um sistema operacional/operativo onde qualquer pessoa possa 
utilizá-lo, sem dificuldades, independente de nacionalidade, nível de conhecimento ou limitações 
físicas. A distribuição deve ser constituída totalmente de software gratuito e livre, além de isenta de 
qualquer taxa. Atualmente uma organização cuida para que cópias sejam remetidas em CDs para 
todo o mundo semcustos. 
A Comunidade Kubuntu/Ubuntu se ajuda mutuamente, não havendo distinção de novatos ou 
veteranos; a informação deve ser compartilhada para que se possa ajudar quem quer que seja, 
independente do nível de dificuldade. 
 
 
 
Mandriva é junção do nome das duas empresas MandrakeSoft e Conectiva. A Mandriva Conectiva é 
a operação brasileira da Mandriva, desenvolvedora e distribuidora do sistema operacional Mandriva 
Linux, resultado da fusão ocorrida em 24 de fevereiro de 2005 entre a MandrakeSoft, uma das 
principais distribuições Linux da Europa, com atuação mundial em mais de 120 países, e a 
Conectiva, pioneira na distribuição Linux e código aberto em português, espanhol e inglês para toda 
a América Latina. A Mandriva possui escritórios nos Estados Unidos, França e Brasil, tem mais de 8 
milhões de usuários e uma carteira de 170 grandes clientes corporativos, além de contar com 130 
funcionários. 
 
 
SuSE / SLED 10 / SLES 10 / openSUSE 
 
O que é o Projecto openSUSE? 
 
O projecto openSUSE é uma programa para uma comunidade apoiado pela Novell. Promovendo o 
uso do Linux pelo mundo fora, este programa permite um acesso fácil e gratuito à distribuição mais 
amigável do mundo, o SUSE Linux. OpenSUSE fornece tudo o que programadores e entusiastas 
precisam para começar a usar o Linux. Localizado em opensuse.org, o projeto permite aceder 
facilmente a novas versões estáveis e de desenvolvimento. 
 
 
 
 
 
O FEDORA LINUX 
 
Fedora (antigamente chamado Fedora Core) é uma distribuição Linux baseada em pacotes RPM, 
criada pela Red Hat. Atualmente mantida pelo Projeto Fedora (Fedora Project). Sua instalação é 
semelhante a versão 9 do Red Hat, em computadores com mais de 1GHz de processamento e 256 
de MB de memória RAM, a instalação padrão demora cerca de 30 minutos. Depois da instalação o 
GNOME fica como gestor de desktop padrão, podendo ser mudado para o KDE, WindowMaker, 
XFCE e etc. Já vem com o browser Mozilla Firefox, com OpenOffice.org e suporte a diversos idiomas, 
além de uma grande diversidade de programas para servidores e desktops. Novas versões do 
Fedora são lançadas aproximadamente a cada 6 meses, tendo como padrão três versões-teste para 
validação e correção de bugs, reportados através do sistema bugzilla do projeto. 
Os usuários da versão Red Hat 9 estavam aguardando a versão 9.1 ou 10 da distribuição, mas na 
verdade a Red Hat estava com outros planos para a nova versão. Esta distribuição era 
comercializada em caixas e disponível nas lojas. Quem assim o adquiria, procurava por mais 
recursos. Esta era a versão Enterprise Linux. A Redhat decidiu focar o mundo corporativo com o Red 
Hat Enterprise Linux e descontinuou sua versão voltada para a comunidade, lançando o Projeto 
Fedora e registrando esta nova marca, desvinculando esta nova distribuição de suas marcas. 
O Fedora representa um conjunto de projetos patrocinados pela Red Hat e direcionados pelo 
Projeto Fedora. Estes projetos são desenvolvidos por uma imensa comunidade internacional de 
pessoas focadas em prover e manter as melhores iniciativas através dos padrões livres do software 
de fonte aberto. A Distribuição GNU/Linux Fedora , projeto central do Fedora, é um sistema 
operacional baseado no Linux, sempre gratuito para ser usado, modificado e distribuído por 
qualquer pessoa. 
As versões testes do Fedora foram iniciadas a partir de Julho de 2003 e em Março de 2004 saiu a 
primeira versão estável. 
Principais características 
 
• Fácil utilização, mesmo para usuários inexperientes em GNU/Linux. 
• Instalador Anaconda, um dos mais fáceis utilizados atualmente. 
• Gestor de desktop GNOME e KDE. 
• Inclui diversos Drivers de periféricos atualizados, facilitando a detecção de hardwares mais 
novos. 
• Possui diversas interfaces de configuração (Rede, Video, Som, Segurança, Teclado, Samba, 
Serviços e etc) facilitando a administração e configuração do sistema. 
• Sistema para gerenciamento de pacotes Yum e atualizador de pacotes PackageKit(a partir do 
Fedora 9). 
• Inumeros programas divididos por temas, que podem ser selecionados na instalação ou 
através do gerenciador de pacotes. 
• LiveCDs instaláveis com Gnome e/ou KDE disponíveis oficialmente a partir da versão 7. 
• A partir da versão 7, inclui o REVISOR, uma ferramenta de facil utilização para que qualquer 
pessoas possa gerar sua versão LiveCD ou DVD baseado no Fedora. 
• Disponível em CDs e DVDs. 
• Disponível nas arquiteturas x86, x86_64 e PPC. 
• Traduzido e Documentado em Português pelo Projeto Fedora Brasil. 
 
Histórico das versões estáveis 
 
Versão Data de lançamento Codinome Descrição 
Fedora Core 1.0 5 de novembro de 2003 "Yarrow" kernel 2.4 
Fedora Core 2.0 18 de maio de 2004 "Tettnang" kernel 2.6, KDE 3.2 e GNOME 2.6 
Fedora Core 3.0 8 de novembro de 2004 "Heidelberg" kernel 2.6, GNOME 2.8 e KDE 3.3 
Fedora Core 4.0 13 de junho de 2005 "Stentz" kernel 2.6, GNOME 2.10, KDE 3.4 e o GCC 4.0 
Fedora Core 5.0 20 de março de 2006 "Bordeaux" kernel 2.6.15, GNOME 2.14, e o GCC 4.1 
Fedora Core 6.0 24 de Outubro de 2006 "Zod" kernel 2.6.18.1, GNOME 2.16, e o GCC 4.1.1 
Fedora 7.0 31 de Maio de 2007 "Moonshine" kernel 2.6.21, GNOME 2.18,KDE 3.5.6. e o Python 2.5 
Fedora 8.0 8 de Novembro de 2007 "Werewolf" kernel 2.6.23, GNOME 2.20,KDE 3.5.8. e o Python 2.5 
Fedora 9.0 13 de Maio de 2008 "Sulphur" kernel 2.6.25, GNOME 2.22.1,KDE 4. e o Python 2.5.1 
 
 
 
CentOS 
O CentOS é uma versão gratuita do Red Hat Enterprise, gerado a partir do código fonte 
disponibilizado pela Red Hat e mantido de forma bastante competente por um grupo de 
desenvolvedores, que combina representantes de diversas empresas que utilizam o sistema 
(sobretudo empresas de hospedagem) e voluntários. 
Ele é, basicamente, uma versão gratuita do RHEL, que possui um excelente histórico de segurança e 
conta com uma boa estrutura de suporte comunitário e atualizações pontuais de segurança, 
qualidades que o tornam uma das distribuições Linux mais populares em servidores, sobretudo em 
servidores web. 
Se você está interessado na estabilidade do Red Hat Enterprise, ou precisa rodar softwares como o 
Oracle, que são suportados apenas nele, mas não tem como pagar caro pelo sistema, o CentOS é a 
sua melhor opção. 
Red Hat x RHEL x CentOS x Fedora 
Para quem está chegando agora, o Red Hat Linux foi uma das primeiras distribuições Linux a 
conquistar um grande público. A primeira versão foi lançado em 1994 e o sistema conseguiu ganhar 
espaço tanto entre os desktops (devido à relativa facilidade de uso) quanto entre os servidores, 
devido à boa estabilidade do sistema. O Red Hat Linux foi descontinuado em 2004, dando lugar ao 
Fedora, que é desenvolvido de forma colaborativa e às diferentes versões do Red Hat Enterprise 
(também chamado de RHEL), a versão comercial do sistema, destinada a grandes empresas. 
O Red Hat Enterprise possui um ciclo de desenvolvimento mais lento (que prioriza a estabilidade) e 
tem suas versões suportadas por um período de nada menos do que 7 anos após o lançamento. 
Para quem está acostumado com o rápido ritmo de desenvolvimento das distribuições Linux 
domésticas, um sistema que é suportado por 7 anos pode soar estranho, mas dentro do ramo 
corporativo este é um diferencial importante, já que atualizar os desktops e os servidores é sempre 
um processo arriscado e caro (devido à mão de obra necessária, necessidade de treinar os 
funcionários, etc.), de forma que ciclos de desenvolvimento mais lentos e previsíveis são preferidos. 
Veja o caso do Windows, por exemplo, muitas empresas ainda usam servidores com o 2000 Server, 
ou mesmo com o NT 4. 
O RHEL é fornecido apenas em conjunto com um plano de suporte e não pode ser redistribuído em 
seu formato binário. Entretanto, todo o código fonte está disponível, de forma que alguém que 
pacientemente compile cada um dos pacotes disponibilizados pela Red Hat, acaba obtendo uma 
cópia completa do sistema, que pode ser usada paratodos os fins. 
O CentOS nada mais é do que um Red Hat Enterprise compilado a partir do código fonte 
disponibilizado pela Red Hat, com os logotipos as marcas registradas removidas. Isso garante que os 
dois sistemas sejam binariamente compatíveis (ou seja, um software compilado para rodar no Red 
Hat Enterprise roda também na versão correspondente do CentOS sem precisar de modificações) e 
todos os passos de instalação e configuração dos dois sistemas são idênticos, o que faz com que 
toda a documentação do Red Hat Enterprise se aplique também ao CentOS. 
Ao aprender a trabalhar com o CentOS, você automaticamente aprende a trabalhar com o Red Hat 
Enterprise e vice-versa. A grosso modo, podemos dizer que o Fedora é uma versão comunitária de 
desenvolvimento do Red Hat Enterprise, enquanto o CentOS é uma cópia praticamente exata do 
sistema. 
Com relação às versões, o Red Hat Enterprise 4 foi baseado no Fedora Core 3, enquanto o Red Hat 
Enterprise 5 foi baseado no Fedora Core 6 e o Red Hat Enterprise 6 será baseado no Fedora 9. As 
versões do CentOS seguem as versões do Red Hat Enterprise, de forma que o CentOS 5 corresponde 
ao Red Hat Enterprise 5 e assim por diante: 
Fedora Core 3 > Red Hat Enterprise Linux 4 > CentOS 4 
Fedora Core 6 > Red Hat Enterprise Linux 5 > CentOS 5 
Fedora 9 > Red Hat Enterprise Linux 6 > CentOS 6 
Novas versões do Red Hat Enterprise são disponibilizadas a cada 18 ou 24 meses, mas recebem um 
grande volume de atualizações e correções de segurança durante este período. Isso leva ao 
lançamento de sub-versões com as atualizações pré-instaladas, como o Red Hat Enterprise 4.6 e o 
Red Hat Enterprise 5.1, que são sempre seguidas pelas versões correspondentes do CentOS. 
Assim como o sistema principal, as atualizações e correções de segurança são disponibilizados pela 
equipe do CentOS, novamente através de pacotes compilados a partir dos códigos fontes 
disponibilizados pela Red Hat. As atualizações do CentOS são tipicamente disponibilizadas entre 24 
e 72 horas depois das do Red Hat Enterprise (o que é impressionante considerando que se trata de 
um projeto voluntário), mas muitas atualizações críticas são disponibilizadas muito mais rápido, em 
poucas horas. Assim como o Red Hat Enterprise, todos os releases do sistema são suportados 
recebem atualizações de segurança por um período de 7 anos. Com isso, o CentOS 4 será suportado 
até 2012 e o CentOS 5 será suportado até pelo menos 2013. 
A grande diferença entre o CentOS e o Red Hat Enterprise é a questão do suporte, já que, embora 
caro, o suporte oferecido pela Red Hat é bastante personalizado e os profissionais passam por um 
exame de certificação exigente (o RHCE) que mistura testes teóricos e práticos. Em servidores de 
missão crítica, usar o Red Hat Enterprise e pagar pelo suporte é geralmente uma boa opção, já que 
além de ajuda na implementação, você tem uma equipe pronta para agir em caso de problemas 
inesperados. Para os demais casos, você pode perfeitamente utilizar o CentOS contando com o 
suporte comunitário oferecido através dos fóruns do projeto. 
O CentOS é também bastante similar ao Fedora, mas nesse caso as diferenças são mais evidentes, já 
que versões recentes do Fedora são baseadas em pacotes mais atuais, o que invariavelmente leva a 
mudanças no sistema. De qualquer forma, os passos básicos de instalação e a configuração geral 
dos dois sistemas são praticamente iguais, de forma que as dicas desse tópico se aplicam também 
ao Fedora. 
Comparar o CentOS e o Fedora para uso em servidores desperta argumentos similares aos de uma 
comparação entre o Ubuntu e o Debian. O CentOS segue as versões do Red Hat Enterprise, que 
possui um ciclo de desenvolvimento muito mais longo, onde a principal preocupação é a 
estabilidade do sistema. O Fedora, por sua vez, é desenvolvido em torno de ciclos muito mais 
curtos, com uma nova versão sendo disponibilizada a cada 6 meses. 
Por um lado isso é bom, já que você tem acesso a versões mais atuais dos pacotes, mas por outro 
lado é ruim, pois o lançamento mais freqüente de novas versões aumenta sua carga de trabalho 
como administrador, já que o sistema precisa ser atualizado mais freqüentemente. 
Além de serem mais espaçadas, as versões do CentOS recebem atualizações de segurança por um 
período muito mais longo, que torna a vida útil das instalações muito maior. Um servidor rodando a 
versão mais atual do CentOS poderia ser mantido em serviço por até 7 anos, recebendo apenas as 
atualizações de segurança, o que não seria possível no Fedora, onde o suporte às versões antigas é 
encerrado muito mais rapidamente. 
Em resumo, se você não se importa de utilizar softwares ligeiramente antigos e quer um servidor 
que ofereça um baixo custo de manutenção e possa ser usado durante um longo período sem 
riscos, o CentOS é mais recomendável. Se, por outro lado, você precisa de versões recentes do 
Apache, Samba ou outros serviços, ou se tem alguma preferência pessoal em relação ao Fedora, 
também pode utilizá-lo sem medo. 
Embora o Fedora seja em teoria menos estável que o CentOS, ambas as distribuições podem ser 
consideradas bastante estáveis. Poderíamos dizer que o CentOS é "99% estável" enquanto o Fedora 
é "98% estável". Ou seja, existe diferença, mas ela é relativamente pequena. 
 
INSTALAÇÃO DO CentOS 
 
1. Coloque o DVD no seu servidor ou computador e coloque o boot pelo seu DVD/CD. 
2. Será exibida esta tela. Existem várias opções de instalação. No nosso exemplo, tecle Enter. 
 
Na próxima tela é possível fazer um teste das mídias. Este teste é demorado. Caso não queira 
realizar o teste, tecle Tab para selecionar o botão Skip e tecle Enter. 
 
Aguardo um pouco e clique no botão Next. 
 
Selecione o idioma desejado. Geralmente nas empresas a instalação é no Inglês. Mas, aqui, vamos 
instalar a versão em Português do Brasil. 
 
Após selecionar o idioma para o Português, todas as telas estarão em português. Confira na próxima 
tela. Agora, selecione o Layout do teclado Português Brasileiro (ABNT2). 
 
Clique no botão Próximo. Será exibida uma tela de alerta, informando sobre a tabela de partições. 
Apenas clique no botão Sim. 
 
Aguarde um pouco. Será exibida a tela onde será necessário criar as partições. Este processo pode 
ser todo automático ou manual. Aqui, vamos optar pelo automático. 
 
Marque a opção Rever e modificar o layout do particionamento. 
 
Clique no botão Próximo. Será exibido um alerta informando que os dados serão perdidos. Clique 
no botão Sim. 
 
O Red Hat e CentOS trabalham com o padrão LVM. O LVM é bem mais prático e flexível. Veja a 
ilustração: 
 
Clique no botão próximo. 
Agora é possível configurar o gerenciador de inicialização do Linux. Por padrão, é usado o Grub. 
Também é possível configurar uma senha para que não possam ser passados parâmetros ao Grub 
na inicialização do Linux. Além de opções Avançadas. Veja na próxima tela: 
 
Clique no botão Próximo. 
Nesta tela estaremos trabalhando com as configurações TCP/IP. É possível configurar via DHCP que 
é o padrão ou manualmente. Caso opte pela configuração manual, será necessário conhecimento 
sobre as configurações TCP/IP da sua rede. Veja: 
 
Ao clicar no botão Editar: 
 
Veja um exemplo de configuração: 
 
Agora selecione o fuso horário de acordo com a sua região. Veja: 
 
Clique no botão Próximo. 
Informe a senha do root. O root é o administrador com maiores privilégios em um sistema 
Linux/Unix. Veja a ilustração: 
 
Agora é o momento de informar quais programas (pacotes) serão instalados. Todos estes pacotes 
podem ser adicionados posteriormente. Sempre opto para instalar neste momento. Veja algumas 
ilustrações: 
 
Estarei selecionando a opção Server. Este é um processo que quando se está aprendendo uma 
distribuição Linux, tem que se repetir várias vezes até ter o domínio da distribuição em questão. 
Outro item que não dispenso é a opção Personalizar agora. 
 
 
Veja algumas personalizações:Na seção Servidor Web, geralmente seleciono a maioria dos itens por questão de facilidade e 
compatibilidade. Veja: 
 
 
Clique no botão Próximo. 
A próxima tela informa que será iniciado o processo de instalação. Esta agora será a parte mais 
demorada. 
 
Agora, aguardo um pouco enquanto é feito o processo de instalação. Pode demorar um pouco 
dependendo da configuração do seu sistema. Veja algumas ilustrações: 
 
 
Agora, o DVD/CD será ejetado automaticamente e será necessário um reboot no sistema. 
 
Após o boot ainda são necessárias algumas configurações: 
 
Clique no botão Avançar. 
Nesta próxima tela, é o momento de configuração do Firewall. É possível liberar alguns serviços 
básicos como o ssh, FTP, samba, e-mail, nfs4. Veja: 
 
Outra configuração importante de segurança é o SELinux: 
 
Clique no botão Avançar. 
É possível configurar o Kdump. Uma ferramenta para ajudar a solucionar. 
 
 
 
 
 
 
Ao final será exibida a tela de conclusão. Clique no botão Terminar. 
Por padrão de login é no Modo Texto. Veja: 
 
Acesse o Modo Gráfico digitando Alt + F7. 
 
Acesse o sistema digitando seu login e senha. Veja: 
 
SELINUX 
 
O que é o SELinux ? 
O SELinux ("Security-Enhanced Linux") é uma implementação de uma flexível e refinada arquitetura 
MAC("Mandatory Access Control"). SELinux provê uma política de segurança sobre todos os 
processos e objetos do sistema baseando suas decisões em etiquetas contendo uma variedade de 
informações relevantes à segurança. A lógica da política de tomada de decisões é encapsulada 
dentro de um simples componente conhecido como servidor de segurança ("security server") com 
uma interface geral de segurança. 
Breve Histórico 
O SELinux foi originalmente um projeto de desenvolvimento da NSA ("National Security Agency") e 
outros. Ele foi integrado no Kernel do Linux usando o "framework" LSM ("Linux Security Modules"). 
Inicialmente a implementação do SELinux utilizava os identificadores (IDs ou PSIDs) armazenado nos 
inodes livres do sistema de arquivos ext2. Essa representação numérica era mapeada pelo SELinux 
como uma etiqueta do contexto de segurança. Infelizmente isso necessitaria de uma modificação 
em cada sistema de arquivo para suportar os PSIDs, o que não é uma solução escalável. 
Então o próximo passo da evolução foi um módulo carregável no kernel 2.4 que armazenava os 
PSIDs em um arquivo normal fazendo com que o SELinux suportasse mais sistemas de arquivos. 
No entanto, esta solução ainda não era ótima para a performance do sistema. Finalmente o código 
do SELinux foi integrado ao kernel 2.6.x com total suporte por LSM e contendo atributos (xattrs) no 
sistema de arquivos ext3. SELinux foi alterado para usar xattrs como forma de armazenamento da 
informação do contexto de segurança. 
Muito do trabalho para deixar o kernel pronto para o SELinux bem como seu subsequente 
desenvolvimento vêm sendo realizado em esforços conjuntos da NSA, Red Hat, IBM e a comunidade 
de desenvolvedores do SELinux. 
Por que utilizá-lo 
Para entender os benefícios do MAC sobre o tradicional DAC ("Discretionary Access Control"), é 
necessário entender as limitações do DAC. 
Utilizando unicamente DAC, o dono de um arquivo/objeto provê um potencial risco de corrompê-lo. 
Um usuário pode expor arquivos ou diretórios à brechas de segurança utilizando incorretamente o 
comando chmod e uma não esperada propagação dos direitos de acesso. Um processo inicializado 
pelo usuário como um script CGI pode fazer tudo que quiser com quaisquer arquivos possuídos por 
este usuário. Por exemplo um servidor HTTP pode realizar qualquer operação sobre arquivos que 
estão no grupo web ou softwares maliciosos podem conquistar nível root de acesso rodando como 
processo de root ou utilizando setuid ou setgid. 
Com DAC existem apenas duas grandes categorias de usuários: Administradores e Não-
administradores. Para alguns serviços e programas rodarem com nível elevado de privilégio as 
escolhas são poucas e tipicamente resolvida dando completo acesso de administrador. 
O MAC permite que seja definido permissões de como os processos irão interagir com outras partes 
do sistema como arquivos, devices, sockets, portas e outros processos (todos chamados de objetos 
para o SELinux). Isso é feito através de uma política de segurança definida administrativamente 
sobre todos os processos e objetos. Estes processos e objetos são controlados pelo Kernel e a 
decisão de segurança tomada com todas as informações disponíveis ao invés de utilizar somente a 
identidade do usuário. Com este modelo os processos podem garantir apenas permissões 
necessárias pela funcionalidade seguindo um princípio de poucos privilégios. 
Sobre MAC, por exemplo, usuários que expõem seus dados utilizando chmod estão protegidos pelo 
fato de seus dados ter um tipo único associado com seu diretório "home" e outros processos não 
podem tocar nestes dados sem devida permissão dentro da política. 
 
SISTEMA DE ARQUIVOS E ESTRUTURA DE DIRETÓRIOS 
 
Nome: ext2 
Características: Pesquisa Binária 
 Não fragmentação 
 Permissões de Arquivo (podem ser extendidas) 
 Arquivos com 255 caracteres no nome 
 Qualquer caractere especial no nome 
 Por default, não síncrono 
Nome: ext3 
Características: Novo sistema 
 Journaling FS (assim como o do Aix e o ReiserFS) 
 Pesquisa Binária 
 Grava o que foi feito, não necessita FSCK mesmo caso caia a energia 
 Pode ser aumentado em tempo real, sem perda de dados 
 Idem a ext2 no restante 
É importante a qualquer administrador de sistemas entender a estrutura de diretórios do sistema. 
Isso porque manter a padronização definida, o ajudará a saber onde as coisas estão e a futuros 
administradores ou auxiliares acharem tudo no sistema. 
O Linux possui uma estrutura muito bem organizada e realmente a devemos 
seguir. 
Abaixo os diretórios principais e o que neles devem conter: 
/etc Configurações do sistema. A grande maioria das configurações dos pacotes 
 do Linux ficam dentro desse diretório 
/lib Bibliotecas compartilhadas necessárias ao sistema 
/mnt Montagem de discos e periféricos 
/opt Pacotes adicionais NÃO fornecidos com o sistema (não utilizado quase) 
/sbin Diretório usado na inicialização do sistema, pacotes essenciais para 
manutenção. Demais pacotes para a administração do sistema devem ficar em /usr/sbin ou 
/usr/local/sbin. 
/usr Segundo maior diretório (logo após o /), recomenda-se monta-lo como RO 
para evitar danos. A grande maioria dos aplicativos do sistema e instalados com ele ficam a partir 
deste diretório. 
/var Diretório que contém arquivos variáveis, tais como spool (filas de email, 
crontab, impressão) e logs. Este diretório existe para que os arquivos que necessitem ser 
modificados fiquem nele e não no /usr, liberando assim sua montagem como RO. 
/root Alguns Unix-Like não o utilizam (utilizam /home/root). É o diretório que 
contém os arquivos do administrador (seu home). 
/proc Diretório VIRTUAL onde o kernel armazena suas informações. Alguns 
dados deste podem ser modificados, como os abaixo de /proc/sys que contém informações muito 
pertinentes a performance tunning do sistema. 
/tmp Diretório que contém arquivos temporários. Todos os usuários necessitam 
poder escrever neste diretório (para gravar seus temporários), no entanto um não pode apagar o 
temporário do outro (se não teríamos um problema), devido a isto este diretório possui uma 
permissão especial, que possibilita escrever mas só apagar aquilo que for seu. Esta permissão 
chama-se STICK BIT. 
/home Os diretórios pessoais dos usuários devem ficar a partir daqui. 
/bin Aplicativos e utilitários usados durante a inicialização do sistema, antes de 
qualquer sistema de arquivos ser montado. As shells dos usuários costumam ficar aqui também. 
Binários de usuários devem ficar em /usr/bin. 
/boot Contém a imagem do kernel e tudo o que for necessário aoprocesso de 
boot, menos configurações. 
/dev Dispositivos do sistema. 
 É importante salientar, que essa estrutura de diretórios pode sofrer pequenas mudanças, 
dependendo da distribuição e da versão que estiver sendo utilizada. Mas não se preocupe, nada 
que não seja percebido por alguém com um pouco de conhecimento em LINUX. 
 
Níveis de execução 
 
Sistemas Linux podem funcionar em vários níveis distintos de execução. Cada nível é caracterizado 
pelo conjunto de processos permanentes e funções oferecidas. Sistemas Red Hat Linux e derivados, 
utilizam seis níveis de execução, ou runlevels, como são mais conhecidos. Esta concepção tem suas 
origens no sistema Unix desenvolvido na AT&T (System V Unix). 
Nível Significado 
0 Neste nível o sistema está parado 
1 Sistemas funcionando no nível 1 estão em modo monousuário, com um conjunto mínimo 
de processos ativos. O sistema de arquivos raiz (root) está montado em modo de leitura. 
Este nível de execução é normalmente utilizado quando a inicialização normal falha por 
alguma razão. 
2 A maior parte dos serviços estão ativos, com exceção dos processos de rede (como nfs, 
nis, named e httpd). O sistema está em modo multi usuário, mas não permite acesso 
remoto 
3 Este é o nível normal de operação, com todos os processos ativos. Carrega o sistema em 
modo multi usuário, mas sem interface gráfica. 
4 Este nível não é utilizado na maior parte das distribuições 
5 Semelhante ao nível 3, com todos os processo ativos, porém com uma interface gráfica 
de logon. 
6 É executado neste nível um reboot do sistema. 
 
O nível de execução padrão é definido no arquivo /etc/inittab, através da entrada: 
 
id:3:initdefault: 
 
Neste caso, o sistema será iniciado com o nível de execução 3. 
 
 
 
 
 
O SHELL 
 
Bourne Shell: é o shell padrão para Unix, ou seja, a matriz dos outros shells, portanto é um dos mais 
utilizados. É representado por "sh". Foi desenvolvido por Stephen Bourne, por isso Bourne Shell. 
Korn Shell: este shell é o Bourne Shell evoluído, portando todos os comandos que funcionavam no Bourne 
Shell funcionarão neste com a vantagem de ter mais opções. É representado por "ksh". 
C Shell: é o shell mais utilizado em BSD, e possui uma sintaxe muito parecida com a linguagem C. Este tipo de 
shell já se distancia mais do Bourne Shell, portanto quem programa para ele terá problemas quanto a 
portabilidade em outros tipos. É representado por "csh". 
Bourne Again Shell: é o shell desenvolvido para o projeto GNU usado pelo GNU/Linux, é muito usado pois o 
sistema que o porta evolui e é adotado rapidamente. Possui uma boa portabilidade, pois possui 
características do Korn Shell e C Shell. É representado por "bash". O nosso estudo estará focado neste. 
O Shell do LINUX, pode ser comparado ao DOS (cmd) do Windows, mas essa comparação é apenas relativa, 
pois o Shell do LINUX é extremamente poderoso e flexível, permitindo a configuração total do sistema LINUX 
(rede, serviços, usuários, permissões, etc) através de interface texto. Também é bastante útil para acesso 
remoto, onde a velocidade de comunicação pode ser um obstáculo para a interface gráfica convencional. 
Uma outra característica do Shell do LINUX é a possibilidade de criação de aplicações Shell (seria o .bat do 
Windows) bastante eficazes, mas isso exige um nível de conhecimento bastante avançado do usuário. Para o 
usuário comum, apenas o conhecimento da interface gráfica já é o suficiente, porém, para o administrador 
do sistema, o conhecimento do Shell é um enorme diferencial, basta vermos que a maioria dos servidores 
LINUX rodam apenas a interface texto. 
 
ALGUNS COMANDOS BÁSICOS 
 
O Linux (na verdade, GNU/Linux), assim como qualquer sistema operacional moderno, é 
perfeitamente capaz de oferecer interação com o usuário através de gráficos, fazendo com que seja 
possível utilizar a maioria de seus recursos através do mouse. Porém, em dado momento, o modo 
gráfico pode não estar disponível, restando apenas o modo texto (para a inserção de comandos). 
Além disso, determinadas tarefas só podem ser executadas por comandos digitados. Para não ficar 
perdido em qualquer dessas situações, é necessário conhecer alguns comandos do Linux. É isso que 
essa matéria apresenta a seguir. 
Onde e como digitar os comandos? 
Se o Linux que você utiliza entra direto no modo gráfico ao ser inicializado, é possível inserir 
comandos no sistema através de uma aplicação de terminal. Esse recurso é facilmente localizável 
em qualquer distribuição. A imagem abaixo, por exemplo, mostra um terminal no Ubuntu Linux: 
 
Se o computador que você acessa não estiver com o modo gráfico ativado, será possível digitar 
comandos diretamente, bastando se logar. Quando o comando é inserido, cabe ao interpretador de 
comandos (também conhecido como shell) executá-lo. O Linux conta com mais de um, sendo os 
mais conhecidos o bash e o sh. 
Quando um terminal é acessado, uma informação aparece no campo de inserção de comandos. É 
importante saber interpretá-la. Para isso, veja os exemplos abaixo: 
Exemplo 1: [root@infowester /root]# 
Exemplo 2: [wester@alecrim /]$ 
Observação: dependendo de sua distribuição e de seu shell, a linha de comandos pode ter um 
formato ligeiramente diferente do que é mostrado nos exemplos. No Ubuntu Linux, por exemplo, o 
segundo exemplo fica na seguinte forma: 
wester@alecrim: ~$ 
Nos exemplos, a palavra existente antes do símbolo @ diz qual o nome do usuário que está usando 
o terminal (lembre-se de que no Linux é necessário ter um usuário para utilizar o sistema). Os 
nomes que aparecem depois do @ indicam o computador que está sendo acessado seguido do 
diretório. 
O caractere que aparece no final indica qual o poder do usuário. Se o símbolo for #, significa que 
usuário tem poderes de administrador (root). Por outro lado, se o símbolo for $, significa que este é 
um usuário comum, incapaz de acessar todos os recursos que um administrador acessa. 
Independente de qual seja, é depois do caractere que o usuário pode digitar os comandos. 
Os comandos básicos do Linux 
Agora que você já sabe como agir em um terminal, vamos aos comandos do Linux mais comuns. 
Para utilizá-los, basta digitá-los e pressionar a tecla Enter de seu teclado. É importante frisar que, 
dependendo de sua distribuição Linux, um ou outro comando pode estar indisponível. Além disso, 
alguns comandos só podem ser executados por usuários com privilégios de administrador. 
A relação a seguir mostra os comandos seguidos de uma descrição: 
cal: exibe um calendário; 
cat arquivo: mostra o conteúdo de um arquivo. Por exemplo, para ver o arquivo infowester.txt, 
basta digitar cat infowester.txt; 
cd diretório: abre um diretório. Por exemplo, para abrir a pasta /mnt, basta digitar cd /mnt. Para ir 
ao diretório raiz a partir de qualquer outro, digite apenas cd; 
chmod: comando para alterar as permissões de arquivos e diretórios. 
clear: elimina todo o conteúdo visível, deixando a linha de comando no topo, como se o sistema 
acabasse de ter sido acessado; 
cp origem destino: copia um arquivo ou diretório para outro local. Por exemplo, para copiar o 
arquivo infowester.txt com o nome infowester2.txt para /home, basta digitar cp infowester.txt 
/home/infowester2.txt; 
date: mostra a data e a hora atual; 
df: mostra as partições usadas; 
diff arquivo1 arquivo2: indica as diferenças entre dois arquivos, por exemplo: diff calc.c calc2.c; 
du diretório: mostra o tamanho de um diretório; 
emacs: abre o editor de textos emacs; 
file arquivo: mostra informações de um arquivo; 
find diretório parâmetro termo: o comando find serve para localizar informações. Para isso, deve-se 
digitar o comando seguido do diretório da pesquisa mais um parâmetro (ver lista abaixo) e o termo 
da busca. Parâmetros: 
name - busca por nome 
type - busca por tipo 
size - busca pelo tamanho do arquivo 
mtime - busca por data de modificação 
Exemplo: find /home name tristania 
fingerusuário: exibe informações sobre o usuário indicado; 
free: mostra a quantidade de memória RAM disponível; 
halt: desliga o computador; 
history: mostra os últimos comandos inseridos; 
id usuário: mostra qual o número de identificação do usuário especificado no sistema; 
kill: encerra processados em andamento. 
ls: lista os arquivos e diretórios da pasta atual; 
lpr arquivo: imprime o arquivo especificado; 
lpq: mostra o status da fila de impressão; 
lprm: remove trabalhos da fila de impressão; 
lynx: abre o navegador de internet de mesmo nome; 
mv origem destino: tem a mesma função do comando cp, só que ao invés de copiar, move o arquivo 
ou o diretório para o destino especificado; 
mkdir diretório: cria um diretório, por exemplo, mkdir infowester cria uma pasta de nome 
infowester; 
passwd: altera sua senha. Para um administrador mudar a senha de um usuário, basta digitar 
passwd seguido do nome deste; 
ps: mostra os processos em execução. Saiba mais no artigo 
pwd: mostra o diretório em que você está; 
reboot: reinicia o sistema imediatamente (pouco recomendável, preferível shutdown -r now); 
rm arquivo: apaga o arquivo especificado; 
rmdir diretório: apaga o diretório especificado, desde que vazio; 
shutdown: desliga ou reinicia o computador, veja: 
shutdown -r now: reinicia o computador 
shutdown -h now: desliga o computador 
O parâmetro now pode ser mudado. Por exemplo: digite shutdown -r +10 e o sistema irá reiniciar 
daqui a 10 minutos; 
su: passa para o usuário administrador, isto é, root (perceba que o símbolo $ mudará para #); 
tar -xzvf arquivo.tar.gz: extrai um arquivo compactado em tar.gz; 
top: exibe a lista dos processos, conforme os recursos de memória consumidos; 
uname: mostra informações do sistema operacional e do computador. Digite uname -a para obter 
mais detalhes; 
 
useradd usuário: cria uma nova conta usuário, por exemplo, useradd wester cria o usuário wester; 
userdel usuário: apaga a conta do usuário especificado; 
uptime: mostra a quantas horas seu computador está ligado; 
vi: inicia o editor de textos vi. 
whereis nome: procura pelo binário do arquivo indicado, útil para conhecer seu diretório ou se ele 
existe no sistema; 
w: mostra os usuários logados atualmente no computador (útil para servidores); 
who: mostra quem está usando o sistema. 
Finalizando 
Praticamente todos os comandos citados possuem parâmetros que permitem incrementar suas 
funcionalidades. Por exemplo, se você digitar o comando ls com o parâmetro -R (ls -R), este mostrará 
todos os arquivos do diretório, inclusive os ocultos. 
A melhor forma de conhecer os parâmetros adicionais de cada comando é consultando as 
informações de ajuda. Para isso, pode-se usar o recurso --help. Veja o exemplo para o comando ls: 
ls --help 
Também é possível utilizar o comando man (desde que seu conteúdo esteja instalado), que 
geralmente fornece informações mais detalhadas. Par usar o man para obter detalhes do comando cp, 
por exemplo, a sintaxe é: 
man cp 
Se você estiver utilizando o bash, pode-se aplicar o comando help ou info da mesma forma que o 
comando man: 
help cp 
info cp 
Assim como conhecer os comandos básicos do Linux é importante, também o é saber como acessar 
seus recursos de ajuda, pois isso te desobriga de decorar as seqüências das funcionalidades extras. 
Sabendo usar todos os recursos, você certamente terá boa produtividade em suas tarefas no Linux. 
GRUPOS 
 
Grupos servem para agrupar diversos usuários em um único grupo, isto e um tanto quanto óbvio. 
Exemplificando, temos um departamento pessoal na empresa, estes usuários podem acessar uma 
diretório chamado /usr/share/dpessoal, e mais ninguém da empresa pode acessar esta pasta, o 
que fazemos para restringir o acesso? Ao invés de modificar a permissão de cada usuário que acessa 
este diretório, podemos criar o grupo deptopessoal, colocar os funcionários do departamento 
pessoal neste grupo e restringir o acesso ao diretório /usr/share/dpessoal para que somente quem 
faça parte deste grupo possa acessar. 
 
Criando um grupo 
 
Para criarmos um grupo utilizamos o comando groupadd, adicionando a opção –g podemos definir 
o gid (número de identificação do grupo) mas se for omitido o sistema vai adicionar a numeração 
automaticamente: 
 
# groupadd deptopessoal 
 
Excluindo um grupo 
 
Para excluir um grupo utilize o comando groupdel, uma observação importante é que não podemos 
excluir os grupos primários de usuários, somente grupos secundários. 
# groupdel deptopessoal 
 
USUÁRIOS 
 
Um sistema operacional multi usuário permite que múltiplos usuários utilizem o computador e 
rodem programas ao mesmo tempo, compartilhando os recursos da máquina. Para que se utilize 
desta característica cada usuário deve ter uma conta válida no computador para que o sistema 
possa controlar as políticas de segurança, mediante autenticação o usuário pode utilizar o sistema 
local e remotamente. As características de acesso à usuários no Linux são rígidas, tornando-o um 
sistema extremamente seguro, veremos abaixo que existem dois tipos de usuário; os usuários 
normais e o usuário root (administrador). 
 
Usuário root 
 
A conta root é também chamada de super usuário, este é um login que não possui restrições de 
segurança. A conta root somente deve ser usada para fazer a administração do sistema, e usada o 
menor tempo possível. 
Qualquer senha que criar deverá conter de 6 a 8 caracteres, e também poderá conter letras 
maiúsculas e minúsculas, e também caracteres de pontuação. Tenha um cuidado especial quando 
escolher sua senha root, porque ela é a conta mais poderosa. 
Evite palavras de dicionário ou o uso de qualquer outros dados pessoais que podem ser 
adivinhados. Se qualquer um lhe pedir senha root, seja extremamente cuidadoso. Você 
normalmente nunca deve distribuir sua conta root, a não ser que esteja administrando um 
computador com mais de um administrador do sistema. Utilize uma conta de usuário normal ao 
invés da conta root para operar seu sistema. Porque não usar a conta root? Bem, uma razão para 
evitar usar privilégios root é por causa da facilidade de se cometer danos irreparáveis como root. 
Outra razão é que você pode ser enganado e rodar um programa Cavalo de Tróia -- que é um 
programa que obtém poderes do super usuário para comprometer a segurança do seu sistema sem 
que você saiba. 
 
Usuário de Sistema 
 
Também conhecidos como usuários lógicos, esse tipo de usuário não é uma pessoa, mas um processo em 
execução no computador, que exige acesso a arquivos e processos para que possa realizar seu trabalho de 
maneira segura. Temos como exemplos desses usuários: FTP, apache, mysql, etc. 
 
Usuário normal 
 
Os usuários normais possuem permissão de escrita somente em seu diretório home, possui 
também acesso de execução nos diretórios /bin/, /usr/bin/ e /usr/local/bin/ (isto pode variar de 
distribuição para distribuição). Em alguns diretórios não possui permissão de leitura como o /root/ e 
nas homes de outros usuários, estas permissões podem ser redefinidas, mas note bem que quanto 
menos poderes um usuário tiver mais seguro será o sistema. 
As contas aqui também possuem senhas portanto os cuidados são os mesmos do usuário root, a 
única diferença é que se sua senha cair em mãos erradas o estrago será menor. 
Criando um usuário 
 
Vamos criar um usuário através do comando useradd, o comando useradd permite que 
especifiquemos de uma vez diversas opções sobre o usuário as mais comuns são -g , -s , -G. 
 
 
-u UID (número de identificação do usuário, caso seja omitido o sistema insere um número 
automaticamente) 
-g Grupo primário a que o usuário pertence ( caso seja omitido o sistema cria um grupo 
com o nome do usuário) 
-G Grupos secundários do usuário (um usuário pode fazer parte de outros grupos) 
-d Diretório home do usuário (caso seja omitido o sistema vai criar um diretório / 
home/nomedousuário) 
-d Diretório home do usuário (caso seja omitido o sistema vaicriar um diretório / 
home/nomedousuário) 
-s Shell padrão do usuário (caso seja omitido o sistema vai selecionar o bash como padrão) 
 
Vamos criar um usuário, veja o exemplo abaixo: 
 
# useradd -g users -G audio bruno 
 
Certo, usuário criado, automaticamente foi adicionado no grupo users e no grupo audio. Agora 
imagine como seria a criação de um usuário que acessa o servidor de uma workstation windows, o 
usuário não precisa de um shell válido. Para isso utilizamos um shell inválido chamado “/bin/false” 
veja abaixo sua criação: 
 
# useradd -g users -s /bin/false Bruno 
 
Modificando um usuário 
 
Da mesma maneira que criamos um usuário podemos modificar um usuário já criado com a 
ferramenta usermod, que tem uma sintaxe muito parecida com a useradd, na verdade as opções 
são as mesmas, a única novidade é a opção -l que permite a troca do nome de usuário. 
Os usuários comuns não podem modificar as opções de suas próprias contas, o administrador deve 
executar estas alterações. 
 
# usermod -l brunao bruno 
 
Modificando o password 
 
Até agora nada foi mencionado à respeito do password (senha) do usuário, a resposta é que os 
passwords vêm bloqueados por padrão nas distribuições atuais. O comando para criação e 
alteração de senhas de usuários e grupos é passwd, veja um exemplo de sua utilização: 
 
# passwd bruno 
Enter new UNIX password: 
Retype new UNIX password: 
passwd: password updated successfully 
 
Por senhas serem secretas cada usuário pode alterar sua senha quando bem entender com o 
comando passwd sem nenhum parâmetro adicional, o administrador pode mudar a senha de um 
usuário, mas não pode saber qual era a senha anterior. 
 
Excluindo um usuário 
 
Para remover definitivamente usuários do sistema utilizamos a ferramenta userdel, adicionando a 
opção -r o sistema deleta todo o conteúdo do diretório home do usuário: 
 
# userdel bruno 
 
 
 
RPM 
 
O sistema operacional Linux, até hoje, tem a fama de ter instalações complicadas, o que, muitas 
vezes, não deixa de ser verdade. Na tentativa de resolver esses problemas de instalação, A empresa 
Red Hat criou uma tecnologia chamada RPM, que significa RedHat Package Manager (Gerenciador 
de Pacotes RedHat). 
O RPM é um poderoso gerenciador de pacotes, que pode ser usado para criar, instalar, desinstalar, 
pesquisar, verificar e atualizar pacotes individuais de software. Um pacote consiste em 
armazenagem de arquivos e informações, incluindo nome, versão e descrição. Veja a seguir, alguns 
comandos e suas respectivas funções, usadas nos pacotes RPM: 
• rpm -ivh - Instalação de pacotes; 
• rpm -Uvh - Atualização de pacotes; 
• rpm -qi - Informações sobre o pacote; 
• rpm -ql - Lista os arquivos do pacote; 
• rpm -e - Desinstala o pacote; 
• rpm -qa - Lista os pacotes instalados; 
Utilizando o RPM 
O RPM tem 5 modos básicos de operação, excluindo-se o modo de confecção de pacotes: 
instalação, desinstalação, atualização, consulta e verificação. Você pode obter mais informações 
usando rpm --help ou man rpm. Vejamos cada modo: 
Instalação 
Pacotes RPM têm nomes de arquivos tais como foo-1.0-1/.i386.rpm, que incluem o nome do pacote 
(foo), versão (1.0), release (1) e plataforma (i386). A instalação de um pacote é feita através de uma 
linha de comando, como por exemplo: 
$ rpm -ivh foo-1.0-1.i386.rpm 
foo ################################ 
Como se pode observar, o RPM apresenta o nome do pacote e apresenta uma sucessão de 
caracteres # atuando como uma régua de progresso do processo de instalação. O processo de 
instalação foi desenvolvido para ser o mais simples possível, porém eventualmente alguns erros 
podem acorrer: 
- Pacotes já instalados 
Se o pacote já tiver sido instalado anteriormente será apresentada a seguinte mensagem: 
$ rpm -ivh foo-1.0-1.i386.rpm foo package foo-1.0-1 is already installed error: foo-1.0-1.i386.rpm 
cannot be installed 
Caso se deseje ignorar o erro, pode-se usar o parâmetro --replacefiles na linha de comando; 
- Dependências não resolvidas 
Pacotes RPM podem depender da instalação de outros pacotes, o que significa que eles necessitam 
destes pacotes para poderem ser executados adequadamente. Caso deseje instalar um pacote que 
dependa de outro pacote não localizado, será apresentada a seguinte mensagem: 
$ rpm -ivh bar-1.0-1.i386.rpm 
failed dependencies: 
foo is needed by bar-1.0-1 
Para corrigir este erro, será necessário instalar o pacote solicitado. Caso deseje que a instalação 
ocorra de qualquer forma, pode-se utilizar o parâmetro --nodeps na linha de comando. 
Desinstalação 
Para desinstalar um pacote utilize o comando: 
$ rpm -e foo 
Onde foo é o nome do pacote. Pode ser encontrado um erro de dependência durante o processo de 
desinstalação de um pacote ( outro pacote necessita de sua existência para funcionar 
corretamente). Neste caso será apresentada a seguinte mensagem: 
$ rpm -e foo removing these package 
would break dependencies: 
foo is needed by bar-1.0-1 
Para ignorar a mensagem de erro e desinstalar o pacote deve ser utilizado o parâmetro --nodeps na 
linha de comando. 
Atualização 
Para atualizar um pacote utilize o comando: 
$ rpm -Uvh foo-2.0-1.i386.rpm 
foo ######################################## 
O RPM desinstalará qualquer versão anterior do pacote e fará a nova instalação preservando as 
configurações. Sugerimos utilizar sempre a opção -U, já que ela funciona perfeitamente, mesmo 
quando não há uma versão anterior do pacote. Uma vez que o RPM executa um processo de 
atualização inteligente, é apresentada uma mensagem do tipo: 
saving /etc/foo.conf as /etc/foo.conf.rpmsave 
O que significa que os arquivos de configuração existentes estão salvos, porém mudanças no 
software podem tornar este arquivo de configuração incompatível com o pacote. Neste caso, as 
adequações necessárias devem ser feitas pelo usuário. Como o processo de atualização é uma 
combinação dos processos de desinstalação e instalação, alguns erros podem ocorrer. Por exemplo, 
quando se quer atualizar um pacote com uma versão anterior à versão corrente, será apresentada a 
seguinte mensagem: 
# rpm -Uvh foo-1.0-1.i386.rpm 
foo package foo-2.0-1 (which is never) is already installed error: foo-1.0-1.i386.rpm 
cannot be installed 
Para forçar uma atualização de qualquer forma, deve-se usar o parâmetro --oldpackage na linha de 
comando. 
 Consulta 
A consulta à base de dados de pacotes instalados é feita através do comando rpm -q. Na sua 
utilização, são apresentados o nome do pacote, versão e release. Por exemplo: 
$ rpm -q foo foo-2.0-1 
Ao invés de especificar o nome do pacote, pode-se utilizar as seguintes opções após o parâmetro q : 
• a - Consulta todos os pacotes instalados; 
• f <file> - Consulta o pacote que contém o arquivo <file>; 
• F - Funciona como o parâmetro -f, exceto que funciona a partir do stdin (entrada padrão), 
como por exemplo find /usr/bin | rpm -qF; 
• p <arquivo do pacote> - Consulta o pacote originado pelo <arquivo do pacote>; 
• P - Funciona como o parâmetro -p, exceto que funciona a partir do stdin (entrada padrão), 
como por exemplo find /mnt/cdrom/RedHat/RPMS | rpm -qP. 
Há diversas formas de especificar que informações devem ser apresentadas pelas consultas. As 
opções de seleção são: 
• i - Apresenta as informações do pacote, tais como nome, descrição, release, tamanho, data 
de criação, data de instalação e outras; 
• l - Apresenta a lista de arquivos relacionados com o pacote; 
• s - Apresenta o status dos arquivos do pacote. Há dois estados possíveis: normal ou missing 
(não localizado); 
• d - Apresenta uma lista dos arquivos de documentação (páginas de manual, páginas info, 
README, etc.); 
• c - Apresenta uma lista dos arquivos de configuração. Estes arquivos podem ser alterados 
após a instalação para personalização. Exemplos sendmail.cf, passwd, inittab, etc. 
 Verificação 
A verificação de um pacote provoca a comparação dos arquivos instalados de um pacote com as 
informações localizadas nas bases dedados do RPM. Entre outras coisas a verificação compara o 
tamanho, MD5 sum, permissões, tipo, dono e grupo de cada arquivo. 
Para verificar um pacote deve-se utilizar o comando: 
rpm -V <nome do pacote 
Pode-se usar as mesmas opções disponíveis no processo de consultas. 
Exemplos: 
Para verificar um pacote que contenha um arquivo em especial: 
rpm -Vf /bin/vi 
Para verificar todos os pacotes instalados: 
rpm -Va 
Para verificar um pacote instalado e o arquivo de pacote RPM: 
rpm -Vp foo-1.0-1.i386.rpm 
Esta função pode ser útil caso haja alguma suspeita de que a base de dados RPM esteja corrompida. 
Se não houver uma discrepância não haverá resposta do sistema, caso contrário será apresentada 
na forma de uma expressão com 8 caracteres, com um c significando arquivo de configuração e 
após, o nome do arquivo. Cada um dos 8 caracteres significa um dos atributos do arquivo 
comparado aos atributos definidos no pacote RPM, onde um ponto significa que o atributo está Ok. 
Os atributos são: 
5 - MD5 checksum 
S - Tamanho do arquivo 
L - Link simbólico 
T - Modificação do arquivo 
D - Device 
U - Usuário 
G - Grupo 
M - Modo 
Se alguma informação for apresentada, é necessário avaliá-la e verificar se é necessário remover o 
pacote, reinstalá-lo ou procurar resolver o problema, estudando outra forma. 
 
 
 
YUM 
 
O yum (Yellow dog Update, Modified) é o gerenciador de pacotes usado por padrão no CentOS, no 
Fedora e no Red Hat Enterprise. O yum foi originalmente desenvolvido pela equipe do Yellow Dog 
(uma distribuição baseada no Red Hat, destinada a computadores com chip PowerPC) e foi 
sistematicamente aperfeiçoado pela equipe da Red Hat, até finalmente assumir o posto atual. 
O yum trabalha de forma bem similar ao apt-get, baixando os pacotes a partir dos repositórios 
especificados nos arquivos de configuração, junto com as dependências necessárias. Assim como o 
apt-get, ele é capaz de solucionar conflitos automaticamente e pode ser também usado para 
atualizar o sistema. Essencialmente, o yum e o apt-get solucionaram o antigo problema das 
dependências (um pacote precisa de outro, que por sua vez precisa de um terceiro) que 
atormentava os usuários de distribuições mais antigas. 
Existem muitas diferenças entre o CentOS e o Debian, uma delas é o formato dos pacotes utilizados: 
o CentOS utiliza pacotes .rpm, enquanto o debian utiliza pacotes .deb. Ambos também utilizam 
repositórios separados, com pacotes construídos especificamente para cada uma das duas 
distribuições, de forma que existem algumas diferenças nos nomes dos pacotes e arquivos de 
configuração usados. 
Diferente do apt-get, onde você precisa rodar o "apt-get update" antes de cada instalação para 
atualizar a lista de pacotes, o yum faz a atualização automaticamente cada vez que uma instalação é 
solicitada, checando os repositórios, baixando os headers do pacotes e calculando as dependências 
antes de confirmar a instalação, como nesse exemplo: 
 
Isso faz com que a instalação de pacotes usando o yum seja um pouco mais demorada que usando o 
apt-get. Ou seja, ganha-se de um lado mas perde-se do outro. :) 
Para instalar um pacote, use o comando "yum install", como em: 
# yum install mysql-server 
Para removê-lo posteriormente, use: 
# yum remove mysql-server 
O yum possui também um recurso de busca, que é bastante útil quando você está procurando por 
um pacote, mas não sabe o nome exato, ou em casos de pacotes que possuem nomes diferentes 
em relação a outras distribuições. Use o comando "yum search", seguido por alguma palavra ou 
expressão, que faça parte do nome do pacote ou descrição, como em: 
# yum search samba 
Ele retorna um relatório contendo todos os pacotes relacionados, incluindo o texto de descrição de 
cada um. Isso resulta geralmente em uma lista relativamente longa. Para fazer uma busca mais 
restrita, procurando apenas nos nomes dos pacotes, use o parâmetro "list", como em: 
# yum list httpd 
Ele é bem menos falador, retornando apenas os pacotes que possuem "httpd" no nome, sem 
pesquisar nas descrições. 
Uma terceira opção é a "provides" que mostra pacotes que incluem um determinado arquivo, 
pesquisando não no nome ou na descrição, mas sim no conteúdo dos pacotes. Ele é bastante útil 
em casos em que você precisa de alguma ferramenta ou biblioteca que faz parte de outro pacote 
maior, como em: 
# yum provides mcedit 
Em caso de dúvida, você pode verificar se um determinado pacote está instalado e qual é a versão 
usando o comando "rpm -q", como em: 
# rpm -q samba 
samba-3.0.25b-0.el5.4 
 
Para atualizar um pacote já instalado, use o comando "yum update", como em: 
# yum update samba 
O comando "yum install" também pode ser usado para atualizar pacotes. A diferença entre o 
"install" e o "update" é que o "update" se limita a atualizar pacotes já instalados. Ao perceber que o 
pacote solicitado não está instalado, ele exibe um aviso e aborta a instalação, como no exemplo 
abaixo. Isso reduz a possibilidade de você acabar instalando um novo serviço por engano: 
# yum update mysql-server 
Loading "installonlyn" plugin 
Setting up Update Process 
Setting up repositories 
Reading repository metadata in from local files 
Could not find update match for mysql-server 
 
Outra observação é que, depois de atualizar um serviço, é necessário recarregar o serviço (como em 
"service smb restart") para que a nova versão passe a ser usada. Esta é mais uma pequena diferença 
com relação às distribuições derivadas do Debian, onde os serviços são reiniciados de forma 
automática depois de atualizados. 
Para atualizar todo o sistema, comece usando o parâmetro "check-update", que lista as atualizações 
disponíveis: 
# yum check-update 
Se usado sem especificar um pacote, o "update" vai atualizar de uma vez só todos os pacotes do 
sistema, de forma similar ao "apt-get upgrade" do Debian: 
# yum update 
Existe ainda o comando "yum upgrade", que é um pouco mais incisivo, incluindo também pacotes 
marcados como obsoletos (que não existem mais na versão atual). Ele é útil em casos em que é 
necessário atualizar uma versão antiga do sistema: 
# yum upgrade 
É possível também fazer com que o yum atualize o sistema automaticamente todas as madrugadas. 
Para isso, basta ativar o serviço "yum" e configurá-lo para ser ativado durante o boot: 
# chkconfig yum on 
# service yum start 
Isso faz com que a atualização seja agendada através do cron e seja (por padrão) executada todos 
os dias às 4:02 da manhã, como especificado no arquivo "/etc/crontab". 
 
Repositórios Adicionais 
 
A lista de repositórios usados pelo yum é dividida em diversos arquivos, organizados na pasta 
"/etc/yum.repos.d/". No CentOS, a parta inclui por padrão apenas dois arquivos: "CentOS-
Base.repo" e "CentOS-Media.repo". O primeiro inclui os repositórios oficiais da distribuição, 
enquanto o segundo permite que você instale pacotes contidos nos CDs (ou no DVD) de instalação. 
O arquivo "CentOS-Base.repo" contém diversas entradas como a abaixo, uma para cada repositório: 
#released updates 
[updates] 
name=CentOS-$releasever - Updates 
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates 
#baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/ 
gpgcheck=1 
gpgkey=http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5 
Ao adicionar repositórios adicionais, você criaria novos arquivos dentro da pasta 
"/etc/yum.repos.d/", um para cada repositório adicional.O yum verifica os arquivos dentro da pasta 
cada vez que é executado, fazendo com que o novo repositório passe a ser usado automaticamente. 
Normalmente, os responsáveis pelos repositórios disponibilizam arquivos de configuração prontos, 
que precisam ser apenas copiados para dentro da pasta "/etc/yum.repos.d". Para adicionar o 
repositório kbs-centos-extras, por exemplo, você baixaria o arquivo "kbsing-CentOS-Extras.repo", 
disponível no http://centos.karan.org/. 
Assim como o apt-get, o yumutiliza chaves GPG para checar a autenticidade dos pacotes antes de 
fazer a instalação. Cada pacote é assinado digitalmente pelo desenvolvedor, o que atesta que o 
pacote foi realmente gerado por ele. Mesmo que alguém tentasse adulterar o pacote (incluindo um 
rootkit ou um script malicioso, por exemplo), não teria como falsificar também a assinatura, o que 
levaria o yum a reportar o problema e abortar a instalação. 
Ao adicionar um novo repositório, é necessário adicionar também a chave pública do 
desenvolvedor, usando o comando "rpm --import", como em: 
# rpm --import http://centos.karan.org/RPM-GPG-KEY-karan.org.txt 
Normalmente, a URL com a chave pública GPG fica em destaque dentro da página com instruções 
de como adicionar o repositório. 
Da mesma forma, para remover um repositório posteriormente, você removeria o arquivo da pasta, 
de forma que o yum deixe de usá-lo. É interessante também limpar o cache do yum, usando os 
comandos: 
# yum clean headers 
# yum clean packages 
 
 
 
 
 
 
CRON 
Este é um daemon usado no Linux e em várias versões do Unix que executa tarefas agendadas no 
arquivo "/etc/crontab". Esta é uma ferramenta bastante poderosa, que pode ser usada para 
automatizar tarefas de rotina e de manutenção do sistema. A diferença entre o at e o cron é que o 
at permite executar os comandos apenas uma vez, enquanto o cron permite executa-los 
repetidamente, todo dia, toda semana, ou em qualquer periodicidade desejada. Para isto, basta 
editar o arquivo, inserindo uma nova linha que especifique o comando a ser executado e a 
periodicidade A sintaxe das linhas do cron é um pouco complicada, por isso preste atenção: 
 
Este é um exemplo de linha que pode ser incluída: 
 
30 15 * * * root /usr/bin/rdate -s 131.188.3.223 
 
O primeiro campo, "30" refere-se aos minutos, enquanto o segundo "15", às horas. Depois temos o 
campo do dia, mês e dia da semana. No meu caso os três campos estão com um *, o que significa 
que o comando será executado todos os dias na hora especificada nos campos da hora, ou seja, 
todos os dias às 15:30. Finalmente, temos o usuário que executará o comando (no caso o próprio 
root) e finalmente o comando que será executado (/usr/bin/rdate -r 131.188.3.223) que serve para 
sincronizar o relógio do micro com o horário do servidor especificado (este endereço é o de uma 
universidade na Alemanha, que mantém um servidor rdate público). Para executar o comando 
todas as quartas feiras, à meia noite (00:00) por exemplo, você usaria o campo de dia da semana (o 
quinto) para especificar um número de 1 a 7 que se refere ao dia. 1 é Segunda-feira e 7 é o 
Domingo. Quarta-feira é o dia 3, então a linha ficaria: 
00 00 * * 3 root /usr/bin/rdate -s 131.188.3.223 
 
Se fosse para executa-lo todo dia 14 de Abril às 4 da tarde (16:00), então seria: 
00 16 14 04 * root /usr/bin/rdate -s 131.188.3.223 
 
Note que neste último caso o dia da semana voltou a ser um asterisco. Se você especificasse 
também um dia da semana, 3 por exemplo, ele só executaria o comando caso o dia 16/04 caísse 
numa Quarta-Feira, o que seria improvável :-). Você poderia brincar com isso fazendo com um um 
comando fosse executado toda Sexta-feira 13 (um backup extra, só pra garantir :-) à meia-noite. 
Neste caso a linha ficaria: 
00 00 13 * 5 root comando 
 
O arquivo /etc/crontab só pode ser editado pelo root, mesmo que o comando a ser inserido na 
linha vá ser executado por outro usuário. Lembre-se de só executar os comandos incluídos no 
/etc/crontab como root quando necessário. Se o comando puder ser executado por um usuário 
comum, altere o "root" na linha pelo login do usuário. Os usuários do sistema também podem usar 
o cron, mas usando o comando "crontab -e". 
Exemplo de tarefas agendadas: 
PERMISSÕES DE ARQUIVOS 
 
O controle de acesso em arquivos e diretórios é a segurança fundamental para qualquer sistema 
multi-usuário. 
Os sistemas de arquivos nativos do Linux implementam controle de acesso utilizando algumas 
propriedades dos arquivos/diretórios. 
 
Configurações básicas 
 
No Linux há três modelos de controle de acesso básicos: Read, Write e Execution. 
 
Veja um exemplo de permissão básica na figura abaixo: 
 
 
 
 
 
O Tipo do Objeto significa: 
 
d => diretório 
b => arquivo de bloco 
c => arquivo especial de caractere 
p => canal 
l => link 
s => socket 
- => arquivo normal 
 
Já os outros caracteres significam: 
 
r => significa permissão de leitura (read); 
w => significa permissão de gravação (write); 
x => significa permissão de execução (execution); 
- => significa permissão desabilitada. 
 
Explicando um pouco mais: 
 
Leitura (r): 
Em arquivos, permite examinar o conteúdo do arquivo. 
Em diretórios permite listar conteúdo do diretório. 
 
Escrita (w): 
Em arquivos, permite escrever, remover e alterar o arquivo. 
Em diretórios, permite criar e remover arquivos dentro do diretório. 
 
Execução (x): 
Em arquivos, permite executar um arquivo como um programa. 
Em diretório, permite ler e escrever em arquivos dentro do diretório. 
 
Sendo que os três primeiros rwx primeiros pertencem ao Dono do arquivo, e os outros três rwx 
pertencem ao Grupo e por fim os últimos três rwx pertencem há outros usuários que não fazem 
parte do grupo. 
 
Uma nota se faz importante neste momento. As permissões de diretório se sobrepõem às permissões do 
arquivo que estão dentro dele. 
 
No LINUX, todos os arquivos e diretórios são automaticamente assinalados por um usuário e um 
grupo que são "donos" deste arquivo/diretório, assim o sistema pode definir diferentes permissões 
de acesso entre usuários. Isto é muito importante pois um sistema multi usuário precisa ter uma 
camada de segurança especial, imagine que o usuário1 cria um diretório com documentos de texto 
importantes, o usuário2 por sua vez não sabe para que serve esta pasta e acaba apagando-a por 
engano, este tipo de coisa não pode acontecer em uma empresa. Desta forma foram criadas as 
permissões de acesso, que restringem as ações que dos usuários em arquivos e diretórios. Vamos 
coletar dados sobre nossa conta atual para gerenciarmos corretamente as permissões de acesso. 
 
Verificação de conta 
 
Para saber que usuário estamos utilizando usamos o comando whoami na verdade pode parecer 
sem sentido saber que usuário estamos utilizando quando logamos, mas imagine que estemos 
acessando o servidor de outra maneira ou seja um usuário genérico. 
 
$ whoami 
bruno 
 
Precisamos saber também a que grupo pertencemos, utilizamos o comando groups: 
 
$ groups 
users audio webdesign 
 
Primeiro vem o grupo primario do usuário, logo após os grupos secundários. O comando groups 
pode retornar os grupos de outros usuários caso seja colocado seu username como parâmetro: 
 
$ groups joao 
users audio vídeo 
 
Vamos agora verificar permissões de arquivos. 
 
Verificação de permissões com ls – l 
 
Para verificarmos as permissões de acesso à arquivos utilizamos o comando ls-l, que retorna uma 
lista com diversas colunas, devemos ter uma atenção especial com três destas colunas, Veja abaixo 
o exemplo: 
 
$ ls -l /aulas/aula7/ 
-rw-r--r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
Veja na tabela abaixo que colunas devem ser observadas: 
 
-rw-r—-r— Permissões de acesso a este arquivo/diretório. 
bruno Usuário dono deste arquivo/diretório. 
Users Grupo dono deste arquivo/diretório. 
 
Como podemos observar, as permissões de acesso são definidas por um conjunto de caracteres, no 
caso do arquivo1.txt as permissões de acesso são "-rw-r--r--", neste conjunto de caracteres estão 
definidas respectivamente as permissões de acesso do usuário dono, do grupo dono e dos outros 
usuários. 
 
Para tornar isto mais claro vamos observar o output do comando que executamos anteriormente: 
 
-rw-r--r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
● O usuário dono possui permissão de leitura e escrita e não possui permissão de execução. 
● O grupo dono possui permissãode leitura e não possui permissão de escrita nem de execução. 
● Os outros usuários possuem permissão de leitura e não possuem permissão de escrita nem de 
execução. 
 
Definindo posse de arquivos e diretórios por usuário com chown 
 
Agora que já sabemos como verificar as permissões de acesso de arquivos e diretórios vamos 
aprender a definir estas permissões de acesso, primeiro vamos mudar o usuário dono deste 
arquivo, para isso utilizamos o comando chown, sua utilização é bem simples veja abaixo um 
exemplo: 
 
# chown root /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-r--r-- 1 root users 0 May 27 08:14 arquivo1.txt 
 
O usuário dono foi alterado, o comando chown pode também alterar de uma única vez o usuário e 
o grupo, passando como parâmetro usuário:grupo, veja o exemplo abaixo: 
 
# chown bruno:webdesign /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-r--r-- 1 bruno webdesign 0 May 27 08:14 arquivo1.txt 
 
Definindo posse de arquivos e diretórios por grupo com chgrp 
 
Existe também um comando que altera somente o grupo dono de determinado arquivo/diretorio, 
este comando é o chgrp sua utilização é igualmente simples: 
 
# chgrp users /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-r--r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
O comando chmod 
 
Enquanto os comando chown e chgrp servem para alterar respectivamente o usuário dono e o 
grupo dono, o comando chmod serve para alterar as permissões rwx vistas anteriormente, o 
comando chmod recebe dois argumentos: a nova permissão e o objeto de destino. Você poderá 
alterar as permissões de acesso a um objeto de duas maneiras, a primeira é através dos triplets 
(rwx) vistos anteriormente, a segunda é através de uma tabela numérica que veremos adiante. 
Definindo permissões de acesso por triplets 
 
Primeiro, vamos definir esta permissão por triplets. Veja o exemplo abaixo: 
 
# chmod g+w /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-rw-r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
Como podemos observar foi utilizado o parâmetro g+w, afinal o que isto significa? 
Quer dizer que o grupo pode escrever no arquivo1.txt. Então fica claro que os parâmetros passados 
são o tipo de usuário + permissão. Veja na tabela abaixo que tipos de usuários podem ser 
utilizados: 
 
u Usuário dono 
g Grupo dono 
o Outros usuários 
a Todos os usuários 
 
Vamos a mais um exemplo para que fique mais claro: 
 
# chmod u+x /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rwxrw-r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
Como podemos observar foi utilizado o parâmetro u+x, isto significa que o usuário dono pode 
executar o arquivo1.txt. 
Como fazemos para retirar permissões? Utilizamos o símbolo “ - ” ao invés do símbolo “ + ” Veja o 
exemplo abaixo: 
 
# chmod u-x /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-rw-r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
No lugar do rwx encontramos o rw- isto significa que retiramos a permissão de execução do usuário 
dono. 
 
Definindo permissões de acesso pelo modo numérico 
 
A definição de permissões pelo modo numérico funciona de maneira diferente; de uma única vez 
definimos as permissões do usuário dono, do grupo dono e dos outros usuários através de um 
número passado como parâmetro, a tabela de números esta abaixo: 
 
Numero Triplet 
7 rwx 
6 rw- 
5 r-x 
4 r-- 
3 -wx 
2 -w- 
1 --x 
0 --- 
 
Veja o exemplo abaixo a utilização do modo numérico: 
 
# chmod 664 /aulas/aula7/arquivo1.txt 
$ ls /aulas/aula7/ 
-rw-rw-r-- 1 bruno users 0 May 27 08:14 arquivo1.txt 
 
Utilizamos o parâmetro 664; o primeiro número serve para o usuário dono, o segundo para o grupo 
dono e o terceiro para os outros usuários. 
 
 
Processos no Linux 
Nos sistemas operacionais, um processo é a forma de representar um programa em execução. É o 
processo que utiliza os recursos do computador - processador, memória, etc - para a realização das 
tarefas para as quais a máquina é destinada. Este artigo mostrará os principais conceitos 
relacionados a processos no Linux e as ferramentas usadas para manipulá-los e gerenciá-los. 
Composição de um processo 
O sistema operacional lida com uma infinidade de processos e, por isso, é necessário ter meios que 
permitam controlá-los. Para isso, os processos contam com um conjunto de características, dentre 
as quais: 
- Proprietário do processo; 
- Estado do processo (em espera, em execução, etc); 
- Prioridade de execução; 
- Recursos de memória. 
O trabalho de gerenciamento de processos precisa contar com as informações acima e com outras 
de igual importância para que as tarefas sejam executadas da maneira mais eficiente. Um dos meios 
usados para isso é atribuir a cada processo um PID. 
PID e PPID 
Um PID (Process Identifier) é um número de identificação que o sistema dá a cada processo. Para 
cada novo processo, um novo número deve ser atribuído, ou seja, não se pode ter um único PID 
para dois ou mais processos ao mesmo tempo. 
Os sistemas baseados em Unix precisam que um processo já existente se duplique para que a cópia 
possa ser atribuída a uma tarefa nova. Quando isso ocorre, o processo "copiado" recebe o nome de 
"processo pai", enquanto que o novo é denominado "processo filho". É nesse ponto que o PPID 
(Parent Process Identifier) passa a ser usado: o PPID de um processo nada mais é do que o PID de 
seu processo pai. 
UID e GID 
Conforme já mencionado, cada processo precisa de um proprietário, um usuário que seja 
considerado seu dono. A partir daí, o sistema saberá, através das permissões fornecidas pelo 
proprietário, quem pode e quem não pode executar o processo em questão. Para lidar com os 
donos, o sistema usa os números UID e GID. 
O Linux gerencia os usuários e os grupos através de números conhecidos como UID (User Identifier) 
e GID (Group Identifier). Como é possível perceber, UID são números de usuários e GID são 
números de grupos. Os nomes dos usuários e dos grupos servem apenas para facilitar o uso 
humano do computador. 
Cada usuário precisa pertencer a um ou mais grupos. Como cada processo (e cada arquivo) 
pertence a um usuário, logo, esse processo pertence ao grupo de seu proprietário. Assim sendo, 
cada processo está associado a um UID e a um GID. 
Os números UID e GID variam de 0 a 65536. Dependendo do sistema, o valor limite pode ser maior. 
No caso do usuário root, esses valores são sempre 0 (zero). Assim, para fazer com que um usuário 
tenha os mesmos privilégios que o root, é necessário que seu GID seja 0. 
Sinais de processos 
Os sinais são meios usados para que os processos possam se comunicar e para que o sistema possa 
interferir em seu funcionamento. Por exemplo, se o usuário executar o comando kill para 
interromper um processo, isso será feito por meio de um sinal. 
Quando um processo recebe um determinado sinal e conta com instruções sobre o que fazer com 
ele, tal ação é colocada em prática. Se não houver instruções pré-programadas, o próprio Linux 
pode executar a ação de acordo com suas rotinas. 
Entre os sinais existentes, tem-se os seguintes exemplos: 
STOP - esse sinal tem a função de interromper a execução de um processo e só reativá-lo após o 
recebimento do sinal CONT; 
CONT - esse sinal tem a função de instruir a execução de um processo após este ter sido 
interrompido; 
SEGV - esse sinal informa erros de endereços de memória; 
TERM - esse sinal tem a função de terminar completamente o processo, ou seja, este deixa de 
existir após a finalização; 
ILL - esse sinal informa erros de instrução ilegal, por exemplo, quando ocorre divisão por zero; 
KILL - esse sinal tem a função de "matar" um processo e é usado em momentos de criticidade. 
O kill também é um comando que o usuário pode usar para enviar qualquer sinal, porém, se ele for 
usado de maneira isolada, ou seja, sem o parâmetro de um sinal, o kill por padrão executa o sinal 
TERM. 
A sintaxe para a utilização do comando kill é a seguinte: 
kill -SINAL PID 
Como exemplo, vamos supor que você deseja interromper temporariamentea execução do 
processo de PID 4220. Para isso, pode-se usar o seguinte comando: 
kill -STOP 4220 
Para que o processo 4220 volte a ser executado, basta usar o comando: 
kill -CONT 4220 
Se o sinal precisa ser enviado a todos os processos, pode-se usar o número -1 no lugar do PID. Por 
exemplo: 
kill -STOP -1 
Como já dito, usar o comando kill isoladamente - por exemplo, kill 4220 - faz com que este use o 
sinal TERM por padrão. Esse sinal, no entanto, pode ser ignorado pelos processos. É por isso que é 
boa prática usar o comando "kill -9 PID" para "matar" um processo, pois o número nove representa 
o sinal kill e este não pode ser ignorado. Isso deixa claro que se você conhecer o número que é 
atribuído a um sinal, você pode usá-lo no lugar de seu nome. Com exceção de alguns sinais, a 
numeração de cada um pode mudar de acordo com a distribuição ou com a versão do kernel. 
Também é comum usar o kill da seguinte forma: kill -l PID. A opção "-l" (letra L minúscula) é usada 
para listar os processos que aceitaram o kill. 
Agora, imagine que você não saiba qual o PID de um processo e tenha se esquecido que o comando 
ps (visto mais à frente) descobre tal informação. Neste caso, pode-se usar o comando killall, desde 
que você saiba o nome do processo. A sintaxe é: 
killall -SINAL processo 
Por exemplo: 
killall -STOP vi 
Estado dos processos 
Quando um processo é criado, isso não significa que ele será imediatamente executado. Além disso, 
determinados processos podem ser temporariamente paralisados para que o processador possa 
executar um processo prioritário. Isso quer dizer que os processos, em certos momentos, podem 
estar em situações de execução diferentes. O Linux trabalha, essencialmente, com quatro tipos de 
situação, isto é, estados: 
Executável: o processo pode ser executado imediatamente; 
Dormente: o processo precisa aguardar alguma coisa para ser executado. Só depois dessa "coisa" 
acontecer é que ele passa para o estado executável; 
Zumbi: o processo é considerado "morto", mas, por alguma razão, ainda existe; 
Parado: o processo está "congelado", ou seja, não pode ser executado. 
Comandos nice e renice 
Ao abordarmos os comandos nice e renice é necessário entender o conceito de gentileza. Um 
processo pode ter prioridade em relação a outros em sua execução. Quando um processo é gentil, 
significa que ele "oferece a gentileza" de permitir que um processo com prioridade maior que a sua 
seja executado antes dele. Os níveis de gentileza, também chamados de nice, são determinados 
através de números. Quanto mais alto for o valor nice, mais gentil é o processo. Geralmente, o 
intervalo de números usados no nice são os inteiros entre -19 e 19. 
Embora determinar a prioridade de um processo não seja uma prática comum, afinal, o próprio 
Linux faz muito bem essa tarefa, isso pode ser necessário em alguma situação. Para isso, utiliza-se 
um comando que recebe o mesmo nome do conceito: nice. A sintaxe é: 
nice -n prioridade processo 
Por exemplo: 
nice -n -5 ntpd 
No exemplo, o ntpd recebe prioridade -5. Trata-se de uma prioridade alta, afinal, como já dito, 
quanto menor o número menor sua gentileza. 
Se um determinado processo está em execução, isso acontece com uma prioridade já definida. Para 
alterar um processo nessa condição, usa-se o comando renice, cuja sintaxe é: 
renice prioridade opção processo/destino 
As opções do renice são: 
-u - a alteração ocorrerá nos processos do usuário informado; 
-g - a alteração ocorrerá nos processos do grupo indicado; 
-p - a alteração ocorrerá no processo cujo PID for informado. 
Um exemplo: 
renice +19 1000 -u infowester 
Neste caso, o comando renice alterou a prioridade do processo 1000, assim como a prioridade dos 
processos do usuário infowester. 
Verificando processos com o ps 
O ps é um comando de extrema importância para o gerenciamento de processos. Por ele, é possível 
saber quais os processos em execução atualmente, quais os UIDs e PIDs correspondentes, entre 
outros. 
Se somente ps for digitado na linha de comando, geralmente o sistema mostra quais os processos 
do usuário. É preciso usar uma combinação de opções para obter mais detalhes. 
As opções mais importantes são os seguintes: 
a - mostra todos os processos existentes; 
e - exibe as variáveis de ambiente relacionadas aos processos; 
f - exibe a árvore de execução dos processos; 
l - exibe mais campos no resultado; 
m - mostra a quantidade de memória ocupada por cada processo; 
u - exibe o nome do usuário que iniciou determinado processo e a hora em que isso ocorreu; 
x - exibe os processos que não estão associados a terminais; 
w - se o resultado de processo não couber em uma linha, essa opção faz com que o restante seja 
exibido na linha seguinte. 
Das opções acima, a combinação mais usada (pelo menos aqui no InfoWester) é aux: 
ps aux 
Como exemplo, o resultado obtido com esse comando foi o seguinte: 
 
Note que usando a combinação lax, o resultado mostra mais detalhes: 
ps lax 
A seguir, segue a descrição dos campos mostrados anteriormente e alguns que só são mostrados 
com a combinação lax: 
USER - nome do usuário dono do processo; 
UID - número de identificação do usuário dono do processo; 
PID - número de identificação do processo; 
PPID - número de identificação do processo pai; 
%CPU - porcentagem do processamento usado; 
%MEM - porcentagem da memória usada; 
VSZ - indica o tamanho virtual do processo; 
RSS - sigla de Resident Set Size, indica a quantidade de memória usada (em KB); 
TTY - indica o identificador do terminal do processo; 
START - hora em que o processo foi iniciado; 
TIME - tempo de processamento já consumido pelo processo; 
COMMAND - nome do comando que executa aquele processo; 
PRI - valor da prioridade do processo 
NI - valor preciso da prioridade (geralmente igual aos valores de PRI); 
WCHAN - mostra a função do kernel onde o processo se encontra em modo suspenso; 
STAT - indica o estado atual do processo, sendo representado por uma letra: R - executável; D - em 
espera no disco; S - Suspenso; T - interrompido; Z - Zumbi. Essas letras podem ser combinadas e 
ainda acrescidas de: W - processo paginado em disco; < - processo com prioridade maior que o 
convencional; N - processo com prioridade menor que o convencional; L - processo com alguns 
recursos bloqueados no kernel. 
Verificando processos com o top 
O comando ps trabalha como se tirasse uma fotografia da situação dos processos naquele 
momento. O comando top, por sua vez, coleta as informações, mas as atualiza regularmente. 
Geralmente essa atualização ocorre a cada 10 segundos. 
A sintaxe do comando top é a seguinte: 
top -opção 
Entre as opções, tem-se as que se seguem: 
-d - atualiza o top após um determinado período de tempo (em segundos). Para isso, informe a 
quantidade de segundos após a letra d. Por exemplo: top -d 30; 
-c - exibe a linha de comando ao invés do nome do processo; 
-i - faz o top ignorar processos em estado zumbi; 
-s - executa o top em modo seguro. 
É possível manipular alguns recursos do comando top através das teclas do teclado. Por exemplo, 
para atualizar imediatamente o resultado exibido, basta pressionar a tecla de espaço. Se pressionar 
a tecla q, o top é finalizado. Pressione a tecla h enquanto estiver utilizando o top para ver a lista 
completa de opções e teclas de atalho. 
 
Os recursos jobs, fg e bg, fuser, pstree, nohup 
Para ter ainda mais controle sobre os processos executados no Linux, pode-se utilizar os seguintes 
comandos: jobs, fg e bg, fuser, pstree, nohup. Cada um é descrito a seguir: 
jobs - serve para visualizar os processos que estão parados ou executando em segundo plano 
(background). Quando um processo está nessa condição, significa sua execução é feita pelo kernel 
sem que esteja vinculada a um terminal. Em outras palavras, um processo em segundo plano é 
aquele que é executado enquanto o usuário faz outra coisa no sistema. Uma dica para saber se o 
processo está em background é verificara existência do caractere & no final da linha. Se o processo 
estiver parado, geralmente a palavra "stopped" aparece na linha, do contrário, a palavra "running" 
é exibida. A sintaxe do jobs é: 
jobs -opção 
As opções disponíveis são: 
-l - lista os processos através do PID; 
-r - lista apenas os processos em execução; 
-s - lista apenas os processos parados. 
Se na linha de um processo aparecer o sinal positivo (+), significa que este é o processo mais 
recente a ser paralisado ou a estar em segundo plano. Se o sinal for negativo (-), o processo foi o 
penúltimo. Note também que no início da linha um número é mostrado entre colchetes. Muitos 
confundem esse valor com o PID do processo, mas, na verdade, trata-se do número de ordem 
usado pelo jobs. 
fg e bg: o fg é um comando que permite a um processo em segundo plano (ou parado) passar para 
o primeiro (foreground), enquanto que o bg passa um processo do primeiro plano para o segundo. 
Para usar o bg, deve-se paralisar o processo. Isso pode ser feito pressionando-se as teclas Ctrl + Z no 
teclado. Em seguida, digita-se o comando da seguinte forma: 
bg +número 
O número mencionado corresponde ao valor de ordem informado no início da linha quando o 
comando jobs é usado. 
Quanto ao comando fg, a sintaxe é a mesma: 
fg +número 
fuser: o comando fuser mostra qual processo faz uso de um determinado arquivo ou diretório. Sua 
sintaxe é: 
fuser -opção caminho (do arquivo ou diretório) 
Entre as opções, tem-se: 
-k - finaliza o processo que utiliza o arquivo/diretório em questão; 
-i - deve ser usada em conjunto com a opção k e serve para perguntar se a finalização do processo 
deve ser feita; 
-u - mostra o proprietário do processo; 
-v - o resultado é mostrado em um padrão de exibição semelhante ao comando ps. 
pstree: esse comando mostra processos relacionados em formato de árvore. Sua sintaxe é: 
pstree -opção PID 
Entre as opções, tem-se: 
-u - mostra o proprietário do processo; 
-p - exibe o PID após o nome do processo; 
-c - mostra a relação de processos ativos; 
-G - usa determinados caracteres para exibir o resultado em um formato gráfico. 
Um detalhe importante: se ao digitar o comando pstree o PID não for informado, todos os 
processos serão listados. 
 
nohup: o comando nohup possibilita ao processo ficar ativo mesmo quando o usuário faz logout. É 
da natureza dos sistemas baseados em Unix interromper processos caso seu proprietário não esteja 
mais ativo, por isso, o nohup pode ser muito útil. Sua sintaxe é: 
nohup comando 
Saber lidar com processos pode ser crucial para manter um computador funcionando e executando 
suas tarefas numa situação crítica. O assunto é essencial a administradores de sistemas, mas é 
importante até mesmo ao usuário doméstico. Obviamente que o controle de processos não se 
resume aos recursos citados aqui, uma vez que este artigo deve ser interpretado como um guia 
básico. Além disso, se você pretende obter algum certificado em Linux, ter conhecimento sobre o 
controle de processos pode lhe dar pontos significativos. Por isso, não hesite em explorar os 
comandos. Se quiser mais detalhes, use os recursos de ajuda, como o tradicional "man comando". 
 
O Temido VI 
"vi" é a sigla para "Visual Interface". A origem desse nome se deve ao seguinte fato: quando o vi foi 
criado (começo da década de 80), não era comum existirem editores de textos como nos dias de 
hoje. Naquela época, você digitava um texto mas não podia vê-lo! Isso mesmo! Em 1992, foi criado 
o vim (Vi IMitator), um clone fiel ao vi, porém com muitas outras funcionaliades, que só foram 
sendo adicionadas. Algum tempo depois, o vim passou a ser chamado de `Vi IMproved' (vi 
melhorado). 
O vim é um dos editores de textos mais utilizados no mundo Unix. Em alguns sistemas, existe um 
link simbólico (/bin/vi) apontando para o /usr/vim. Em outros, o /bin/vi é o executável, só que 
executa diretamente o vim. Muita gente acha que usa vi, mas na verdade utiliza o vim, e eles têm 
algumas diferenças. O que você verá abaixo fala sobre o vim. 
O vim é um editor de textos muito poderoso, ele pode: abrir vários arquivos ao mesmo tempo, 
possui sistema de autocorreção, auto-identação, seleção visual, macros, seleção vertical de texto, 
uso de expressões regulares, sintaxe colorida, e muito mais. Ele não é exclusivo do Unix, ou seja, 
pode ser executado em outras plataformas, como Amiga, MacOS, Sun, Windows entre outras. 
Existe também o gvim, que é o vim em modo gráfico, com todas as funcionalidades do vim em 
pleno funcionamento, o que muda é apenas o modo gráfico mesmo. 
O vim possui vários modos, ou seja, estados em que ele se encontra. São eles: modo de inserção, 
comandos, linha de comando, visual, busca e reposição. Abordarei os dois principais: 
Modo de inserção e de comandos 
Para identificar o modo (estado) do vim, basta visualizar o rodapé da tela. 
Agora, vamos à prática. Para executar o vim, utilize: 
$ vi => Abre o vim vazio, sem nenhum arquivo e exibe a tela de apresentação. 
$ vi arquivo => Abre o arquivo de nome "arquivo". 
$ vi arquivo + => Abre o arquivo de nome "arquivo", com o cursor no final do mesmo. 
$ vi arquivo +10 => Abre o arquivo de nome "arquivo", com o cursor na linha 10. 
$ vi arquivo +/Copag => Abre o arquivo de nome "arquivo", na primeira ocorrência da palavra 
"Copag". 
Ao executar o vim, ele inicia diretamente em modo de comando. Para comprovar, é só olhar na 
última linha (rodapé) e não vai haver nada lá. Isso quer dizer que você não conseguirá escrever 
nada, pode digitar a vontade que só vai ouvir beeps. Para começar a escrever, pressione "i" em seu 
teclado. O vim entra em modo de inserção, que você comprova (como falado anteriormente) pelo 
rodapé da tela, onde fica a seguinte marcação: 
- - -- INSERT -- 
Suponha que você já digitou o bastante, e quer salvar, por segurança. Pressione a tecla ESC para 
voltar em modo de comandos. E veja os comandos para salvar/sair: 
:w => Salva o arquivo que está sendo editado no momento. 
:q => Sai. 
:wq => Salva e sai. 
:x => Idem. 
ZZ => Idem. 
:w! => Salva forçado. 
:q! => Sai forçado. 
:wq! => Salva e sai forçado. 
Então, você editou uma boa quantidade de textos e quer salvar: 
:w 
Agora, quer voltar a editar o texto: 
i 
Lembre que utilizando o "i" para inserção, a mesma se inicia inserindo texto antes do cursor. Veja 
agora outros subcomandos de inserção de texto: 
A => Insere o texto no fim da linha onde se encontra o cursor 
o => Adiciona uma linha vazia abaixo da linha corrente 
O => Adiciona uma linha vazia acima da linha corrente 
Ctrl + h => Apaga último caracter à esquerda 
Voltando ao modo de comando: 
Veja agora subcomandos para movimentação pelo texto: 
Ctrl + f => Passa para a tela seguinte. 
Ctrl + b => Passa para a tela anterior. 
H => Move o cursor para a primeira linha da tela. 
M => Move o cursor para o meio da tela. 
L => Move o cursor para a última linha da tela. 
h => Move o cursor para caracter a esquerda. 
j => Move o cursor para linha abaixo. 
k => Move o cursor para linha acima. 
l => Move o cursor para caracter a direita. 
w => Move o cursor para o início da próxima palavra (não ignorando a pontuação). 
W => Move o cursor para o início da próxima palavra (ignorando a pontuação). 
b => Move o cursor para o início da palavra anterior (não ignorando a pontuação). 
B => Move o cursor para o início da palavra anterior (ignorando a pontuação). 
0 (zero) => Move o cursor para o início da linha corrente. 
^ => Move o cursor para o primeiro caracter não branco da linha. 
$ => Move o cursor para o fim da linha corrente. 
nG => Move o cursor para a linha de número "n" 
G => Move o cursor para a última linha do arquivo. 
Copiando e colando textos no vim (utilizando o mouse) 
Selecione o texto necessário com o botão esquerdo do mouse. Quando você for colar, saiba que o 
texto será colado a partir de onde se encontra o cursor (esse que aparece, às vezes piscando e às 
vezes não, quando você está digitando). Para colar,depois de ter selecionado o texto, você pode 
utilizar uma dessas opções: 
1) Pressionando o botão direito do mouse; 
2) Pressionando o botão direito + botão esquerdo juntos; 
3) Pressionando o botão do meio do mouse (mouse de 3 botões); 
Observação: Lembre-se que o vim deve estar no modo de inserção. 
Usando o modo visual do vim 
Entre no modo visual: v 
Agora, utilize as teclas direcionais (setas) do teclado, para selecionar o texto desejado. 
Pressione e cole, utilizando a tecla "p" (paste). 
Veja agora como apagar um determinado texto: 
Utilizando normalmente as teclas Backspace/Delete, ou entrando em modo visual (v) e 
pressionando a tecla Delete. 
Você pode remover até o final de uma palavra, utilizando: dw 
Pode também remover até o final de uma frase: d$ 
Desfazendo uma ação 
É claro que você pode desfazer uma ação que você considera errado, ou que errou ao digitar o 
texto. É só utilizar: u 
Se você precisar voltar o texto na tela, utilize as teclas Ctrl + r. 
Subcomandos para localização de texto 
/palavra => Procura pela palavra ou caracter acima ou abaixo do texto. 
?palavra => Move para a ocorrência anterior da palavra (para repetir a busca use "n"). 
n => Repete o último comando utilizando / ou ?. 
N => Repete o último comando / ou ? ao contrário (baixo para cima). 
Ctrl+g => Mostra o nome do arquivo, o número da linha corrente e o total de linhas. 
Mais opções para remoção de caracteres 
x => Apaga o caracter onde o cursor estiver. 
dd => Apaga a linha inteira onde o cursor estive 
D => Apaga a linha a partir da posição do cursor até o fim. 
J => Une a linha corrente à próxima. 
:5dd => Removeas próximas 7 linhas a partir da posição do atual do cursor (qualquer número). 
Mais para copiar e colar 
:yy => Copia a linha onde o cursor se encontra. 
:5yy => Copia as próximas 5 linhas a partir da posição atual do cursor. 
:p => Cola o que foi copiado na linha abaixo do cursor atual. 
Opções para substituição de textos 
rCARACTER => Substitui o caracter onde o cursor se encontra pelo caracter especificado em 
CARACTER. 
RTEXTO => Substitui o texto corrente pelo texto digitado (sobrepõe). 
cw => Remove a palavra corrente para substituição. 
cc => Remove a linha corrente para substituição. 
C => Substitui o restante da linha corrente, esperando o texto logo após o comando. 
J => Une a linha corrente à próxima. 
:s/velho/novo => Substitui a primeira ocorrência de "velho" por "novo" na linha corrente. 
:% s/velho/novo => Substitui em todo o arquivo (%) a primeira ocorrência de "velho" por "novo" em 
cada linha. 
:% s/velho/novo/g => Substitui em todo o arquivo (%), todas (g) as ocorrências de "velho" por 
"novo". 
:% s/velho/novo/gc => Igual ao anterior, mas pedindo confirmação para cada substituição. 
:% s/^String[0-9]//gc => Expressões regulares também funcionam, como no sed. 
:% s/./\u&/gc => Converte para maiúsculas (\u) o primeiro caracter (.) de cada linha. 
Abreviações 
:ab => Mostra todas as abbr. 
:abc[lear] => Remove todos. 
:iab => Apenas para modo de inserção. 
:iabc[lear] => Tira todos de inserção. 
:cab => Apenas p/modo de comando ( : ). 
:cabc[lear] => Tira todos os modos de comando. 
:una vc => Tira ab para vc. 
Observação: Pontuação, espaço ou o ENTER, disparam a expansão de uma abreviação. Porém, Ctrl+] 
também pode ser usado, para expandir sem adicionar caracteres. 
Opções para o comando SET 
:set 
autowrite aw => Salva a cada alteração. 
backspace bs => Comportamento backspace (1 ou 2). 
errorbell eb => Campainha de erro. 
expandtab et => Troca tab por espacos. 
fileformat=dos ff => Converte o arquivo para DOS. 
hidden hid => Preserva o buffer. 
hlsearch hls => Elumina a última procura. 
ignorecase ic => Case insensitive na busca. 
incsearch is => Ilumina procura enquanto digita. 
laststatus=2 => Mostra linha de estado. 
lazyredraw lz => Não redesenha em macros. 
lines=N => Múmero de linhas na tela. 
magic => Usar mágicas na procura de padrões. 
number nu => Mostra núm da linha. 
report=N => Mostra aviso quando N linhas mudaram (0=sempre). 
showcmd => Mostra o comando que se está fazendo. 
showmatch sm => Mostra o casamento de {},[],(). 
smartcase scs => Assume "noic" quando tiver maiúsculas. 
textwidth=N => Quebra de linha do texto. 
undolevels ul=N => Guarde os N últimos comandos para desfazer (padrão=1000). 
vb t_vb= => Retira o "beep" de erro. 
Agora invertendo maiúsculas/minúsculas 
5~ => Inverte os 5 próximos caracteres. 
g~$ => Inverte todos os caracteres até o fim da linha. 
seleciona, u => Converte para minúsculas. 
seleciona, U => Converte para maiúsculas. 
seleciona, ~ => Inverte. 
Observação: Onde está escrito "seleciona", é para fazer utilizando o modo visual (v). 
Agora veja como definir coluna de quebra de linha (problema que eu tive quando iniciei no 
aprendizado do vim): 
:set textwidth=N 
Se você já estiver num arquivo pronto: 
:set wm=5 => O número 5 aqui são as colunas que serão "cortadas". 
gqG => Até o final do arquivo. 
Vamos ver agora o que podemos fazer pressionando a tecla "Ctrl": 
É claro que é segurando Ctrl + . 
No modo de COMANDO: 
A => Incrementa um número (Add) 
X => Decrementa um número 
S => ScrollLock 
L => Redesenha tela 
V => Modo visual (Visual Vertical) 
G => Status do arquivo 
M => Início da próxima linha 
E => Linha abaixo sem mover cursor 
Y => Linha acima sem mover cursor 
N => Próxima linha (Next) 
P => Linha anterior (Previous) 
F => PageDown (Forward) 
B => PageUp (Backyard) 
U => PageUp / 2 (Up) 
D => PageDown / 2 (Down) 
Agora, no modo de INSERÇÃO: 
A => Insere o último texto inserido 
I => TAB 
S => ScrollLock 
H => BackSpace 
T => 2 tab's no início da linha (Two Tabs) 
V => Anula expansão do próximo caractere 
J => Enter - quebra de linha 
M => Enter - quebra de linha 
L => Redesenha tela 
R => Insere conteúdo do registrador [a-z] (Veja abaixo) 
K => Insere um dígrafo (Veja abaixo) 
N => Procura palavra no texto atual (Next) 
P => Procura palavra no texto atual (Previous) 
Y => Copia caractere que está acima (Yank) 
Veja os caracteres especiais: 
ga => Mostra o código da letra sobre o cursor. 
:dig => Mostra todos os dígrafos disponíveis (tabela). 
Exemplos: Para fazer um º, use Ctrl+K,-,o ("Ctrl"+"K"+"-"+"o"). 
Para fazer um ½, use Ctrl+K,1,2 ("Ctrl"+"K"+"1"+"2"). 
Trabalhando com arquivos e janelas múltiplas 
Você pode abrir múltiplos arquivos, por exemplo: 
$ vim arquivo1 arquivo2 
E pode alternar entre as janelas. Veja: 
:wn => Grava o atual e vai ao próximo. 
:wN => Grava o atual e vai ao anterior. 
:args => Mostra todos os arquivos atuais. 
:qa => Sai de todas as janelas de uma vez. 
:all => Abre todos os arquivos em janelas individuais. 
Tecla chave das janelas = Crtl+W 
j, seta abaixo => Move para janela abaixo. 
k, seta acima => Move para janela acima. 
o => Apenas esta janela, fecha todas as outras (Only). 
+, - => Muda o tamanho da janela. 
= => Deixa todas as janelas com tamanhos iguais. 
Os registradores 
"[a-z] => Use o registrador [a-z] para o próximo delete, cópia ou cola. 
:reg => Mostra o conteúdo de todos os registradores. 
:reg [a-z] => Mostra o conteúdo do registradores [a-z]. 
Observação: O [a-z] pode ser: 0-9a-z%#:.-=" 
Marcas: 
m[a-z] => Marca em [a-z] a posição corrente do cursor. 
`[a-z] => Vai até a marca [a-z]. 
`` => Vai até a posição anterior ao último pulo (alterna). 
:marks => Mostra as marcas ativas. 
Fazendo gravação de seqüência de comandos 
q[a-z] => Inicia a gravação de uma seqüência no registrador [a-z]. 
q[A-Z] => Inicia a gravação, adicionando no registrador [a-z]. 
q => Pára a gravação. 
@[a-z] => Executa a seqüência do registrador [a-z] (5 vezes? 5@a) 
Dica: Pode-se colocar o @[a-z] dentro da própria gravação do q[a-z]! Assim ele é executado 
recursivamente. Muito útil quando há uma procura de padrões na gravação. faz para todas as 
ocorrências. 
Mapeamentos 
:map :r!date => Mapeamento em modo de comando. 
:imap :r!date => Mapeamento em modo de inserção. 
:cmap r!date => Mapeamento em modo linha de comando. 
:vmap :r!date=> Mapeamento em modo visual. 
Exemplos: 
"html: negrito no trecho selecionado 
:vmap d`pa # html: negrito no trecho selecionado 
"liga/desliga autoIndent 
:map ,si :set ai!:echo "autoIndent="&ai 
"mostrar os espaços em branco no fim das linhas 
:map / *$^M 
Através dos mapeamentos é possível "encurtar" comandos, ou seja, abreviá-los. Conheça as 
sintaxes: 
Comment => Ciano 
Constant => Roxo 
Identifier => Ciano 
PreProc => Azul escuro 
Special => Vermelho 
Statement => Amarelo 
String => Roxo 
Type => Verde 
Todo => Preto, fundo marrom 
Error => Branco, fundo vermelho 
Ignore => Preto, fundo preto! - esconde 
Utilizando o recurso de expandtab 
Mas, o que isso faz? Transforma todos os TABs em espaços. Podemos ativar dentro do próprio vim, 
utilizando o comando: 
:set expandtab 
Para desabilitar: 
:set noexpandtab 
Podemos colocar também no arquivo ~/.vimrc a seguinte linha: 
set expandtab 
O arquivo ~/.vimrc pode ser usado para muitas configurações, e essa é uma delas. Existe ainda o 
arquivo ~/.exrc, mas não entraremos em detalhes. 
Podemos incluir a saída de um comando no vim, utilizando: 
:r!comando 
Por exemplo: 
:r!rpm -q kernel 
Incluiria o seguinte resultado, dentro do seu texto (isso na minha máquina): 
kernel-2.4.18-3 
Dicas diversas do vim: 
:xit => Igual :wq, mas só grava se tiver sido alterado algo no arquivo. 
:map N_ARQ ^R=expand("%:t:r")^M 
Imprime no arquivo o próprio nome do arquivo editado quando N_ARQ é digitado. 
Agora, veja como alinhar o texto: 
:left 
:right 
:center 
E para fazer uma busca de 2 palavras ao mesmo tempo: 
/palavra1\|palavra2 
O vim é um editor de textos com centenas de opções, comandos, strings... Enão dá para abordar 
tudo aqui. Por isso, a melhor maneira de conhecê-lo a fundo é usando-o. 
 
 
 
SERVIDOR FTP 
 
O que é FTP 
 
FTP significa File Transfer Protocol (Protocolo de Transferência de Arquivos), e é uma forma bastante rápida e 
versátil de transferir arquivos (também conhecidos como ficheiros), sendo uma das mais usadas na internet. 
Pode referir-se tanto ao protocolo quanto ao programa que implementa este protocolo (Servidor FTP, neste 
caso, tradicionalmente aparece em letras minúsculas, por influência do programa de transferência de 
arquivos do Unix). 
A transferência de dados em redes de computadores envolve normalmente transferência de arquivos e 
acesso a sistemas de arquivos remotos (com a mesma interface usada nos arquivos locais). O FTP (RFC 959) é 
baseado no TCP, mas é anterior à pilha de protocolos TCP/IP, sendo posteriormente adaptado para o TCP/IP. 
É o padrão da pilha TCP/IP para transferir arquivos, é um protocolo genérico independente de hardware e do 
sistema operacional e transfere arquivos por livre arbítrio, tendo em conta restrições de acesso e 
propriedades dos mesmos. 
A transferência de arquivos dá-se entre um computador chamado "cliente" (aquele que solicita a conexão 
para a transferência de dados) e um servidor (aquele que recebe a solicitação de transferência). O utilizador, 
através de software específico, pode selecionar quais arquivos enviar ao servidor. Para existir uma conexão 
ao servidor, o utilizador informa um nome de utilizador (ou username, em inglês) e uma senha (password), 
bem como o nome correto do servidor ou seu endereço IP. Se os dados foram informados corretamente, a 
conexão pode ser estabelecida, utilizando-se um "canal" de comunicação, chamado de porta (port). Tais 
portas são conexões no qual é possível trocar dados. No caso da comunicação FTP, o padrão para porta é o 
número 21. 
 
Instalando o servidor 
 
Para que nosso Linux tenha a possibilidade de se conectar por FTP para realizar transferência de arquivos, 
necessita ter instalado e configurado um servidor de FTP. 
Para você instalar um servidor FTP em Linux normalmente não necessita de nenhum programa adicional já 
que o servidor FTP costuma vir com o sistema. Para os exemplos que vamos citar a seguir, utilizamos o 
servidor FTP que vem com distribuições que seguem o padrão RED HAT. 
Para começar, teremos que instalar o pacote que contém o servidor FTP que neste caso se chama Vsftpd 
1.1.3-8, para o qual executaremos a seguinte instrução: 
rpm -ivh vsftpd 1.1.3-8 
Observação: a versão do pacote certamente será diferente em distribuições mais recentes do LINUX. 
 
Configuração 
 
Uma vez instalado o servidor de FTP, vamos configurá-lo de acordo com nossas necessidades. 
Começaremos com a lista de usuários que poderão ter acesso ao servidor FTP: 
Para configurar este parâmetro necessitaremos abrir o arquivo vsftpd.user.list que se encontra em /etc/. 
Neste arquivo poderemos ver uma lista com os usuários que têm acesso. 
Porém, na verdade o arquivo mais importante para a configuração do servidor é o vsftpd.conf que contém 
todos os parâmetros de configuração, entre outras coisas a localização dos arquivos compartilhados. Dentro 
deste arquivo se encontram os seguintes parâmetros, que podemos modificar dependendo do uso que 
quisermos dar. 
anonymous.allow 
 
Com estes parâmetros se habilita ou desabilita o usuário anônimo. 
Anonymous.allow=trae (usuário anônimo habilitado) 
Anonymous.allow=false (usuário anônimo desabilitado) 
 
Write_enable 
 
Indica se uma pasta tem permissão de escritura ou não. Em outras palavras indica se podemos subir arquivos 
à pasta ou não. 
Write_enable=true (se tem permissão de escritura) 
Write_enable=false (não tem permissão de escritura) 
 
ftpd_banner 
 
Permite colocar uma mensagem de boas vindas aos usuários quando se conectem 
ftpd_banner=mensagem 
 
chroot_local_user 
 
Permite ou não aos usuários locais o acesso à máquina 
chroot_local_user=true 
chroot_local_user=false 
 
Para dizer ao servidor de FTP que usuários têm permissão para acessar temos que pegar a rota do arquivo 
antes comentado onde se encontrava a lista de usuários (vsftpd.user_list) 
Para isso, no arquivo de configuração colocaríamos algo como isto: 
Chroot_list_file=/etc/vsftpd.user_list 
Programa o ftp para que feche qualquer sessão inativa por 2 minutos seja derrubada 
idle_session_timeout=120 
 
Programa o ftp para que durante a transferência de dados, a sessão seja derrubada após 2 minutos 
idle_connection_timeout=120 
 
Basicamente com estes comandos você poderá configurar seu servidor FTP em Linux sem nenhum problema. 
 
 
 
Iniciar e interromper o servidor de FTP 
 
Já nos falta somente iniciar o servidor para o qual utilizaremos os seguintes comandos. 
 
Para iniciar o serviço: 
service vsftpd start 
 
Para parar o serviço: 
 service vsftpd stop 
 
Para reiniciar o serviço: 
service vsftpd restart 
 
 
Configurando um cliente ftp para Windows 
 
FileZilla é freeware, isso quer dizer que você pode copiá-lo e usá-lo livremente. Ele pode ser obtido no 
endereço http://filezilla.sourceforge.net/ 
NOTA: Você precisará de um endereço FTP do local que deseja acessar, bem como de um usuário e uma 
senha. Verifique as configurações de segurança de seu sistema, para que aplicações como FIREWALL não 
bloqueiem o programa de FTP e/ou as portas que ele utiliza para se conectar aos servidores. 
A aplicação é bastante simples de instalar, dispensando qualquer comentário para esse processo. 
 
Passo 1. Ao executar o FileZilla você terá a seguinte tela 
 
Como você pode ver, a interface não é tão complicada. A esquerda poderá ser vista a sua máquina local 
(Local Site) 
Para configurar o FileZilla para que se conecte ao seu servidor clique no pequeno computador, conforme 
destacado acima pela seta vermelha.
 
 
Passo 2. A janela Site Manager será mostrada. 
Clique no botão New Site e coloque um nome para sua nova conexão 
 
 
 
 
 
Passo 3. Agora você precisa preencher os detalhes da conexão (setas vermelhas). 
 Informe o Host name (esse é o endereço do seu servidor FTP) 
 
Seu tipo de servidor é FTP. O tipo de logon é Normal. 
Usuário e senha do servidor de ftp. Sevocê estiver usando um computador compartilhado com outros 
usuários, pode ser interessante solicitar ao Filezilla que não memorize sua senha, evitando dessa forma, que 
outros usuários consigam fazer logon com suas credenciais. 
Não esqueça de salvar suas alterações clicando em Save and Exit 
 
 
 
Passo 4. Agora, após retornar a tela principal do Filezilla clique na pequena seta ao lado do ícone do 
computador e veja uma lista com os sites que você configurou previamente. Clique no seu site para fazer a 
conexão. 
 
 
 
Passo 5. Conexão estabelecida. Você verá a estrutura de pastas do seu servidor do lado direito da tela. 
 
 
 
 
 
Passo 6 Selecione a pasta de destino e de origem utilizando a mesma forma usada no Windows Explorer 
 
 
 
 
 
Passo 7. Agora, encontre os arquivos do seu computador que deseja transferir ao servidor “Upload” (no 
lado esquerdo da tela). Simplesmente selecione os arquivos, arraste e solte-os no servidor (lado direito da 
tela). Da mesma forma pode ser feito para copiar arquivos do servidor para o seu computador local 
“Download”, que é a operação contrária. 
 
 
Você verá dados sobre a transferência na parte inferior da tela, assim pode acompanhar o andamento da 
transferência de cada arquivo, bem como saber se a transferência foi efetuada com sucesso. 
 
Pronto, copia terminada. 
 
 
 
Passo 8. Se você alterar algum arquivo no seu PC e quiser aplicar essas mudanças também no servidor tudo o 
que precisa fazer é usar novamente o drag-and-drop (arrastar e soltar) e confirmar a pergunda sobre se 
deseja sobregravar o arquivo no servidor. 
 
 
 
 
 
 
Passo 9. Para fazer a desconexão, basta clicar no icone apontado pela seta vermelha. 
 
 
Comandos FTP (Shell) 
O comando ftp permite o gerenciamento de arquivos num servidor ftp remoto. 
Para iniciar o uso você deve primeiro estar conectado a rede. No caso de um servidor ftp da 
internet, você deve estar conectado à internet. 
Para conectar-se ao servidor utilize a seguinte sintaxe: 
ftp SERVIDOR 
Por exemplo, para conectar-se ao servidor ftp.hpg.com.br você deve digitar: 
ftp ftp.hpg.com.br 
Dependendo do servidor, pode ser pedido seu nome de usuário e senha. Após estabelecida a 
conexão o comando ftp exibirá seu prompt e aguardará suas instruções 
ftp> 
Mesmo que não seja especificado um endereço para conexão o comando ftp será iniciado e 
aguardará instruções no seu prompt. 
Após estabelecida conexão com o servidor você pode manipular os arquivos através dos seguintes 
comandos: 
COMANDO SINTAXE DESCRIÇÃO 
! ! COMANDO 
Executa COMANDO na máquina local. 
 
No prompt do ftp, os comandos digitados são, a princípio, 
executados na máquina remota. Para executar um comando na 
máquina local preceda o mesmo com o ! 
Ascii ascii 
Configura o tipo de transferência de arquivos para ASCII. É o 
valor padrão 
Bell bell Emite um bip quando um comando é completado 
Binary binary Configura o tipo de transferência de arquivos para binário. 
Bye bye Encerra a sessão ftp e retorna ao interpretador de comandos 
Cd cd DIRETÓRIO Muda o diretório de trabalho para DIRETÓRIO 
Cdup cdup Muda para o diretório que está um nível acima do diretótio atual 
Chmod chmod MODO ARQUIVO Altera as permissões de ARQUIVO de acordo com MODO. 
Close close Encerra a sessão ftp e retorna ao interpretador de comandos 
Delete delete ARQUIVO Apaga ARQUIVO 
Dir dir DIRETÓRIO ARQUIVO-LOCAL 
Lista o conteúdo de DIRETÓRIO colocando o resultado em 
ARQUIVO-LOCAL, que é um arquivo na sua máquina. Se 
DIRETÓRIO não for especificado, será listado o conteúdo do 
diretório atual. Se ARQUIVO-LOCAL não for especificado a 
listagem será enviada para a tela. 
Get 
get ARQUIVO-REMOTO ARQUIVO-
LOCAL 
Baixa ARQUIVO-REMOTO para sua máquina com o nome de 
ARQUIVO-LOCAL. Se ARQUIVO-LOCAL não for especificado o 
arquivo será baixado com o mesmo nome que tem na máquina 
remota. 
Help help COMANDO 
Descreve sumariamente o COMANDO. Se este não for 
especificado será exibida a lista de todos os comandos. 
LCD lcd DIRETÓRIO Muda o diretório de trabalho na máquina local. 
Ls ls DIRETÓRIO ARQUIVO-LOCAL 
Lista o conteúdo de DIRETÓRIO colocando o resultado em 
ARQUIVO-LOCAL, que é um arquivo na sua máquina. Se 
DIRETÓRIO não for especificado, será listado o conteúdo do 
diretório atual. Se ARQUIVO-LOCAL não for especificado a 
listagem será enviada para a tela. 
Mdelete mdelete ARQUIVOS Apaga ARQUIVOS 
Mdir mdir DIRETÓRIOS ARQUIVO-LOCAL Semelhante a dir, porém lista o conteúdo de vários diretórios 
Mget mget ARQUIVOS Semelhante a get, porém baixa vários arquivos 
Mkdir mkdir DIRETÓRIO Cria um diretório com o nome de DIRETÓRIO 
Mls mls DIRETÓRIOS ARQUIVO-LOCAL Semelhante a ls, porém lista o conteúdo de vários diretórios 
Mode mode MODO 
Configura o modo de transferência de arquivos para MODO. O 
modo padrão é "stream" 
Modtime modtime ARQUIVO Exibe a hora da última modificação de ARQUIVO 
Mput mput ARQUIVOS Semelhante a put, porém envia vários arquivos 
Newer 
newer ARQUIVO-REMOTO ARQUIVO-
LOCAL 
Substitui o ARQUIVO-LOCAL pelo ARQUIVO-REMOTO se a hora 
de modificação do ARQUIVO-REMOTO for mais recente 
Nlist nlist DIRETÓRIOS ARQUIVO-LOCAL Semelhante a nls 
Put 
put ARQUIVO-LOCAL ARQUIVO-
REMOTO 
Envia ARQUIVO-LOCAL para o servidor ftp nomeando-o como 
ARQUIVO-REMOTO. Se ARQUIVO-REMOTO não for especificado 
o arquivo será enviado com o nome de ARQUIVO-LOCAL 
Pwd pwd Exibe o caminho completo(PATH) do diretório atual 
Quit quit Semelhante a bye 
Recv 
recv ARQUIVO-REMOTO ARQUIVO-
LOCAL 
Semelhante a get 
Reget 
reget ARQUIVO-REMOTO ARQUIVO-
LOCAL 
Semelhante a get com a diferença que se ARQUIVO-LOCAL existe 
e é menor que ARQUIVO-REMOTO, reget considera que 
ARQUIVO-LOCAL é ARQUIVO-REMOTO parcialmente transferido 
e contiua a transferência do arquivo. Muito útil quando se baixa 
arquivos grandes. 
remotehelp 
rhelp 
remotehelp COMANDO 
rhelp COMANDO 
Semelhante a help, porém solicita ajuda ao servidor ftp 
remotestatus 
rstatus 
remotestatus ARQUIVO 
rstatus ARQUIVO 
Exibe a situação de ARQUIVO. Se ARQUIVO não for especificado, 
exibe a situação da máquina remota. 
Rename rename NOME-ANTIGO NOME-NOVO Renomeia um arquivo 
Rmdir rmdir DIRETÓRIO Apaga DIRETÓRIO 
Send 
send ARQUIVO-LOCAL ARQUIVO-
REMOTO 
Semelhante a put 
Size size ARQUIVO Exibe o tamanho de ARQUIVO 
Status status Exibe a situação atual do servidor ftp 
System system Exibe o tipo de sistema operacional da máquina remota 
Type type TIPO 
Configura o tipo de transferência de arquivos para TIPO. O 
padrão é ASCII. Se TIPO não for especificado, será mostrada a 
configuração atual 
? ? COMANDO Semelhante a help 
 
 
SSH 
 
Introdução 
O ssh é um pacote de programas cujo objetivo é aumentar a segurança de um sistema de redes. Ele, 
basicamente fornece um substituto mais seguro para os programas "remotos" - rsh, rlogin, rcp. Alem de ser 
uma boa alternativa para o telnet. 
O problema de segurança que este pacote tenta solucionar é o da escuta de rede para obter 
informações sigilosas. Os comandos remotos e o telnet usam transferência direta de dados sem 
codificação. Isto permite que redes abertas a "escutas" tenham informações criticas vazadas. Uma 
"escuta" é facilmente instalada numa rede ethernet na qual não é possível controlar o acesso de 
maquinas ou usuários suspeitos. 
A situação torna-se mais critica quando sistemas sem nenhuma segurança como DOS, WIN 3.x e 
WIN 95 participam da rede, e o acesso a essas maquinas não é suficientemente controlado. Isto 
porque tais sistemas não possuem a noção de usuário privilegiado, não sendo muito complicado 
instalar nos mesmos programas de escuta de rede que podem "ouvir" as transferências feitas numa 
rede ethernet, ou qualquer rede do tipo "broadcast". 
O exemplo mais simples de utilização de uma escuta é para pegar a senha de alguém que esteja 
fazendo telnet. A senha é passada entre a maquina cliente e o servidor de telnet como textopuro. A 
solução seria usar o rlogin no lugar do telnet mas os comandos remotos possuem também as suas 
falhas. O sistema de autorização da conexão (autenticação) é baseado nos arquivos hosts.equiv e 
.rhosts, que basicamente deveriam dizer quais maquinas podem fazer a conexão. A autenticidade 
da identidade destas maquinas é garantida pelo seu endereço IP ou pelo seu nome de domínio. 
Existem muitos métodos de falsificação de identidade IP e alguém capaz de instalar uma escuta na 
rede é muito bem capaz de instalar um programa "travesti" de IP e simular que é uma maquina 
autorizada. 
O ssh se propõe a solucionar o problema da escuta com uma transferência de dados criptografada e 
com um protocolo de autenticação mais seguro. Os métodos de autenticação selecionáveis incluem 
.rhosts apenas (inseguro), .rhosts com validação do host atraves de RSA ou validação exclusiva 
através de RSA. Os protocolos do X Windows também apresentam diversos problemas de segurança 
e o ssh procura fornecer seções seguras para clientes X11 executados a partir dele. 
Configuração do ssh 
O arquivo /etc/sshd_config configura o servidor sshd. Os defaults da instalação são normalmente 
suficientes. 
Exemplo de um configurador utilizado no CL10 
sshd_config 
# $OpenBSD: sshd_config,v 1.59 2002/09/25 11:17:16 markus Exp $ 
# This is the sshd server system-wide configuration file. See 
# sshd_config(5) for more information. 
# This sshd was compiled with PATH=/usr/bin:/bin:/u sr/sbin:/sbin 
# The strategy used for options in the default sshd _config shipped with 
# OpenSSH is to specify options with their default value where 
# possible, but leave them commented. Uncommented options change a 
# default value. 
Port 22 
#Protocol 2,1 
ListenAddress 192.168.10.37 
#ListenAddress :: 
# HostKey for protocol version 1 
#HostKey /etc/ssh/ssh_host_key 
# HostKeys for protocol version 2 
#HostKey /etc/ssh/ssh_host_rsa_key 
#HostKey /etc/ssh/ssh_host_dsa_key 
# Lifetime and size of ephemeral version 1 server k ey 
#KeyRegenerationInterval 3600 
#ServerKeyBits 768 
# Logging 
#obsoletes QuietMode and FascistLogging 
#SyslogFacility AUTH 
#LogLevel INFO 
# Authentication: 
#LoginGraceTime 120 
#PermitRootLogin yes 
#StrictModes yes 
#RSAAuthentication yes 
#PubkeyAuthentication yes 
#AuthorizedKeysFile .ssh/authorized_keys 
# rhosts authentication should not be used 
#RhostsAuthentication no 
# Don't read the user's ~/.rhosts and ~/.shosts fil es 
#IgnoreRhosts yes 
# For this to work you will also need host keys in /etc/ssh/ssh_known_hosts 
#RhostsRSAAuthentication no 
# similar for protocol version 2 
#HostbasedAuthentication no 
# Change to yes if you don't trust ~/.ssh/known_hos ts for 
# RhostsRSAAuthentication and HostbasedAuthenticati on 
#IgnoreUserKnownHosts no 
# To disable tunneled clear text passwords, change to no here! 
#PasswordAuthentication yes 
#PermitEmptyPasswords no 
# Change to no to disable s/key passwords 
#ChallengeResponseAuthentication yes 
# Kerberos options 
#KerberosAuthentication no 
#KerberosOrLocalPasswd yes 
#KerberosTicketCleanup yes 
#AFSTokenPassing no 
# Kerberos TGT Passing only works with the AFS kase rver 
#KerberosTgtPassing no 
# Set this to 'yes' to enable PAM keyboard-interact ive authentication 
# Warning: enabling this may bypass the setting of 'PasswordAuthentication' 
#PAMAuthenticationViaKbdInt no 
#X11Forwarding no 
#X11DisplayOffset 10 
#X11UseLocalhost yes 
#PrintMotd yes 
#PrintLastLog yes 
#KeepAlive yes 
#UseLogin no 
#UsePrivilegeSeparation yes 
#PermitUserEnvironment no 
#Compression yes 
#MaxStartups 10 
# no default banner path 
#Banner /some/path 
#VerifyReverseMapping no 
#Subsystem sftp /usr/libexec/sftp-server 
AllowUsers marcio junior daniel supervisor laercio luiz toptel 
 
 
Cliente SSH no LINUX 
 
Diversos aplicativos fazem parte do pacote do SSH, mas vamos dar ênfase aos dois mais utilizados, que 
permitem o controle de um servidor via linha de comando, e também a copia de arquivos. 
Comando ssh 
Esse comando permite ao usuário ter acesso a linha de comando de um servidor ssh, podendo realizar 
qualquer operação no mesmo (só sendo limitado pelas permissões de acesso do usuário utilizado) 
Observação: Ao executar o cliente ssh pela primeira vez, cria-se um diretorio .ssh debaixo do $HOME e um 
arquivo random_seed. Caso a maquina servidora não seja "conhecida" pela maquina cliente (chave publica 
da maquina servidora no arquivo /etc/ssh_known_hosts), o ssh pede para validar a identidade da maquina 
para inclui-la entre as servidoras de ssh conhecidas do usuário no arquivo .ssh/known_hosts. Estes arquivos 
guardam as chaves publicas das maquinas com as quais os usuários normalmente conectam-se, quando 
ocorre a mudança de chave publica de alguma maquina, existe a possibilidade de está havendo uma quebra 
de segurança. O usuário, nesse caso, pode aceitar a nova chave publica ou rejeitar e consultar o responsável 
daquela maquina para saber se ele trocou as chaves do ssh. 
Exemplo: 
 
 
Comando scp 
O Comando scp permite que sejam feitas cópias de um servidor SSH para a máquina cliente e vice-versa. 
 
Alguns exemplos: 
scp -P 222 marcio@coopemtax.no-ip.info:/jipr/projetos/data/MOV.zip mov.zip 
Faz a cópia do arquivo MOV.zip que está no diretório /jipr/projetos/data do servidor coopemtax.no-ip.info 
utilizando para conexão a porta 222 para o diretório atual do cliente 
scp marcio.zip marcio@192.168.10.32:/home/marcio 
Faz a cópia do arquivo marcio.zip da máquina cliente para o diretório /home/marcio que está no servidor 
192.168.10.32. Perceba que a porta não foi informada, pois o serviço está “escutando” na porta padrão “22” 
scp –r * marcio@192.168.10.32:/home/marcio 
Faz a cópia de todos os arquivos do diretório atual e também dos subdiretórios da máquina cliente para o 
diretório /home/marcio que está no servidor 192.168.10.32. 
 
Cliente SSH no Windows 
Um cliente SSH para Windows que é muito utilizando, e também gratuito, é o Putty. Se trata de 
uma aplicação com instalação extremamente simples e leve, mas que oferece toda a segurança e 
simplicidade do acesso via ssh. 
Uma vez instalado o PuTTY, sua utilização é bastante simples. 
 1. Clique duplo no programa PuTTY. 
Será exibida a seguinte tela. Observe no seu computador: 
2. Coloque o IP ou no do computador (ver se tem DNS na tua rede). Fala de acordo com a ilustração 
abaixo: 
 
3. Selecione o protocolo SSH. No campo Sessions, digite um nome. Geralmente o nome do servidor 
e clique no botão Save. 
4. Clique duas vezes no nome do servidor. Será exibida a seguinte tela: 
 
5. Clique no botão Yes. Pois na primeira conexão, será gerada uma chave para identificação da 
máquina remota, de forma a garantir segurança no processo 
6. Agora, informe o login e senha para acesso. 
Veja na ilustração: 
 
7. Digite su – e Enter. 
8. Digite a senha do root. 
Pronto. Agora, é possível gerenciar o teu Linux de dentro do Windows. 
Transferindo arquivo do Windows para o Linux utilizando pscp (putty) 
Bem, vamos transferir arquivos usando o servidor de ssh. No Windows, vamos usar o programa 
pscp. Uma informação é que temos que ter um diretório no Linux com direito de escrita. Esse 
comando é similar ao scp do Linux, que vimos anteriormente. 
1. Abra um prompt no Windows. 
2. Digite pscp Jarbas.war jarbas@192.168.1.1:/tmp . 
Veja a explicação: 
 
3. Agora tecle Enter. 
Será exibida a seguinte tela: 
 
4. Digite y para confirmar. 
Agora, selecionado solicitada a senha do usuário. Neste nosso exemplo do usuário Jarbas. 
5. Informe a senha e aguardo o arquivo ser transferido. Veja a ilustração: 
 
Ao digitar apenas pscp e teclar (ENTER), as opções disponíveis de utilização serão mostradas: 
 
 
 
 
 
DHCP 
O DHCP, Dynamic Host Configuration Protocol, é um serviço de rede com servidor e cliente, do lado 
servidor roda o dhcpd para fornecer endereçosIP os clientes, configurar a rede automaticamente 
nas estações com opção de obter IP automaticamente no boot (DHCP), ou quando reinicia o serviço 
de rede, a parte básica é fornecer IP dinamico para estações, tanto Linux e Windows, serve também 
como configurador de rede, além do IP pode configurar o servidor de DHCP para fornecer também a 
mascara de rede, gateway, DNS e outras opções, muito útil e prático. 
Consome o mínimo de recursos da maquina, desprezível, considere usar um micro da rede que 
fique sempre ligado, entre eles pode ser o servidor Samba, proxy, firewall, o importante é manter 
ligado para não falhar no fornecimento ou renovação do IP, não precisa ser o micro que compartilha 
internet ou servidor proxy, pode usar qualquer maquina da rede. 
O dhcp é muito útil em ambientes de testes e manutenção, onde sempre há máquinas novas para 
conectar a rede, isso evita o problema de conflitos de Ips. 
 
Exemplo de configurador DHCP 
 
authoritative; 
# Informa que esse é o servidor DHCP com autoridade sobre a rede. 
Sempre mantenho 1 servidor DHCP na rede, mas, caso voce tenha mais de 1 é bom saber qual é o principal. 
ddns-update-style none; 
# Desativa o suporte a DNS dinâmico. 
default-lease-time 600; 
 # Servidores DHCP cedem endereços sob pedido por um tempo pré-determinado.O padrão neste exemplo é ceder o endereço IP por 
600 segundos, ou 10 minutos. 
max-lease-time 7200; 
# Caso o cliente solicite um tempo maior, o tempo máximo permitido será de 7200 segundos (2 horas) 
server-identifier 192.168.10.37; 
option domain-name "teste.com.br"; 
option domain-name-servers 192.168.10.37; 
option host-name "proxy1"; 
option routers 192.168.10.254; 
option subnet-mask 255.255.255.0; 
option broadcast-address 192.168.10.255; 
subnet 192.168.10.0 netmask 255.255.255.0 { 
 range 192.168.10.206 192.168.10.253; 
} 
host marcio_wireless { 
 hardware ethernet 00:1F:3C:02:96:97; 
 fixed-address 192.168.10.251; 
} 
host marcio { 
 hardware ethernet 00:1b:38:d3:62:d1; 
 fixed-address 192.168.10.38; 
 } 
host luiz { 
 hardware ethernet 00:1c:bf:31:14:87; 
 fixed-address 192.168.10.238; 
 } 
host paulo-wireless { 
 hardware ethernet 00:12:f0:2f:75:4d; 
 fixed-address 192.168.10.7; 
} 
 
 
 
SAMBA 
 
O SAMBA é um aplicativo que torna possível o compartilhamento de recursos com máquinas 
rodando Windows®. O nome SAMBA é derivado do protocolo utilizado pelo Windows® para 
compartilhar discos e impressoras: o protocolo SMB, Server Message Block. 
Através da utilização do SAMBA é possível criar redes mistas, utilizando servidores Linux e clientes 
Windows®. O SAMBA também permite que o Linux acesse discos exportados de máquinas 
Windows®. Além de compartilhar recursos, o SAMBA é capaz de executar várias funções de um 
servidor Windows®, como por exemplo autenticação de clientes, servidor WINS, e até mesmo agir 
como um Controlador Primário de Domínio (PDC). 
O SAMBA é capaz de executar muitas funções, não cobriremos o assunto em detalhes aqui. Será 
visto como instalar e fazer uma configuração básica do SAMBA, como exportar um diretório 
qualquer e como exportar os diretórios home dos usuários, permitindo assim que eles tenham 
acesso a seus arquivos de qualquer estação Windows® de sua rede. 
Adicionando Usuários ao SAMBA 
 
Adicionar um novo usuário ao Samba, é necessário que o mesmo esteja criado no linux. Para criá-lo 
no linux, você utiliza o comando: 
 
adduser <nome-do-usuário> -g <nome-do-grupo> 
passwd <nome-do-usuário> 
 
Após a criação do usuário no linux, deve-se adicionar o usuário, no arquivo de configuração do 
samba /etc/smb.conf. Em seguida, reinicie o Samba. 
 
Agora basta adicionar o usuário, no Samba, com o comando: 
 
smbadduser <nome-do-usuário>:<nome-do-grupo-no-samba> 
smbpasswd <nome-o-usuário> 
 
O configurador 
 
Abaixo estão alguns dos parâmetros usados na configuração do arquivo /etc/smb.conf: 
 
Seção [global] 
Nesta seção são definidos os parâmetros globais do Samba. Veja os 
parâmetros que podem ser usados nesta seção: 
comment 
comentário para o Host na rede. 
workgroup 
especifica o Domínio ou o Workgroup a que o Host pertence na Rede. 
security 
(O Samba utiliza segurança a nível de usuário security=user , com opções) 
_ security = share - cada recurso compartilhado necessita que uma 
senha seja informada, para a utilização daquele recurso. Geralmente 
este parâmetro é utilizado quando para estações Linux. 
_ security = user - a permissão é dada de acordo com cada usuário, na 
hora em que ele efetua o login. Está opção também se aplica a grupos 
(@grupo). 
_ security = server - o Samba validará a senha enviando os dados do 
usuário para outro servidor Samba ou Windows®, para isso deve-se 
incluir o parâmetro password server = IP_SERVIDOR , na seção global. 
_ security = domain - este parâmetro deve ser usado, se o Host for 
adicionado a um domínio Windows através do comando smbpasswd, 
então as informações são enviadas para o PDC da rede. 
os level 
este parâmetro é obrigatório, caso você utilize mais servidores Linux ou Windows. O valor é um 
número de 1 a 255, onde 65 é a mesma variável utilizada pelo Windows, especificando um número 
maior que este, você garante a escolha do servidor Samba para a validação do login nas estações. 
announce as 
especifica o tipo de servidor NetBios (nmbd) que será divulgado na sua rede. As opções válidas são: 
NT Server; NT Workstation; Win95; WFW . 
domain logons 
usado para validar logins na rede. Apenas para estações Windows. 
logon script 
define qual arquivo de logon script será executado para os usuários. Deve-se criar o 
compartilhamento de nome [netlogon] apontando para o diretório de scripts. 
logon path 
é o caminho do perfil remoto do usuário. Este parâmetro é útil, quando 5 usuários costumam fazer 
o login em mais de um host na rede, pois dessa forma seu perfil é trazido com o login. 
domain master 
informa se o Host será o Domain Master Browser da rede toda. 
local master 
informa se o Host será o Master Browser da rede local. 
prefered master 
com este parâmetro, força-se o Samba a atuar como Master Browser para o workgroup. Junto com 
este parâmetro, é recomendável a utilização do parâmetro domain master = yes . Porém, se sua na 
sua rede tiver outros servidores (Windows e até mesmo Samba), e alguns desses outros já forem 
Domain Master, não utilize esta opção e deixe o parâmetro os level = 65 . 
guest account 
para que ocorra uma melhor performance em redes Windows, é recomendável a utilização de uma 
conta guest(visitante), por padrão, no Samba, a conta usada é nobody. 
wins server 
aqui deve ser informado qual é o servidor Wins da rede. Caso o próprio Host seja, então não utilize 
este parâmetro, pois o sistema entrará em loop e conseqüêntemente travará. 
wins support 
permite que o Samba seja o servidor Wins da rede, onde conterá uma tabela com o ambiente de 
rede completo. Dessa forma há um certo ganho no desempenho, quando um determinado host for 
localizar outra maquina na rede, por exemplo. 
keep alive 
verifica o estado dos hosts (ativos ou não), este parâmetro deve ser utilizado quando as estações 
forem Windows, e constantemente travam. Com a utilização deste parâmetro, evita-se o tráfego 
desnecessário de informações na rede. Também pode ser usado com estações Linux. 
debug level 
este parâmetro forneve ao Samba, uma maior flexibilidade para trabalhar com algumas situações 
de erro. 
winpopup command 
define-se qual o comando será executado quando o servidor receber mensagens Winpopup(existem 
muitas configurações, que podem ser colocadas aqui). É interessante utilizar essa opção se a sua 
rede utiliza mensagens desse tipo. 
log file 
especifica o arquivo de log do Samba. Por padrão os arquivos de log gerados pelo Samba, estão em 
/var/log/samba . 
null passwords 
define a permissão para contas de usuários sem senha. 
1 password sync 
caso este parâmetro esteja ativado (com valor = yes), permiteque estações Windows troquem de 
senha. 
socket options 
este parâmetro permite configurações extras para o protocolo, possibilitando uma melhor 
performance do servidor para trablhar com os pacotes de rede. 
printing 
define qual o sistema padrão de impressão utilizado pelo Linux. 
printcap name 
define qual o arquivo que contém informações das impressoras. 
load printers 
disponibiliza as impressoras para a rede. 
hosts allow 
define qual máquina tem acesso a rede. Pode-se utilizar o IP ou o nome da máquina. Para definir 
uma rede toda usa-se: " hosts allow = 192.168.10. " . 
hosts deny 
define qual máquina nõ terá acesso a rede. Deve ser utilizado da mesma forma que o parâmetro 
hosts allow . 
admin users 
define quais usuários possuem permissão completa (permissão de root ). 
max disk size 
especifica qual o limite de espaço em disco que será utilizado. O valor deve ser informado em 
Megabytes. Para especificar, por exemplo, um determinado valor para a sessão home (vista logo 
abaixo), você deve trabalhar com as quotas do Linux. 
Seção [homes] 
Nesta seção, define-se os parâmetros para as pastas pessoais dos usuários. 
comment 
parâmetro de comentário para este compartilhamento. 
public 
este parâmetro define se outros usuários poderão acessar o compartilhamento. 
browseable 
define se o compartilhamento será visível ou não no Ambiente de Rede. 
writeable 
define a permissão de escrita para o usuário. 
Seção [netlogon] 
Nesta seção, define-se os parâmetros para os scripts de login dos usuários. 
comment 
parâmetro de comentário para este compartilhamento. 
path 
define o local onde estão os scripts de cada usuário. 
public 
este parâmetro define se outros usuários poderão acessar o 
compartilhamento. 
browseable 
define se o compartilhamento será visível ou não no Ambiente de Rede. 
writeable 
define a permissão de escrita para o usuário. 
Demais Seções [NOME_SESSÃO] 
Cada sessão é um compartilhamento existente na rede. Abaixo, estão alguns parâmetros que 
podem ser usados nesta seção. 
comment 
parâmetro de comentário para este compartilhamento. 
path 
define o local onde está o compartilhamento. 
valid users 
aqui deve ser informado o nome dos usuários que tem permissão para acessar este 
compartilhamento. 
writeable 
define se será ou não permitido criar ou excluir arquivos ou diretórios deste compartilhamento. 
public / guest ok 
este parâmetro define se outros usuários poderão acessar o compartilhamento. 
browseable 
define se o compartilhamento será visível ou não no Ambiente de Rede. 
write list 
define os usuários/grupos que terão acesso de escrita no compartilhamento. Para utilizar vários 
nomes de usuários, deve-se usar virgula(,) entre os nomes de cada usuário. 
Para grupos deve-se usar @nome_do_grupo. 
read list 
define os usuários/grupos que terão acesso de leitura no compartilhamento. 
force create mode 
este parâmetro, faz com que o Samba forçe o tipo de permissão para cada arquivo criado dentro do 
compartilhamento, seria semelhante ao chmod do Linux. 
force directory mode 
este parâmetro, faz com que o Samba forçe o tipo de permissão para cada diretório criado dentro 
do compartilhamento, seria semelhante ao chmod do Linux. 
copy 
copia os parâmetros de outra seção. É útil se você utiliza compartilhamentos semelhantes. Para a 
alteração de algum parâmetro, basta você modificá-lo na seção atual. 
max connections 
define o número máximo de conexões simultâneas que o compartilhamento pode "responder". 
 
Em alguns parâmetros usa-se variáveis, abaixo, encontra-se algumas variáveis mais utilizadas. 
 
_ %S - Nome do Serviço (compartilhamento) atual; 
_ %u - Nome do usuário; 
_ %g - Nome do grupo; 
_ %H - Nome do diretório pessoal do usuário (home dir); 
_ %m - Nome da máquina cliente fornecido pelo NetBios; 
_ %L - Nome do Servidor NetBios, permitindo que a configuração desejada seja alterada de acordo 
com o cliente que vai acessar o sistema; 
_ %M - Nome Internet da máquina cliente; 
_ %a - Sistema Operacional da máquina remota, onde são reconhecidos: WFW, WinNT e Win95; 
_ %I - O endereço IP da máquina cliente; 
_ %T - Data e Horário. 
Após a configuração do arquivo smb.conf, você pode fazer um teste para saber se a configuração 
está correta, para isto utiliza-se o comando testparm: 
 
testparm 
 
Confira o resultado apresentado na tela. Caso apareça alguma mensagem de erro edite novamente 
o arquivo de configuração (smb.conf). 
 
Exemplo de um smb.conf simples e funcional 
[global] 
workgroup = INFORMATICA 
netbios name = FEDORA_HOME 
server string = SAMBA SERVER – LINUX 
security = user 
encrypt password = yes 
add machine script = /usr/sbin/adduser -n -r -g machines -c "Samba machine" -d /dev/null -s 
/bin/false %u 
add user script = /usr/sbin/useradd -d /dev/null -g 100 -s/bin/false -M %u 
passdb backend = smbpasswd 
browseable = yes 
 
[homes] 
comment = Diretorios HOME (Linux) 
path = /home/%u/docs 
valid users = %S 
read only = no 
browseable = no 
writeable = yes 
#create mask = 777 
#directory mask = 775 
[backup] 
comment = LINUX Fedora - Backup – Teste 
public = yes 
path = /backup 
writeable = yes 
browseable = yes 
valid users = marcio 
create mask = 777 
directory mask = 777 
guest ok = yes 
 
REFERÊNCIAS 
 
 
www.wikipedia.org 
http://my.opera.com/Ricardo%20Belfiglio/blog/show.dml/586273 
http://www.guiadohardware.net/tutoriais/instalando-fedora - Júlio César Bessa Monqueiro 
http://robertors.blogspot.com/2006/09/linux-permisses-de-acesso-especiais.html - Roberto 
Rodrigues da Silva 
http://www.criarweb.com/artigos/servidor-ftp-em-linux.html 
http://renator.wordpress.com/2007/01/26/instalando-um-servidor-ftp-vsftp 
http://www.velnetsupport.co.uk/parrots/FTP/Filezilla/ 
http://www.rnp.br/newsgen/9708/n3-3.html 
http://www.primeirospassos.org/sessao10_7.html 
http://www.devin.com.br/intro_linux 
http://www.zoomdigital.org/2008/07/gerenciando-o-linux-a-partir-do-windows 
http://www.inf.ufes.br/~proinfo/docs/samba/samba.html 
Dominando LINUX Red Hat e Fedora, Bill Ball e Hoyt Duff, 2004, Makron Books 
Apostila LINUX Ong IDEPAC – 2005 - Bruno César Brito Sant'Anna 
APOSTILA TREINAMENTO AVANÇADO EM LINUX v1.5 - Rodrigo Rubira Branco - Firewalls Security 
http://www.guiadohardware.net/termos/cron 
Apostila – Configurando o Samba - Bruno T. Russo 
http://www.infowester.com/comandoslinux.php - Emerson Alecrin 
http://www.infowester.com/linprocessos.php - Emerson Alecrin 
http://www.infowester.com/linuxvi.php 
 
Marcio Adroaldo da Silva 
marcio_ad@yahoo.com.br 
marcio.infocus@gmail.com