Apostila LINUX - Carlos Piergentile

Transcrição

LINUX
Marcio Adroaldo da Silva - 2009
[email protected]
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 que trabalhem 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 malintencionadas. 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.
2.
3.
4.
A liberdade de executar o programa, para qualquer propósito;
A liberdade de estudar como o programa funciona e adaptá-lo para as suas necessidades;
A liberdade de redistribuir cópias de modo que você possa ajudar ao seu próximo;
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.
Atualmente temos 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 rivalidade
existente 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 sem custos.
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
Fedora Core 1.0 5 de novembro de 2003
Fedora Core 2.0
18 de maio de 2004
Codinome
Descrição
"Yarrow"
kernel 2.4
"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 para todos 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:
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:
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ãoadministradores. 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 ao processo 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
0
1
2
3
4
5
6
Significado
Neste nível o sistema está parado
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.
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
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.
Este nível não é utilizado na maior parte das distribuições
Semelhante ao nível 3, com todos os processo ativos, porém com uma interface gráfica
de logon.
É 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
finger usuá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
-g
-G
-d
-s
UID (número de identificação do usuário, caso seja omitido o sistema insere um número
automaticamente)
Grupo primário a que o usuário pertence ( caso seja omitido o sistema cria um grupo
com o nome do usuário)
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)
Diretório home do usuário (caso seja omitido o sistema vai criar um diretório /
home/nomedousuário)
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 de dados 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: "CentOSBase.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 yum utiliza 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—
bruno
Users
Permissões de acesso a este arquivo/diretório.
Usuário dono deste arquivo/diretório.
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:
● 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ão de 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/
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/
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
7
6
5
4
3
2
1
0
Triplet
rwx
rwr-x
r--wx
-w--x
---
Veja o exemplo abaixo a utilização do modo numérico:
# chmod 664 /aulas/aula7/arquivo1.txt
$ ls /aulas/aula7/
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 temporariamente a 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 é verificar a 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
Pode também remover até o final de uma frase: d$
de
uma
palavra,
utilizando:
dw
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
/palavra1\|palavra2
uma
busca
de
2
palavras
ao
mesmo
tempo:
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. Se você 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
Executa COMANDO na máquina local.
!
! COMANDO
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
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
Muda para o diretório que está um nível acima do diretótio atual
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 ARQUIVOLOCAL
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 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 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 DIRETÓRIOS ARQUIVO-LOCAL
Semelhante a ls, porém lista o conteúdo de vários diretórios
mode MODO
Configura o modo de transferência de arquivos para MODO. O
modo padrão é "stream"
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 ARQUIVOLOCAL
Substitui o ARQUIVO-LOCAL pelo ARQUIVO-REMOTO se a hora
de modificação do ARQUIVO-REMOTO for mais recente
Binary
Cdup
Chmod
Ls
Mdelete
Mls
Mode
Modtime
Nlist
nlist DIRETÓRIOS ARQUIVO-LOCAL
Semelhante a nls
Put
put ARQUIVO-LOCAL ARQUIVOREMOTO
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 ARQUIVOLOCAL
Semelhante a get
reget ARQUIVO-REMOTO ARQUIVOLOCAL
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.
Reget
remotehelp remotehelp COMANDO
rhelp
rhelp COMANDO
remotestatus remotestatus ARQUIVO
rstatus
rstatus ARQUIVO
Rename
Semelhante a help, porém solicita ajuda ao servidor ftp
Exibe a situação de ARQUIVO. Se ARQUIVO não for especificado,
exibe a situação da máquina remota.
rename NOME-ANTIGO NOME-NOVO Renomeia um arquivo
Rmdir
rmdir DIRETÓRIO
Apaga DIRETÓRIO
Send
send ARQUIVO-LOCAL ARQUIVOREMOTO
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 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
Type
?
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 texto puro. 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.
# sshd_config(5) for more information.
See
# This sshd was compiled with PATH=/usr/bin:/bin:/usr/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 key
#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 files
#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_hosts for
# RhostsRSAAuthentication and HostbasedAuthentication
#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 kaserver
#KerberosTgtPassing no
# Set this to 'yes' to enable PAM keyboard-interactive 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
AllowUsers
sftp
/usr/libexec/sftp-server
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 [email protected]:/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 [email protected]:/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 * [email protected]:/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 [email protected]:/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ços IP 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
option host-name
192.168.10.37;
"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;
}
host luiz {
hardware ethernet 00:1c:bf:31:14:87;
}
host paulo-wireless {
hardware ethernet 00:12:f0:2f:75:4d;
}
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), permite que 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
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
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
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
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
[email protected]
[email protected]

Apostila LINUX - Carlos Piergentile

Transcrição

Documentos relacionados

Assunto: : Aplicativos

Adoção do Linux na atual crise financeira global

Rafaelle Magella de Santiago - PMI-CE

Apresentação - PHLC Development Blog

Bloco da ale gria Oficina de for ma ta ção Top

Assunto: : Sugestões

Assunto: : Sugestões

FORMAÇÃO FEVEREIRO 2014 Porto XD nível 1 e 2 / Linux prático

Permissão de escrita

PC Guia | Raúl Oliveira confirmado no evento Linux 2013