CAPÍTULO # 8 : APRENDENDO ADMINISTRAÇÃO DE SISTEMAS

Administrador do Sistema : A pessoa responsável em gerenciar os recursos sistema.

Para realizarmos a maior parte das tarefas de administrador de sistema Linux, é

preciso que loguemos com o usuário root que também é conhecido como
superusuário ou obtermos temporariamenteas permissões de root.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
1 - ENTENDENDO A ADMINISTRAÇÃO DO SISTEMA
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

Por motivos de segurança, o administrador de sistemas normalmente faz o login com

uma conta normal e quando necessário, requisita os privilégios
administrativos.

Os privilégios administrativos podem ser solicitados das seguintes formas:

O comando su
Normalmente se abre um shell onde depois se é executado esse comando para se
ter os privilégios de root, mas depois de terminar a sua necessidade,
essa shell é fechada.

O comando sudo
Em uma única shell, se executa o comando sudo de formas a se executar outros
comandos como root.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----
3 - USANDO A CONTA DO USUÁRIO ROOT
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----

Na maior parte das vezes, loga-se como um usuário comum e depois torna-se o usuário
root para fazer as tarefas administrativas.

Nota que muitos sistemas Linux não permitem que o usuário root faça o login a
partir da rede por motivos de segurança. Com o comando su, é possível atuar
como root mas, esse comando por si só, não nos dá o ambiente do usuário root e por
consequência, certos comandos reservados para esse user, podem não
funcionar. Para resolver esse caso, usamos o comando su com a opção - .

$ su -
Password: ******
#

Podemos também logar com qualquer outro usuário

$ su -user
Password: ******
$
 * Permitindo Acesso Administrativo por Meio da Interface Gráfica

* Ganhando Acesso Administrativo com sudo

Usuários normais podem também ter privilégios administrativos se forem

adicionados no arquivo sudoers. Todo o comando executado pelo usuário
será precedido do comando sudo.

É recomendável que o arquivo sudoers seja editado com o comando visudo.

# usr/sbin/visudo

Para atribuir plenos privilégios de root:

username ALL=(ALL) ALL

Desta forma, o usuário poderá executar comandos administrativos

precendendo-os com o comando sudo mas, terá que inserir a sua senha.

Para atribuir privilégios administrativos sem a necessidade de inserir

a senha:

username ALL=(ALL) NOPASSWD:ALL

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----
4 - EXPLORANDO COMANDOS ADMINISTRATIVOS, ARQUIVOS DE CONFIGURAÇÃO E ARQUIVOS DE LOG
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----

* Comandos Administrativos

Muitos comandos só podem ser executados pelo usuário root. A variável

$PATH guarda o caminho dos diretórios de muitos desses comandos.
Alguns desses diretórios são:

/sbin

Contém comandos necessários para iniciar o sistema,

comandos para verificar sistemas de arquivos (fsck) e comandos para
iniciar ou parar serviços do sistema (sistema).

/usr/sbin

Contém comandos para gerenciar contas de usuários tais como

useradd, comandos que verificam os processos que seguram
arquivos abertos tais como lsof.

Outros comandos administrativos estão localizados em diretórios de

usuários regulares tais como /bin e /usr/bin.
 * Arquivos de Configuração Administrativa

Para além dos comandos administrativos, também temos os arquivos

administrativos. Todas as configurações nos sistemas Linux são armazenadas
em arquivos de texto simples.

Os dois diretórios principais dos arquivos de configuração são o

diretório home que contém as configurações pessoais do usuário e o
diretório /etc que contém as configurações do sistema.

$HOME - Os usuários armazenam suas informações em seus diretórios

iniciais, essas informações determinam como as contas de cada usuário se
comporta. Muitos dos arquivos de configuração se encontram mesmo no
diretório inicial de cada usuário e tendem a começar com um ponto (.), de
formas que eles não aparecem no diretório quando se faz uma listagem
simples com o ls. Para que possamos ver esses arquivos, usamos o ls -a.
Alguns arquivos ponto definem o comportamento do shell de cada usuário,
o comportamento e aparência do desktop emuito mais. No diretório
inicial, também podemos encontrar arquivos .ssh que configuram
permissões de rede para cada usuário. Para se ver o nome do seu diretório
inicial,

echo $HOME

/etc - Esse diretório contém a maior parte dos arquivos de configuração

do sistema Linux.

/etc/cron* - aqui existem arquivos que definem como o utilitário crond

executa aplicativos com base em uma agenda diária (cron.daily), de hora
em hora (cron.hourly), mensal (cron.monthly) ou semanal (cron.weekly).

/etc/cups - Contém arquivos usados para configurar o serviço de

impressão CUPS.

/etc/default - Contém arquivos que definem valores padrão diversas

utilidades. Por exemplo, o arquivo para o comando useradd define o número do
grupo padrão, o diretório inicial, a data de expiração da senha, o
shell e o diretório esqueleto (/etc/skel) que são utilizados para criar uma
nova conta de usuário.

/etc/httpd - Contém uma variedade de arquivos usados para configurar o

comportamento do servidor web Apache (especificamente, o processo httpd).
Em alguns sistemas Linux, é utilizado o diretório /etc/apache ou
/etc/apache2.

/etc/init.d - Contém as cópias permanentes dos scripts de nível de

execução no estilo System V.

/etc/mail - Contém arquivos usados para configurar o agente de

transporte de e-mail sendmail.

/etc/pcmcia -

/etc/postfix -

/etc/ppp -

/etc/security -
 /etc/sysconfig - Contém arquivos do sistema de configuração que são
criados e mantidos por vários serviços tais como, iptables, samba e a maioria
dos serviços de rede.

Alguns arquivos de configuração importantes no /etc:

aliases - Pode conter listas de distribuição utilizadas pelo

serviço de email Linux. (/etc/email)

bashrc - Define todos os padrões de nível de sistema para

usuários do shell bash. Isso pode ser chamado bash.bashrc em algumas distros.

crontab - Configura a data e a hora para a execução de tarefas

automatizadas e variáveis associadas com o recurso cron (como o SHELL e PATH
associado com o cron).

hosts - Contém endereços IP e nomes de host que você pode

alcançar a partir de seu computador. (Normalmente esse arquivo
é usado apenas para armazenar nomes de computadores em sua rede
local ou pequena rede privada.)

passwd - Armazena informações das contas de todos os usuários

válidos no sistema. Também inclui outras informações tais
como o diretório inicial e o shell padrão. Raramente inclui as
senhas em si, que normalmente estão armazenadas no arquivo
/etc/shadow.

sudoers - Configura comandos que podem ser executados usuários,

que exceto por isso não tem permissão para executar o comando,
usando o comando sudo. Em particular, esse arquivo é utilizado
para fornecer a usuários selecionados permissão de root.

* Arquivos de Log Administrativos

Os arquivos de log nos ajudam a monitorar o sistema de qualquer

anomalia.

O daemon rsyslogd é a utilidade principal para o registro em log de

erros e mensagens de depuração em Linux. Em sistemas mais antigos,
usa-se o syslogd.

O registro em log será feito de acordo com informações no arquivo

/etc/rsyslog.conf. As mensagens são normalmente direcionadas
para arquivos de log que geralmente estão no diretório /var/log. Alguns
arquivos de log comuns são:

boot.log - Contém mensagens de boot sobre serviços à medida que

eles iniciam.

messages - Contém muitas mensagens informativas de gerais sobre o

sistema.

secure - Contém mensagens relacionadas à segurança, como a

atividade de login ou qualquer outro ato que autentica usuários.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----
5 - USANDO OUTRAS CONTAS ADMINISTRATIVAS
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

Os logins administrativos estão disponíveis no Linux, porém o login direto desses

usuários está desabilitado por padrão. As contas são mantidas
principalmente para fornecer posse de arquivos e processos associados com serviços
particulares.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----
6 - VERIFICANDO E CONFIGURANDO O HARDWARE
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

Quando seu sistema inicializa, o kernel detecta o hardware e carrega os drivers que
permitem que o Linux funcione com esse hardware. Como as mensagens sobre
a detecção de hardware passam rapidamente pela tela, para rever as mensagens de
problemas potênciais, é preciso reexibi-las depois que o sistema inicializa.

Existem duas maneiras de exibir as mensagens de inicialização do kernel depois que

o Linux inicializa. Qualquer usuário pode exibir o comando dmesg para ver
qual hardware foi detectado e quais drivers foram carregados pelo kernel durante a
inicialização. A outra forma de ver as mensagens em alguns sistemas Linux
é exibindo o conteúdo do arquivo /var/log/dmesg, se ele existir.

Uma vez que seu sistema está instalado e funcionando, existem outros comandos que
permitem que você examine para obter informações detalhadas sobre o hardware
de seu computador. O comando lspci lista barramentos PCI em seu computador e os
dispositivos conectados a eles.

$ lsusb

* Gerenciando Hardware Removível

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

CAPÍTULO # 9 : INSTALANDO O LINUX

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

CAPÍTULO # 10 : OBTENDO E GERENCIANDO SOFTWARE

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----
2 - ENTENDENDO O EMPACOTAMENTO DE SOFTWARE RPM DO LINUX
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

* Entendendo Pacotes RPM

Um pacote RPM é um conjunto de arquivos necessários para fornecer um

recurso, como um processador de texto, um visualizador de fotos ou um
servidor de arquivos. Dentro de um RPM pode estar os comandos, arquivos
de configuração e documentação que compõe o recurso de software.
Mas um arquivo RPM também contém metadados que armazenam informações
sobre o conteúdo do pacote, de onde o pacote veio, oque ele precisa para
funcionar e outras informações.

Oque há em um RPM

Para se saber o nome do de um pacote RPM instalado no sistema:

rpm -q nome_do_pacote

rpm -q firefox
Um pacote RPM instalado,o nome e outras informações sobre o pacote são
armazenados em uma base de dados RPM na máquina local.

Para saber mais sobre oque está dentro de um pacote RPM, pode-se
adicionar opções para além do comando rpm para consultar a base de dados RPM
local.

rpm -qi firefox (opção query information/consultar

informações)

De onde vêm os RPMs?

Os softwares vêm incluídos com as distros ou são construídos por

terceiros para trabalharem com essas distros. Eles vêm de
milhares de projetos de código aberto de todo o mundo. Esses
projetos são conhecidos como fornecedores de software upstream, geralmente
tornam o software disponível para quem os quiser utilizar sob
certas condições de licenciamento.

Instalando RPMs

Quando se instala uma distro, ela vem já com um conjunto de

pacotes RPMs individuais instalados. Depois de instaldo, o Linux permite a
a adição de novos pacotes RPMs.

A primeira ferramenta desenvolvida para se instalar pacotes foi o

rpm, com ela podemos instalar, atualizar, consultar, validar e remover
pacotes RPM. O comando porém tem algumas desvantagens:

Dependências - A maioria dos pacotes RPM dependem de

algum outro software (bibblioteca, arquivos executáveis etc) que é instalado
no sistema para o pacote funcionar.
 Localização dos RPMs - O comando rpm espera que você
fornece a localização exata do arquivo RPM quando quando tenta instalá-lo.
Em outras palavras, você teria de indicar firefox-10.0.3-
1.e16_2x86_64.rpm como uma opção se o RPM estivesse no diretório atual ou
http://example.com/firefox-10.0.3-1.e16_2.x86_64.rpm se
fosse um servidor.

-----------------------------------------------------------------------------------
-------------------------------------------------------------------------
3 - GERENCIANDO PACOTES RPM COM O YUM
-----------------------------------------------------------------------------------
-------------------------------------------------------------------------

O projeto Yellowdog Updater Modified (YUM) foi criado para resolver a dor de cabeça
de gerenciar dependências com pacotes RPM. Sua principal contribuição foi
a de parar de pensar em pacotes RPM como componentes individuais e pensar neles
como partes de repositórios de software maiores.

Com repositórios, o problema de lidar com dependências não recai na pessoa que
instalava o software, mas na distribuição Linux ou no distribuidor de software
independente que disponibiliza o software. Por exemplo, caberia a distro se
certificar de que todos os componentes necessários para cada pacote em sua
distribuição Linux podem ser disponibilizados por algum outro pacote no
repositório.

Os repositórios yum podem ser colocados em um diretório em um servidor web

(http://), servidor FTP(ftp://) ou mídia local, como um CD,DVD ou diretório local
(file://). A localização desses repositórios, então, seria armazenada no sistema do
usuário no arquivo /etc/yum.conf ou, mais geralmente, em arquivos de
configuração separados no diretório /etc/yum.repos.d

* Entendendo como funciona o yum

A sintaxe básica do comando yum é:

# yum [options] command

Com essa sintaxe é possível encontrar e consultar as informações de

pacotes, saber mais sobre grupos de pacotes, atualizar ou excluir pacotes,
para citar alguns recursos. Com o repositório YUM e aconfiguração no
lugar, um usuário pode instalar um pacote simplismente digitando:

# yum install firefox

O resultado de um comando yum install package é que o pacote solicitado

é copiado a partir do repositório yum para o sistema local. Os arquivos
do pacote são colocados no sistema de arquivos onde são necessários
(/etc, /bin, /usr/share/man etc). As informações sobre o pacote são
armazenadas no banco de dados RPM local, onde podem ser consultadas.

1. Verificando /etc/yum.conf

Quando qualquer comando yum é iniciado, ele verifica as

configurações padrão no arquivo /etc/yum.conf. Este arquivo é de configuração
básica
do YUM. É também possível identificar a localização dos
repositórios aqui, embora o diretório /etc/yum.repos.d seja o local mais típico
para
identificar repositórios.

Para encontrar outros recursos que você pode definir no arquivo

yum.conf, digite

man yum.conf

2. Verificando /etc/sysconfig/rhn/up2date(RHEL somente)

5. Pacotes RPM instalados para o sistema de arquivos Linux

Depois de todos os pacotes necessários são transferidos para os

diretórios de cache, o comando yum roda comandos rpm para instalar cada pacote.

6. Armazene o repositório de metadados YUM no banco de dados RPM local.

* Usando o YUM com repositórios de software de terceiros

Os metadados contidos em cada pacote RPM instalado são, por fim,

copiados para o banco de dados RPM local. O banco de dados RPM está contido nos
arquivos que são armazenados no diretório /var/lib/rpm.

Depois que as informações sobre os pacotes instalados estiverem na base

de dados RPM local, é possível fazer vários tipos de consulta e essa base de
dados. É possível ver quais pacotes estão instalados, listar os
componentes desses pacotes e ver scripts ou mudar logs associadosa cada pacote. É
possível até validar os pacotes instalados para ver a sua autenticidade
caso alguém os adultere.

O comando rpm é a melhor ferramenta para consultar a base de dados RPM.

Este pode ser usado para se fazer consultas individuais ou usá-los em scripts
para produzir relatórios ou executar consultas comuns repetidamente.

* Gerenciando Software com o Comando YUM

O comando yum tem dezenas de subcomandos que podem ser usados para
trabalhar com pacotes RPM no sistema. Podemos utilizá-los para procurar, instalar,
consultar e atualizar pacotes associados com seus repositórios YUM.

Procurando por pacotes

Usando diferentes subcomandos de pesquisa, você pode encontrar

pacotes com base em palavras-chave, conteúdo ou outros atributos deles.

yum search pacote - Procurar por um pacote em específico

yum info pacote - Obter informações sobre um pacote
yum list pacote - Listar nomes de pacotes de diferentes
formas
yum deplist pacote - Listar as dependências de um pacote

Instalando e removendo pacotes

O subcomando install permite instalar um ou mais pacotes,

juntamente com todos os pacotes dependentes necessários. Com yum install, múltiplos
repositórios podem ser pesquisados para satisfazer as
dependências necessárias.

yum install pacote

Para reinstalar um pacote

yum reinstall pacote

Para remover um único pacote

yum erase pacote

Uma boa maneira de vermos quais pacotes desinstalar, é vermos o

histórico de todas as atividades executadas com o yum

yum history - Para ver todas as atividades

yum history info ID - Para ver o historial da instalação de

um comando

yum history undo ID - Desinstalar um pacote

Atualizando pacotes

Sempre que novas releases de um pacote se tornam

disponíveis, elas podem ser colocadas em repositórios de atualização separados ou
adicionados ao repositório original. Se várias versões de
um mesmo repositório estiverem disponíveis, quer no mesmo repositório ou
em repositórios diferentes, o comando yum fornece a versão
mais recente quando você instala um pacote. Se uma nova versão existir
mais tarde, usamos o subcomando update

yum update - Faz update de qualquer pacote com

atualizações disponíveis
yum update pacote - Faz um update de um pacote
específico

Para verificarmos updates disponíveis:

yum check-update
yum check-update pacote

Atualizando grupos de pacotes

Para ver uma lista de nomes de grupos :

yum grouplist | less ou yum grouplist

Para vermos oque está dentro de um grupo:

yum groupinfo LXDE

Para instalar um grupo de pacotes:

 yum groupinstall groupname

Para remover um grupo de pacotes:

yum groupremove groupname

Mantendo a base de dados e o cache de pacotes RPM

Há vários subcomandos do yum que podem ajudar-nos a fazer

as tarefas de manutenção, tais como verificar problemas com a base de dados RPM ou
limpar o
cache. O recurso YUM tem ferramentas para manter os pacotes
RPM e manter o software de seu sistema eficiente e seguro.

Limpar o cache é algo que é recomendável fazer de vez em

quando. Se os pacotes baixados se mantiverem depois de instalados, eles são
removidos por
padrão, com base na configuração keepcache=0 no arquivo
/etc/yum.conf, os diretórios de cache em /var/cache/yum podem ficar cheios.
Metadados
armazenados em diretórios de cache podem ser apagados,
fazendo com que novos metadados sejam baixados de todos os repositórios YUM
habilitados da
próxima vez que o comando yum for executado. Eis algumas
formas de limpar essas informações:

yum clean packages

yum clean metadata

Caso a base de dados RPM esteja corrompido, para

verificarmos os erros:

yum check

Para reconstruir os arquivos da base de dados do RPM

yum clean rpmdb

A rpmdb é uma das poucas opções do yum que é usada para

trabalhar com a base de dados RPM diretamente. Emgeral, o yum é usado para
manipular
repositório yum. O comando mais adequado para trabalhar com
a base de dados RPM local é o rpm.

Baixando RPMs de um repositório yum

Se quiser apenas examinar um pacote sem realmente instalá-

lo, Pode se utilizar o comando yumdownloader. Executar esse comando faz com que o
pacote nomeado seja baixado a partir do repositório YUM e
copiado para o diretório atual.

Exemplo : Baixar a última versão do Firefox do repositório

YUM para o diretório atual:
 yumdownloader firefox

Com o pacote RPM agora no diretório atual, é possível usar

uma variedade de comandos rpm para consultar ou usar uma variedade de comandos rpm
para
consultar ou usar esse pacote de diferentes formas.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----
4 - INSTALANDO, CONSULTANDO E VERIFICANDO SOFTWARE COM O COMANDO RPM
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

Existe uma riqueza de informações sobre os pacotes instalados na base de dados RPM
local. O comando rpm contém dezenas de opções para que se possa encontrar
informações sobre cada pacote, como os arquivos que ele contém, quem criou, quando
foi instalado, o seu tamanho e muitos outros atributos. Uma vez que a
base de dados contém impressões digitais (md5sums) de cada arquivo em cada pacote,
ele pode ser consultado com o RPM para descobrir se arquivos de qualquer
pacote foram adulterados.

O comando rpm também pode ser usado para fazer instalação básica e atividades de
atualização, embora a maioria das pessoas só use o rpm dessa forma quando há
um pacote residindo no diretório local, pronto a ser instalado.

Com o pacote zsh copiado para o diretório atual, vamos experimentar alguns comandos
rpm nele.

* Instalando e Removendo Pacotes com o Comando rpm

Para se instalar um pacote com o comando rpm:

rpm -i zsh-4.3.17-1-1-31-2-fc16-noarch.rpm

O nome completo do pacote é dado para instalar com o comando rpm. Se

existir uma versão anterior do zsh estivesse instalada, o pacote pode também ser
utualizado usando a opção -U. Muitas vezes as pessoas usam -h e -v para
obter sinais de jogo da velha impressos e uma saída mais detalhada durante a
atualização:

rpm -Uhv zsh-4.3.17-1-1-31-2-fc16-noarch.rpm

* Consultando Informações do rpm

Informações do pacote podem ser consultadas uma vez que este esteja
instalado. Usando a opção -q, é possível ver as informações sobre o pacote,
incluindo uma descrição (-qi), uma lista de arquivos (-ql), a
documentação (-qd) e os arquivos de configuração (-qc).

rpm -qi zsh

rpm -ql zsh

 rpm -qd zsh

rpm -qc zsh

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

CAPÍTULO # 11 : GERENCIANDO CONTAS DE USUÁRIO

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----
1 - CRIANDO CONTAS DE USUÁRIO
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----

Cada pessoa que utiliza o sistema Linux o faz através de uma conta de usuário
separada. Ter uma conta de usuário fornece a cada pessoa uma área para armazenar
arquivos de maneira segura e um meio de adequar a interface com o usuário para
satisfazer a maneira como o usuário utiliza o computador.

Campos a preencher:

User Name - É recomendável utilizar até ao máximo 8 letras, todas minúsculas,

sem caracteres de controle ou espaços. O comando useradd permite até 32
caracteres.

Full Name - O nome real do usuário, normalmente utilizado com letras

maiúsculas e minúsculas.

Password - A senha deve ter pelo menos oito caracteres e conter palavras
reais, letras repetidas ou letras sequenciais do teclado.

Login Shell - O shell bash é usado por padrão. Mas, é possível selecionar a
partir de uma lista de shells que estão instalados no sistema.

Create home directory - O diretório inicial, por padrão é o /home/usuário. É

possível especificar um local diferente.

Create a private group for the user - O grupo principal do usuário tende a
ter o mesmo nome com o usuário.

Specify user ID manually - Se este campo não for preenchido, o usuário recebe
o próximo ID numérico. IDs de usuários começam em 500, em alguns sistemas Linux
começam
em 1.000.

Specify group manually - Este campo pode ser usado para atribuir um grupo ao
usuário de forma manual.

* Adicionar usuários com o useradd

 Ao abrir uma janela de terminal com permissão de root, invoque o comando
useradd no prompt de comando, com os detalhes da nova conta como parâmetros.

Algumas opções para o comando useradd:

-c : Serve para comentário. Normalmente usado para dar entrada do nome

completo do usuário (-c Gerson ou -c "Gerson Muel").

-d : diretório_inicial. Define o diretório inicial para a conta a ser

criada. É recomendado dar o nome do diretório inicial o mesmo do login e colocá-lo
em /home.

-D : Em vez de criar uma conta nova, salve as informações fornecidas

como as novas configurações padrão para todas as novas contas que forem criadas.

-e : data_de_expiração. Atribui-se uma data de expiração da conta no

formato AAAA-MM-DD.Por exemplo, -e 2013-05-05.

-f -1 : Defina o número de dias após a senha expirar até que a conta

seja permanentemente desativada. O padrão, -1, desabilita a opção. Configurar isso
como 0
desativa a conta imediatamente após a senha expirar. Substitui-se
o -1 pelo número desejado.

-g grupo : Configure o grupo principal que já deve existir no

arquivo /etc/group a que o novo usuário pertencerá.Sem essa opção, um novo grupo é
criado com o mesmo
nome do usuário e esse novo grupo é usado como o principal do
usuário.

-G lista_de_grupos :Adicione o novo usuário à lista de grupos

adicionais separadas por vírgulas fornecida. Por exemplo,

-G wheel, sales, tech, lunch

Note que para adicionarmos mais grupos adicionais à um usuário,

usermod -aG nome_do_grupo

-k dir_esqueleto : Defina o diretório esqueleto que contém arquivos de

configuração inicial e scripts de login que devem ser copiados para o diretório
inicial de um novo
usuário. Esse parâmetro pode ser utilizado em conjunto com a opção -m.
Substitua dir_esqueleto pelo nome do diretório a usar. Sem essa opção, o
diretório /etc/skel é
utilizado.

-m : Crie automaticamente o diretório inicial do usuário e copie os

arquivos no diretório esqueleto /etc/skel para ele. Note que esse padrão não é em
todas as distros.

-M : Não crie o diretório inicial do novo usuário, mesmo que o

comportamento padrão seja criá-lo.

-n : Desativa o comportamento padrão de criar um novo grupo que

coincide com o nome e o ID de usuário do novo usuário. Essa opção está disponível
em apénas o Fedora e RHEL.
 Outras distros costuman atribuir um novo usuário ao grupo chamado
users.

-p : Digite uma senha para a conta que está sendo criada. Ela deve ser
uma senha criptografada ou pode-se simplismente usar o comando passwd. Para gerar
uma senha
criptografada MD5, digite openssl passwd.

-s : Especifique o shell de comando a ser utilizado pelo novo usuário.

Por exemplo:

-s /bin/csh

-u : id_do_usuário : Especifique o número de ID do novo usuário. Sem

esta opção, é atribuído o próximo número disponível.

Prática:

# useradd -c "Sara Green" sara

# passwd sara
Nova senha: ********
Digite novamente a nova senha: ********

Nota:

Ao criar a conta para Sara, o comando useradd executa diversas

ações:

1. Lê os arquivos /etc/login.defs e /etc/default/useradd

para obter valores padrão para usar criar contas.

2. Verifica parâmetros de linha de comando para saber quais

valores padrão substituir.

3. Cria uma entrada de novo usuário nos arquivos

/etc/passwd e /etc/shadow com base em valores padrão e
parâmetros de linha de comando.

4. Crie qualquer entrada de novo grupo no arquivo

/etc/group.

5. Cria um diretório inicial, com base no nome do usuário,

no diretório /home.

6. Copia quaisquer arquivos localizados dentro do diretório

/etc/skel para o novo diretório.
Normalmente, isso inclui scripts de login e de
inicialização de aplicativos.

Registro de conta no arquivo /etc/passwd:

sara:x:502:507:Sara Green:/home/sara:/bin/tcsh

Nome do login:senha criptografada(/etc/shadow):ID de usuário:ID de

grupo:campo de comentário:diretório inicial:shell de comando.
 O arquivo /etc/group contém informações sobre os diferentes grupos no sistema
e os usuários que pertencem a eles. Grupos são úteis
para permitir que múltiplos usuários compartilhem o acesso aos mesmos
arquivos enquanto nega acesso a outros.

* Configurando Padrões de Usuário

* Modificando Usuários com usermod

Usado para mudar parâmetros de conta. Muitas das suas opções, são as mesmas
do useradd.

* Excluindo Usuários com userdel

Usado para remover usuários. Por exemplo:

# userdel -r sara

Remove o usuário sara do arquivo /etc/password. A opção -r remove também o

diretório inicial do usuário.

Note que a remoção da conta de um usuário não muda nada sobre os arquivos que
ele deixa por todo o sistema exceto os que são excluídos
quando se usa a opção -r. A posse dos arquivos deixados por um usuário
eliminado aparece como pertencendo ai número de ID do usuário
removido quando se utiliza ls -l nos arquivos.

Antes de se excluir um usuário, podemos executar o comando find para

localizar todos os arquivos que seriam deixados por ele. Depois de
excluir o usuário, é possível fazer a mesma pesquisa pelo ID do usuário para
encontrar os arquivos deixados por ele.

# find / -user sara -ls

# find / -uid ID -ls

Nota que não é boa prática ter arquivos no sistema que não estão atribuídos a
nenhuma conta em particular. Podemos utilizar o comando find
para localizar arquivos sem proprietários:

# find / -nouser -ls

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------
2 - ENTENDENDO CONTAS DE GRUPO
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------

Contas do grupo são úteis quando se pretende compartilhar um conjunto de arquivos

com múltiplos usuários. É possível criar um grupo e alterar um
conjunto de arquivos a serem associados com ele. O usuário root pode atribuir
usuários a esse grupo para que eles possam ter acesso a arquivos com base
na permissão do grupo.

* Usando Contas de Grupo

* Criando Contas de Grupo

A criação de grupos de utlizadores pode ser feita a partir da janela User

Manager ou a partir da linha de comando com o comando groupadd.
De lembrar também que alguns grupos são criados a quando da criação das
contas dos usuários.

Os números de identificação de grupos de 0 a 499 são atribuídos a grupos

administrativos especiais. Por exemplo, o grupo de root é associado com o
GID 0. Grupos regulares começam em 500 para RHEL e Fedora.

groupadd kings ---- Grupo criado com o próximo id disponível

groupadd -g 325 jokers ---- Grupo criado com o ID 325

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------------
3 - GERENCIANDO USUÁRIOS NA EMPRESA
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------------

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------------------------

CAPÍTULO # 12 : GERENCIANDO DISCOS E SISTEMAS DE ARQUIVOS

Tanto o sistema operativo, as aplicações e todos os dados precisam ser mantidos em

algum tipo de armazenamento permanente, de modo que quando se desligar o
computador, os dados permaneçam lá
quando o computador for ligado de novo.

Para se organizar informações no disco, ele é dividido em partições, com a maioria

das partições recebendo uma estrutura chamada de sistema de arquivos.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------------------
1 - ENTENDENDO ARMAZENAMENTO EM DISCO
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------------------

Quando um sistema operativo é instalado, o disco é dividido em em uma ou mais

partições. Cada partição é formatada por um sistema de arquivos. No caso do Linux,
algumas partições podem ser
especialmente formatadas para elementos, tais como área de troca (swap), ou volumes
físicos LVM.
Enquanto os discos são usados para o armazenamento permanente, a memória de acesso
aleatório RAM e a memória de troca swap são usadas para armazenamento temporário.
Por exemplo, quando um comando
é executado, ele é copiado do disco rígido para a memória RAM para que o
processador do computador CPU possa acessá-lo mais rapidamente.

Quando a RAM está cheia de processos a serem executados, novos não terão acesso ou
não são executados. Daí que entra o swap. O swap é um espaço de troca ou uma
partição do disco rígido em que
seu computador pode tirar os dados da memória RAM que não estão sendo usados no
momento e depois os devolver quando forem precisos.

Outra partição especial é o Gerenciador de Volumes Lógicos (LVM) e volumes físicos.

Para o Linux, pelo menos uma partição de disco é necessária, atribuída à raiz (/)
do sistema de arquivos Linux inteiro. É comum se ter partições separadas que são
atribuídas atribuídas a diretórios
específicos, tais como /home, /var, /tmp. Cada uma das partições está conectada ao
sistema de arquivos Linux maior, montando-a em um ponto no sistema de arquivos onde
se quer que a partição seja
usada. Qualquer arquivo adicionado ao diretório do ponto de montagem de uma
partição, ou em um subdiretório, é armazenado na partição.

A forma na qual as partições de disco são conectadas ao sistema de arquivos Linux é

feito de forma automática e invisível para o usuário final. Cada partição de disco
regular criada quando se instala
o Linux está associada a um nome de dispositivo. Uma entrada no arquivo /etc/fstab
informa o nome do dispositivo Linux de cada partição e onde montá-lo bem como
outras informações. A montagem é feita
quando o sistema é inicializado.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------------------------------
2 - PARTICIONANDO DISCOS RÍGIDOS
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------------------------------

É preciso saber como particionar um disco caso se queira adicionar um disco no

sistema e alterar a configuração do disco existente.

* Visualizando Partições de Disco

Para visualizar as partições do disco, use o comando fdisk com algumas

opções:

fdisk /dev/sda -c -u -l ou fdisk -c -u -l /dev/sda

Quando uma pen drive por exemplo é inserido, ele é atribuído ao próximo
dispositivo sd disponível. Por exemplo, /dev/sdc é definido como o nome do
dispositivo (o terceiro disco no sistema).

* Criando um Disco de Uma única Partição

1. Instale o novo disco rígido ou insira o novo pen drive USB.

 2. Particione o novo disco
3. Crie o sistema de arquivos no novo disco
4. Monte os sistemas de arquivos

A maneira mais fácil de adicionar um disco ou oen drive ao Linux é dedicar o

disco inteiro a uma única partição Linux. Mas também é possível ter várias
partições e atribuir cada uma a
diferentes tipos de sistemas de arquivos e diferentes pontos de montagem.

Particionamento de um USB:

1. Uso de um pen drive USB

2. Determine o nome do dispositivo do disco rígido. Como o usuário root
de um shell, digite o seguinte comando tail e, logo, insira o pen drive USB.
Aparecem mensagens, indicando
o nome do dispositivo da unidade que foi conectado. Pressione ctrl+c
para sair do tail.

# tail -f /var/log/messages
3. A partir da saída, pode se ver que o pen drive USB foi encontrado e
atribuído a um /dev/sd[a,b,c...]. O dispositivo contém uma partição /dev/sdc1.
4. Se o pen drive USB for montado automaticamente, desmonte-o. Na sua
área de trabalho, clique no ícone Filesystem 8.0GB que aparece e selecione Unmount.
Ou, nesse caso, como root você
poderia, em vez disso, digitar umount /dev/sdc1.

5. Use o comando fdisk para criar partições no disco novo. Por exemplo,
se estivermos a formatar o terceiro disco USB, SATA ou SCSI (sdc), pode se digitar
o seguinte:

# fdisk -c -u /dev/sdc

6. Se se começar com um novo pen drive USB, ele pode ter uma partição
que é inteiramente dedicada a um sistema de arquivos compatível com Windows (cimo
VFAT). Pode se utilizar a opção p
para ver todas as partições e d para excluir a partição.

Command (m for help) : p

Command (m for help) : d

7. Para criar uma nova partição, digite a letra n. Somos solicitado a

informar a tipo de partição.

8. Escolhe uma partição estendida (e) ou primária (p). Digite a letra p

para primária.

9.

Nota: Continua

* Criando um Disco de Múltiplas Partições

* Usando Partições LVM