Sistema de arquivos

O sistema de arquivos do GNU/Linux pode ser representado como uma árvore de cabeça para baixo… No topo dessa arvore fica o diretório raiz( / ).  Dentro do diretório raiz encontramos os seguinte diretórios:

bin Arquivos executáveis
boot Arquivos essências para a carga do sistema. É aqui que fica a imagem do kernel
dev Arquivos que representam dispositivos do sistema
etc Arquivos de configuração do sistema
home Diretórios dos usuários
lib Bibliotecas do sistemas. Usadas pelos programas e módulos do kernel
mnt Diretório para montagem de dispositivos ( Em alguns casos existe o diretório media com a mesma utilidade )
proc Informações do sistema e dos processos atuais
opt Programas que não fazem parte da distribuição
root Diretório do super usuário ( root )
sbin Programas do super usuário ( programas/comandos de administração )
tmp Arquivos temporários. O conteúdo desse diretório é apagado a cada reboot
usr Programas usados pelos usuários
var Arquivos variáveis. Logs e arquivos de email

Essa estrutura foi definida por um padrão de mercado criado pelo comunidade em 1994, chamado Filesystem Hierarchy Standard ( FHS ). As distribuições não precisam seguir esse padrão, mas existe uma grande conscientização sobre a importância desse padrão.

GNU/Linux – Trabalhando com textos

Oi pessoal, tudo bem? Hoje vou mostrar alguns comandos do GNU/Linux para trabalhar com arquivos de texto. O GNU/Linux possui uma grande quantidade de comandos para trabalhar com arquivos de textos, mas nesse artigo vou escrever apenas sobre os seguintes comandos:

 

    • cat
    • tac
    • cut
    • head
    • tail
    • join
    • nl
    • tr

 

Apesar de não aparecerem nessa lista, existem 2 comandos( linguagens ) que precisam ser lembrados… O primeiro deles é o awk, já escrevi sobre ele aqui, e o outro é o sed, que vou dedicar um artigo exclusivo futuramente.

Bem, feito a declaração inicial, vejamos os comandos desse aritgo.

cat

O comando cat serve para visualizar, concatenar e criar arquivos.

Para visualizar um arquivo utilize o comando cat da seguinte forma:

cat caminho_para_o_arquivo

Veja:

 


cat /etc/passwd

Para concatenar arquivos utilize o comando cat assim:

cat arquivo1 arquivo2 arquivo3 >> arquivo123.

Veja:


cat /etc/environment /etc/profile >> arquivo_final

Para criar arquivos utilize o comando cat da seguinte maneira:

cat > arquivo.

Veja:


cat > arquivo

O prompt vai ser aberto para digitação, para encerrar a escrita utilize ‘ctrl + d’

tac

O comando tac funciona da mesma forma que o comando cat, porém coloca as linhas na ordem contrária.

cut

O comando cut serve para cortar partes de um arquivo de texto. Esse comando geralmente é usado com arquivos do tipo CSV.

Veja:


cut -d : -f 1 /etc/passwd

Dessa forma o comando cut vai mostrar apenas a primeira coluna (primeiro campo de cada linha).

-d Delimitador
-f O campo que vai ser exibido

head

O comando head serve para visualizar um arquivo a partir do inicio( cabeça ). É possível limitar a quantidade de linhas que serão exibidas da seguinte maneira:


head -n 10 /etc/passwd

Nesse exemplo a saída vai ser as 10 primeiras linhas do arquivo /etc/passwd

tail

O comando tail serve para visualizar um arquivo a partir do final( cauda ). Da mesma forma que o head é possível limitar a quantidade de linhas que serão exibidas da seguinte maneira:


tail -n 10 /etc/passwd

Nesse exemplo a saída vai ser as 10 últimas linhas do arquivo /etc/passwd

join

O comando join faz a junção de arquivos que tenham um campo com índice comum.

Veja:

arquivo1

1 paulo
2 andre
3 junior

arquivo2

1 10
2 9
3 10

 


join -j 1 arquivo1 arquivo2

A saída vai ser:

1 paulo 10
2 andre 9
3 junior 10

nl

O comando nl serve para numerar as linhas de um arquivo, veja:


nl /etc/passwd

tr

O comando tr é um tradutor… Com ele é possível substituir um caracterer por outro…

veja:


cat /etc/passwd | tr a-z A-Z

Esse comando vai alterar as letras minúsculas do arquivo /etc/passwd para maiúsculas.

Outra possibilidade desse comando é retirar caracteres repetidos, por exemplo:


echo "paaaaaaulo" | tr -s a

E também é possível apagar caracteres de um arquivo, assim:


echo "paulo" | tr -d a

Chegamos ao fim de mais um artigo… Claro que existem várias outras possibilidades para esses comandos, para saber mais, utilize o comando man.

Assim:

man nome_comando

Segue alguns links:

http://www.prminformatica.com.br/2014/01/awk.html
http://thobias.org/doc/inc_sed.html

Como montar um servidor LTSP no Ubuntu

O que é LTSP?

Nessa semana eu tive que instalar um servidor LTSP em uma escola aqui da minha cidade. Utilizei o sistema Ubuntu e o processo de instalação e configuração foi extremamente simples. Segue algumas imagens de como ficou o laboratório:

Observação: Algumas máquinas nas imagens não estão utilizando o servidor LTSP

Nesse artigo vou mostrar os passos que usei para ter o servidor e todos as máquinas clientes funcionando. No meu caso, a maioria dos clientes são equipamentos especializados chamados thin client, mas também é possível utilizar computadores comuns, desde que eles tenham suporte ao boot pela rede (sendo necessário apenas um mínimo de memória ram e não sendo necessário ter um HD na máquina ). Para o servidor é necessário ter duas placas de rede, um bom processador e quanto mais memória ram melhor. Para calcular a quantidade mínima de memória do servidor utilizei a seguinte fórmula: 2GB + (numeroClientes * 512MB).

Os passos necessários são:

1 – Instalar o Ubuntu com a seguinte tabela de partições: *valores aproximados

100MB /dev/sda1 /boot
16GB /dev/sda2 swap
250GB /dev/sda3 /
250GB /dev/sda4 /home

Observação: Você pode alterar as partições conforme a sua necessidade.

2 – Configurar a rede através do arquivo /etc/network/interfaces:

 
auto eth0
iface eth0 inet dhcp

auto eth1
iface eth1 inet static
address 192.168.0.1
netmask 255.255.255.0

Observação: A interface de rede eth0 fica conectada na internet e a eth1 nos clientes.

3 – Instalar os serviços:

 
sudo apt-get install ltsp-server-standalone openssh-server

4 – Configurar os arquivos /etc/ltsp/dhcpd.conf e /etc/default/isc-dhcp-server

O arquivo /etc/ltsp/dhcpd.conf já estava preenchido, foi necessário apenas adaptar as configurações de rede. Esse arquivo têm essa aparência:


authoritative;

subnet 192.168.0.0 netmask 255.255.255.0 {
    range 192.168.0.20 192.168.0.250;
    option domain-name "example.com";
    option domain-name-servers 192.168.0.1;
    option broadcast-address 192.168.0.255;
    option routers 192.168.0.1;
#    next-server 192.168.0.1;
#    get-lease-hostnames true;
    option subnet-mask 255.255.255.0;
    option root-path "/opt/ltsp/i386";
    if substring( option vendor-class-identifier, 0, 9 ) = "PXEClient" {
        filename "/ltsp/i386/pxelinux.0";
    } else {
        filename "/ltsp/i386/nbi.img";
    }
}

No arquivo /etc/default/isc-dhcp-server foi necessário apenas configurar a interface de rede que se conecta nos clientes:

 
INTERFACES=”eth1″

5 – Criar os usuários para os clientes.

 
sudo adduser

6 – Criar e atualizar a imagem do sistema para os clientes:

 
sudo ltsp-build-client --arch i386 #esse cria a imagem dos clientes, vai demorar :)

sudo ltsp-update-sshkeys 

sudo ltsp-update-image

Observação: No primeiro comando, também é possível usar o parâmetro –dist para especificar um versão diferente do ubuntu. Exemplo: lucid ou precise.

7 – Reiniciar o servidor

 
sudo reboot

8 – Configurar os clientes para dar boot pela rede

Observação: Isso pode ser feito de várias maneiras diferentes dependendo da bios dos clientes. Procure onde é configurada a ordem de boot e altere para LAN, network ou PXE.

Pronto, se você seguiu os passos de forma correta, o seu servidor LTSP já está funcionando.

Segue alguns links para ajudar e complementar esse artigo:

http://www.hardware.com.br/termos/pxe
https://www.youtube.com/watch?v=LJt9VIqWfDY
https://fedorahosted.org/k12linux/wiki/InstallGuide

Precisa trabalhar com arquivos de texto ? AWK!

Eae pessoal, nos últimos meses eu tive que usar bastante a linguagem C para manipular arquivos de texto (txt). Apesar de ser uma linguagem poderosa, trabalhar com esses arquivos em C pode ser bem complicado. Pensando nisso, quero mostrar nesse artigo uma linguagem mais especialiazada em manipulação de arquivos de texto ( lembre-se, para quem só sabe usar martelo, tudo é prego ).

Essa linguagem é a AWK, ela foi criada em 1977 pelos cientistas Alfred Aho, Peter J. Weinberger e Brian Kernighan no laboratório Bell Labs.

Para criar os exemplos vou utilizar o arquivo “/etc/passwd”, e para que tudo ocorra de forma segura fiz uma copia desse arquivo para pasta home do meu usuário. Faça você também:



cp /etc/passwd $HOME

O meu arquivo passwd têm essa aparência:


saned:x:110:120::/home/saned:/bin/false
ntp:x:111:121::/home/ntp:/bin/false
rtkit:x:114:123:RealtimeKit,,,:/proc:/bin/false
mdm:x:108:112:Gnome Display Manager:/var/lib/mdm:/bin/false
paulo:x:1000:1000:paulo:/home/paulo:/bin/bash

Perceba que é um arquivo CSV separado por ‘:’ . Cada linha desse arquivo representa um usuário do sistema, sendo que os campos estão organizados assim:

login: senha : Id do usuario : Id do grupo : extras : pasta home : shell

Para iniciar, vou apenas usar o AWK para imprimir o arquivo no terminal, para isso digite o seguinte comando ( no terminal ) :



awk '{ print }' $HOME/passwd

O AWK fez a leitura de cada linha (uma por uma) do arquivo passwd e imprimiu na saida padrão( monitor ). Isso não é muito util, afinal, o comando cat também pode fazer isso e com uma sintaxe mais simples ( cat $HOME/passwd ). Agora vou tentar algo um pouco mais elaborado, vou imprimir o arquivo novamente, mas apenas o primeiro campo (login).



awk -F: '{ print $1 }' $HOME/passwd

Dessa vez eu utilizei o parametro -F, que especifica o separador de campos utilizado no arquivo ( nesse caso :, sem isso, o separador padrão é o TAB ou ” ” ) e passei a variável $1 ( que representa o primeiro campo ) para o print. Para cada campo da linha que esta sendo processada existe uma variável $n, onde n é a posicao do campo apartir do 1, A variavel $0 contém a linha inteira.

Para o próximo exemplo quero imprimir apenas quem utiliza o shell Bash:



awk -F: '{ if( $7 == "/bin/bash" ) print $1 }' $HOME/passwd

Obs. AWK utiliza os mesmos operadores condicionais e lógicos do C

Funcionou, mas ainda é possível melhorar a aparência dessa saída:



awk -F: ' { if( $7 == "/bin/bash" ) printf "%s usa o shell %s n", $1, $7 }' $HOME/passwd

Obs. Perceba que o printf do AWK é quase igual ao do C, ele aceita vários formatos, por exemplo: %d, %i, %f, %s e outros.

Assim fica melhor, né? No próximo exemplo quero finalizar a saída com a quantidade de campos encontrados:



awk -F: '{ if( $7 == "/bin/bash" ) { printf "%s usa o shell %s n", $1, $7; total++ } } END { printf "Total de registros %d n", total }' $HOME/passwd

Nesse exemplo utilizei o bloco END, esse bloco é executado depois que o AWK processou todo conteúdo do arquivo. Diferente do C em AWK não é necessário instanciar uma variavel. Na primeira vez que uma variável é mencionada o AWK automaticamente cria uma instância e atribui um valor inicial, para números esse valor é 0 e para strings é “”.

Caso seja necessário também é possível especificar um bloco BEGIN que é executado antes do AWK processe o conteúdo do arquivo.

O exemplo anterior ficou um pouco grande para ser executado direto no terminal, para facilitar a escrita, é possivel utilizar a AWK em forma de script, para isso basta criar um arquivo que inicie com a linha “#!/usr/bin/awk -f” e escrever os comandos nas linhas seguintes. Vai ser necessário fazer algumas adaptações, exemplo anterior em forma de script fica assim:


#!/usr/bin/awk -f

BEGIN {
FS=":";
}

{
if( $7 == "/bin/bash") {

printf "%s usa o shell %s n", $1, $7;
total++;
}
}

END {
printf "Total de registros %d n", total
}

A principal diferença é que no lugar de especificar o separador através do parametro -F, utilizo a variavel padrão FS, dentro do bloco BEGIN.

Salvei o script no arquivo teste.awk, depois dei permissão de execução para ele através do comando “chmod +x teste.awk” e para executar basta escrever no terminal “./teste.awk $HOME/passwd” . Assim fica parecido com shell script, né? ( não sabe o que é shell script? clique aqui )

Continuando, agora eu quero mostrar apenas as linhas onde o login tenha menos de 4 letras:


#!/usr/bin/awk -f

BEGIN {
FS=":";
}

{
if( length( $1 ) < 4) {

printf "%s n", $1;
total++;
}
}

END {
printf "Total de registros %d n", total
}

Nesse exemplo utilizei a função length que retorna o tamanho de uma string. Algumas das funções do AWK para trabalhar com strings são:

index( s1, s2 ) retorna a posição da string s1 na string s2
gsub( sO, sS, s ) substitui a string original sO pela a string substituta sS na sting s
length( s ) retorna o tamanho da string s
split( s, v, d ) quebra a string s usando o delimitador d e coloca no vetor v
substr( s, i, f ) retorna a parte da string s que inicia na posição i e termina na posição f

AWK também têm funções para trabalhar com números, alguma delas são:

sqrt( n ) raiz quadrada
sen( n ) seno
cos( n ) cosseno
int( n ) a parte inteira de n

No próximo exemplo vou redirecionar a saída para um arquivo e vou alterar o shell de todos os usuários que usam o “/bin/sh” para o “/bin/bash”:


#!/usr/bin/awk -f

BEGIN {
FS=":";
}

{
if( $7 == "/bin/sh") $7 = "/bin/bash";

for( i = 1; i < 8; i++ ) printf "%s:", $i >> "bkp";

print "" >> "bkp"; #pra quebrar a linha
}

Obs1. A AWK também possui uma instrução while, que assim como o for tem uma sintaxe idêntica a do C
Obs2. Os comentários em AWK são feitos com #

O exemplo anterior foi escrito ao estilo C propositalmente, eu queria mostrar como é a instrução for, o jeito AWK de fazer isso é utilizando a função gsub, assim:



#!/usr/bin/awk -f
{
gsub( "/bin/sh", "/bin/bash", $0 )

print $0 > "bkp"
}

Pessoal por hoje é isso, tem muito mais para mostrar sobre o AWK, mas fica para um próximo artigo. Para quem quiser continuar estudando o AWK, aqui fica alguns links…

http://www.inf.pucrs.br/~manssour/AWK/
http://pt.wikipedia.org/wiki/AWK
http://br-linux.org/artigos/awk_intro.htm

Permissões especiais: SUID, SGID e STICKY

Hoje quero mostrar as permissões especiais do linux: SUID, SGID e STICKY. Esses bits podem ser aplicados em determinadas situações para se conseguir um comportamento bem especifico.

Esses bits têm as seguintes características:

SUID

Esse bit só pode ser aplicado em arquivos executáveis. Basicamente, quando esse bit está ativado o arquivo é executado com as permissões do dono dele e não com as permissões de quem executou. Por exemplo, um arquivo executável onde o dono é o root e o bit SUID está ativado, sempre roda com as permissões do root, ou seja, qualquer usuário pode executa-lo com privilégios de administrador.

SGID

O bit SGID quando é aplicado em um arquivo executável, funciona de forma parecida com o SUID, mas é usada a permissão do grupo do arquivo e não do dono. Além disso, esse bit pode ser aplicado em diretórios, quando isso acontece, tudo que for criado dentro desse diretório terá o grupo dele, ou seja, se o diretório pai tem o bit SGID ativado, tudo que for criado dentro dele terá o seu grupo e não o do usuário que criou.

STICKY

O bit STICKY geralmente é utilizado em diretórios públicos (777) onde todos os usuários podem gravar e apagar arquivos. Esse bit altera a capacidade dos usuários apagarem arquivos/diretórios dos quais não sejam donos, ou seja, o bit STICKY interfere na permissão de apagar arquivos/diretórios, permitindo apenas que o usuário apague os seus arquivos/diretorios (onde ele é dono), mesmo que ele tenha a permissão necessária para apagar arquivos de outros usuários. (o root obviamente não sofre esse bloqueio )

Como aplicar essas permissões

Para ativar esses bits você pode usar o comando chmod de forma octal colocando um digito a mais no inicio da sequencia de dono, grupo e outros.( X777 )

Para ativar o SUID : chmod 4777

Para ativar o SGID : chmod 2777

Para ativar o STICKY : chmod 1777

OBS: não precisa ser sempre X777, as 3 últimas você define como quiser, dependendo das permissões que for aplicar para o dono, grupo e outros

Exemplos

SUID

Perceba que tem ‘s’ no lugar do ‘x’ na sequencia de permissões do dono. Ele representa SUID ativado

SGID

Perceba que tem ‘s’ no lugar do ‘x’ na sequencia de permissões do grupo. Ele representa SGID ativado

STICKY

Perceba que tem ‘t’ no lugar do ‘x’ na sequencia de permissões do outros. Ele representa STICKY ativado

Saib mais…
http://www.vivaolinux.com.br/artigo/Entendendo-as-permissoes-no-Linux
http://pt.wikipedia.org/wiki/Sistema_octal

Configuração básica do Squid no Fedora

Eae pessoal, dessa vez quero mostrar como configurar rapidamente um servidor de proxy Squid. Vou mostrar o básico para o Squid funcionar, no final deixo alguns links para quem quiser se aprofundar no assunto, beleza? Dessa vez vou utilizar o Fedora.

Um servidor de proxy tem basicamente duas funções: Agilizar o processo de entrega de requisições web e filtrar o conteúdo que os usuários tem acesso. Existem duas maneiras de configurar o servidor Squid, manualmente e transparente.

Quando você usa configuração manual é necessário especificar para todos os clientes(geralmente navegadores) que eles devem fazer uso do proxy. Já quando você faz a configuração de forma transparente não existe a necessidade de especificar que os clientes utilizem o proxy. Na verdade, os clientes não sabem da existência dele.

Em um proxy configurado de forma manual e tendo como cliente um navegador o processo de requisição seria (+ ou -) assim:

NAVEGADOR > SERVIDOR_PROXY > SITE V

NAVEGADOR < SERVIDOR_PROXY < SITE

Ou seja, o navegador faz a requisição da página para o servidor proxy, esse realiza a filtragem e se for o caso( se for aprovado ) requisita a página para o site e devolve para o navegador.

E se proxy for transparente o processo de requisição de uma página é o seguinte:

NAVEGADOR > FIREWALL > SERVIDOR_PROXY > SITE V

NAVEGADOR < SERVIDOR_PROXY < SITE

Nesse caso o navegador não sabe da existência do proxy, então faz a requisição normalmente para o roteador padrão( por isso não é necessário configurar o navegador), o firewall da rede então identifica essa operação e desvia o fluxo para o proxy para que ele faça a filtragem e se for o caso a requisição para o site.

Nesse tutorial vou mostrar como fazer a configuração manual. O ideal é que você instale e configure o servidor em uma máquina e use outra como cliente, se você não tiver outra máquina disponível utilize o virtualbox para criar uma máquina virtual. (Nunca usou o virtual box? aqui têm um tutorial).

Na máquina que vai ser o servidor use o seguinte comando para instalar o Squid: ( O servidor deve ser Fedora, o cliente pode se qualquer sistema, ok?)

 
sudo yum install squid -y

Com o Squid instalado no servidor abra com um editor de texto o arquivo “/etc/squid/squid.conf” :

 
sudo nano /etc/squid/squid.conf

Veja que já existe bastante conteúdo nesse arquivo, mas não se preocupe a maior parte dele não será alterada. A idéia é ser simples e rápido, então não vou fazer muitas configurações, vou mudar somente o necessário. A configuração completa para colocar o proxy em ‘produção’ fica para um próximo artigo.

Vou iniciar configurando o cache, para isso altere a seguinte linha no arquivo squid.conf:

 
#cache_dir ufs /var/spool/squid 100 16 256

Essa linha faz o ajuste do cache em disco: O 100 especifca o tamanho do cache em MB, o 16 a quantidade de diretórios e o 256 a quantidade de subdiretórios que o Squid pode criar. Você pode alterar os valores conforme achar necessário, apenas se certifique de tirar o ‘#’ do inicio da linha. Este ‘#’ comenta a linha, com ele essa instrução não é avaliada pelo Squid.

Em seguida coloque essa linha abaixo da anterior( em baixo da cache_dir…):

 
visible_hostname nome_do_seu_servidor_aqui

Essa linha especifica o hostname do Squid e também vai aparecer nas páginas de informação.

Pronto, salve o arquivo e você já têm o cache do seu Squid configurado. O próximo passo é configurar as regras de filtragem. Essas regras são definidas através dos comandos ‘acl’ e ‘http_access’. Veja a documentação para encontrar todas as ‘acls’ possíveis. http://www.squid-cache.org/

As ‘acls’ são escritas da seguinte forma:

 
acl < nome_da_acl > < tipo_acl > < parâmetro >

Veja alguns exemplos de ‘acls’:

 

# acl de origem, representa o ip do cliente que acessa o proxy
acl rede_local src 192.168.0.0/24

# acl de destino, representa o destino da requisição
acl meu_blog dstdomain .prmjuniorblog.blogspot.com.br

# acl de expressão regular, verifica se a palavra jogo esta na url
acl words url_regex jogo

Para iniciar a configuração da filtragem coloque um ‘#’ (comentar) as seguintes linhas: (Elas estão permitindo acesso total para a rede local e para o próprio servidor, vamos tirar esse acesso.)

 
#No seu elas devem estar sem o '#' na frente, coloque.
#http_access allow localnet
#http_access allow localhost

Agora é possível criar regras personalizadas. A configuração que vou utilizar vai estabelecer algumas palavras proibidas e se o Squid encontrar alguma delas o acesso será negado, para isso procure no arquivo “/etc/squid/squid.conf” a seguinte linha:

 
http_access deny all

Digite os comando abaixo antes dela:

 

# a sua rede, -ALTERE- para a faixa de IP que você usa. Use o comando ifconfig para ter essa informação
acl rede_local src 192.168.0.0/24
#as palavras proibidas
acl proibidas url_regex -i "/etc/squid/proibidas"

Criei duas ‘acls’, a primeira representa o IP da sua rede local, ou seja a faixa de ip dos computadores clientes e a segunda representa as palavras proibidas. O “-i” garante que a busca pelas palavras não vai considerar diferença entre maiusculas e minusculas, e o endereço “/etc/squid/proibidas” é o arquivo onde as palavras serão armazenadas( uma por linha ). Para testar crie o arquivo “/etc/squid/proibidas” e coloque a palavra baixaki dentro dele. Salve as modificações no “/etc/squid/squid.conf”, abra um terminal e execute o comando abaixo:

 

sudo echo "baixaki" > /etc/squid/proibidas

Depois de executar esse comando o arquivo das palavras proibidas já estará criado e contendo a palavra baixaki. Volte a abrir o arquivo “squid.conf” e digite o seguinte logo abaixo das linhas anteriores:

 

#nega que a rede acesse requisições que tenham as palavras proibidas em qualquer lugar da url
http_access deny rede proibidas
#permite que a rede acesse o restante
http_access allow rede

OBS: Se uma regra bloquear o acesso, esse vai ficar bloqueado, mesmo que uma regra abaixo libere

Com isso a filtragem está pronta, use o seguinte comando para verificar erros de digitação na configuração:



squid -k parse

Se for mostrado algum erro tente corrigi-lo( se não souber arrumar deixe um comentário 🙂 .Quando a configuração estiver ok, inicie o Squid com o comando:

 

sudo service squid start

OBS: para que o Squid inicie sempre com o Fedora, use o comando “sudo chkconfig squid on”

Agora é necessário configurar o navegador do cliente para usar o proxy. Aqui têm tutorial explicando como fazer isso em vários navegadores. Você vai precisar do ip do servidor, se não souber, use o comando ifconfig.

Segue uma imagem de como ficou no meu Firefox

Feito, tente navegar… o Baixaki deve ser o único site bloqueado. Se quiser fazer outros bloqueios não é necessário alterar o “/etc/squid/squid.conf”, basta alterar o arquivo das palavras proibidas.

Se você preferir ter um arquivo com palavras liberadas, ou seja, acessa somente os sites que tiverem uma das palavras na url, crie o arquivo liberadas e altere as seguintes linhas no “/etc/squid/squid.conf”:

 
# cria a acl
acl liberadas url_regex -i "/etc/squid/liberadas"
#nega acesso a qualquer url que não tenha uma das palavras liberadas
http_access deny rede !liberadas

Saiba mais…
http://pt.wikipedia.org/wiki/Proxy
http://www.sourcebrasil.org/tutoriais/visualizar/instalacao-e-configuracao-do-servidor-proxy-squid.html
http://www.youtube.com/watch?v=fgOw-3PV_sQ

Quota de disco no Linux (Fedora 19)

Hoje vou escrever sobre como aplicar um sistema de quota de disco no GNU/Linux. Dessa vez estou utilizando o Fedora 19, mas tudo deve funcionar perfeitamente em outras distribuições.

A ideia ao se criar um sistema de quota é dividir o disco de forma justa ou da melhor maneira possível.

Por exemplo, imagine que em um sistema a partição /home têm 1GB, e que determinado usuário resolve fazer o download de uma .iso de 700MB… Os demais usuários terão que dividir os 300MB restantes.  Nesse caso, temos um usuário usando a maior parte do disco sozinho, para evitar essa situação, é possível usar o sistema de quota.

Para configurar o sistema de quotas, é necessário  instalar o pacote quota com o seguinte comando:

sudo yum install quota 

Depois de instalar o pacote, é necessário alterar o arquivo /etc/fstab de forma que a partição /home tenha as seguintes opções: usrquota e grpquota.

Exemplo:

/dev/mapper/fedora-home /home ext4 defaults,usrquota,grpquota 1 2

Para ativar a configuração é possível reiniciar o sistema ou remontar a partição com o seguinte comando: 

sudo mount -o remount /home

Agora que o sistema de quota já esta instalado, é possível fazer a configuração das quotas por usuário ou por grupo.

Execute o seguinte comando para criar os arquivos de configuração:

sudo quotacheck -cugfm /home

Após esse comando, a  pasta /home deve possuir os arquivos aquota.group e aquota.user.  É importante que esses arquivos possam ser alterados apenas pelo root .

Ative a quota de disco com:

sudo quotaon /home

Feito isso, a configuração de um usuário pode ser feita com o comando:

sudo edquota -u usuario

O seguinte arquivo será aberto para edição no vi:

Filesystem blocks soft hard inodes soft hard
/dev/mapper/fedora-home 32 2000 3000 14 10 15

Nesse arquivo, apenas as colunas soft e hard devem ser alteradas. O primeiro conjunto de colunas soft e hard especifica a quota de disco por espaço ocupado e o segundo conjunto especifica a quota por inode.

Você pode considerar um inode como um ponteiro para um arquivo, a quantidade desses inodes é limitada, por isso, pode ser útil fazer um sistema de quota para eles também… Para saber mais sobre inode, clique aqui.

A coluna soft especifica a quota do usuário, ou seja, acima disso o usuário estourou sua quota. E a coluna hard, especifica um tamanho máximo após estourar a quota( um extra ).

Simplificando,  soft é a quota do usuário e hard é um extra para armazenar mais alguns arquivos enquanto o usuário resolve o problema.

O tempo que o usuário têm para usar o espaço extra é chamado de grace period e serve para que seja possível fazer backup ou excluir algum arquivo que não seja mais necessário. Esse tempo pode ser especificado com o comando:

sudo edquota -t

Para consultar a situação das quotas é utilizado o comando:

sudo repquota -va

Uma vez que um usuário possui quota definida, é possível replicar a quota dele em outro usuário através do seguinte comando:

sudo edquota -up usuario paulo

Dessa forma, o usuário paulo terá a mesma configuração de quota do usuário usuario

As quotas por grupo podem ser configurada de forma semelhante… Por exemplo, para configurar a quota de um grupo é possível usar o comando:

sudo edquota -g grupo

E para listar as quotas:

sudo repquota -vag

Por hoje é isso, qualquer dúvida deixe um comentário.

A leitura dos seguintes links pode ser interessante.

Comandos básicos do vi
Add usuário pela linha de comando
O comando mount

Gerenciando processos no Ubuntu 12.04

Nesse artigo vou mostrar como usar alguns comandos para gerenciar processos no GNU/Linux. Mais uma vez estou usando o ubuntu 12.04 , mas tudo deve funcionar normalmente em outras distribuições .

O primeiro comando que vou mostrar é o ps:

 
ps aux | more
 

Na saida desse comando é possível encontrar as colunas:

USER é o nome do usuário que iniciou o processo;
PID é o id do processo;
% CPU é a porcentagem de uso do processador;
% MEM é a porcentagem de uso da memória;
VSZ é o tamanho virtual do processo ;
RSS é a quantidade de memória usada em KB;
TTY é o terminal do processo;
STAT é o estado atual do processo;
START é hora em que o processo foi iniciado;
COMMAND é comando que executa o processo;

O STAT pode ter os valores:

D um processo morto;
R um processo em execução;
S um processo parado(dormindo);
T um processo parado, por um sinal de controle;
Z um processo terminado, mas removido por seu processo pai;

E esses valores podem também ser combinados com os seguintes caracteres:

> o processo têm prioridade maior que o normal, a alteração foi feita pelo kernel;
< o processo têm prioridade menor do que o normal, a alteração foi feita pelo kernel;
+ o processo é pai 🙂 possui processos filhos;
s o processo possui processos que dependem dele;
l o processo possui múltiplas threads;
L o processo possui páginas travadas na memória;
N o processo têm prioridade diferente do normal, a alteração foi feita por um usuário;

O comando ps é como um ‘print screen’ dos processos, ou seja, ele mostra como os processos estavam em um determinado momento, mas em algumas situações pode ser melhor ver a ‘movimentação’ dos processos em ‘tempo real’. Para isso, é possível usar o comando top. Existe também o comando htop que é uma versão mais amigável do top.

Para instalar o htop no Ubuntu digite no terminal:

 
sudo apt-get install htop
 

Depois de visualizar os processos você pode enviar sinais para mudar o comportamento deles. Veja mais sobre os sinais aqui

Alguns dos sinais possíveis são:

9 (SIGKILL) para matar o processo ( quase sempre uso esse :);
15 (SIGTERM) para terminar o processo;
18 (SIGCONT) para continuar um processo parado;
19 (SIGSTOP) para parar um processo;

É possível enviar esses sinais direto da interface do comando top ou utilizar alguns comandos externos. Em alguns deles é usado o nome do programa e em outros o PID.

Por exemplo, nos comandos abaixo é usado o nome do programa para matar os processos:

 
pkill -9 firefox
killall -s 9 firefox

E no próximo é usado o PID de um processo para matá-lo;

kill -9 1889

Com o comando kill é necessário saber o PID do processo para enviar um sinal para ele. Você pode usar os comandos ps e top para encontrar esse número, mas existem comandos que facilitam essa busca, por exemplo:

pidof firefox
pgrep firefox

Para terminar, vou mostrar dois comandos para alterar a prioridade de um processo.

Para executar um processo com prioridade diferente do normal use o comando:

nice -n 19 firefox

E para alterar a prioridade de um processo use:

renice -20 1889

Bom, espero que esse artigo seja útil para alguém… Se quiser ver outra forma de gerenciar processos( gráfica ), veja esse artigo do terminal de informação.

Operações matemáticas com shell script

Uma coisa que chama a atenção em shell script são as operações matemáticas. Em shell script a princípio elas não são resolvidas diretamente, para resolver essas operações é necessário usar algum comando auxiliar, por exemplo:


a=1;
b=2;
# c=$a+$b; não iria funcionar
d=$(( $a + $b )); # ok

obs. também é possível usar os comandos let, expr e bc para resolver operações matemáticas.

Mas essa caracteristica apesar de ser padrão, pode ser modificada usando o comando ‘declare -i’ para criar as variáveis, veja:


a=1;
b=2;
declare –i c; # a variavel c é do tipo inteiro
c=$a+$b; # a operacao é resolvida diretamente...
# cuidado com os epaços...

Isso garante que a variável ‘c’ é do tipo inteiro, e não vai aceitar outros tipos de valores, algo parecido com o que ocorre com linguagens fortemente tipadas, mas diferentemente dessas, ao se atribuir um valor diferente do estipulado não será emitida uma mensagem de erro, veja:


declare –i c; # c é inteiro
c=”paulo”;
echo $c # imprime 0 (zero)

Ao tentar setar uma string em ‘c’ o valor é desconsiderado, ficando o valor de zero no lugar.

É importante perceber que usando o comando ‘declare -i’, além da variável assumir (parcialmente) caracteristicas de uma linguagem fortemente tipada, também terá alterações no seu escopo. Veja os exemplos:


Function teste() {
a=10;
}
teste # executa a função
echo $a #imprimie 10

Diferente de outras linguagens as variáveis dentro de funções não são por padrão locais, ou seja, elas iram escapar para o escopo principal quando a função for executada (caracteristica bem estranha, na minha opinião), mas se for usado o comando ‘declare –i’ isso não acontece:


Function teste() {
declare –i a=10;
}
teste
echo $a # nao imprimi 10

valeu pessoal, espero que seja util…

Obs. Se você precisa que as variáveis dentro de funções sejam locais e não quer usar o declare –i ou as suas variáveis não são numericas use “local a=10”;

Configurando o GRUB2 no Debian Squeeze

Os principais arquivos de configuração do GRUB2 são o /boot/grub/grub.cfg, o /etc/default/grub e também os scripts localizados no diretório /etc/grub.d/.

Na verdade, a configuração manual do GRUB2 é feita apenas no arquivo /etc/default/grub e nos scripts do diretório /etc/grub.d/. O arquivo /boot/grub/grub.cfg apesar de ser o principal arquivo de configuração, não deve ser alterado manualmente, esse arquivo será configurado pelo comando update-grub tendo como base o conteúdo dos arquivos anteriores.

/etc/grub.d/

Os arquivos do diretório /etc/grub.d/ são scripts responsáveis por montar o arquivo /boot/grub/grub.cfg. Esses scripts serão executados pelo comando update-grub, por tanto, devem ter permissão de execução.

A ordem de execução desses arquivos segue a ordem alfabética de seus nomes, por exemplo: o arquivo 05_debian_theme é executado antes do 10_linux.

Alguns scripts desse diretorio são:

00_header: é o script que carrega as configurações que estão no arquivo /etc/default/grub, por exemplo: o tempo de espera e a entrada de boot padrão.

05_debian_theme: Define a aparência do GRUB2

10_linux: Localiza os kernels do sistema operacional e cria suas entradas no menu.

20_memtest86+: Cria as entradas do memtest.

30_os-prober: Busca outros sistemas operacionais e cria as suas entradas no menu.

40_custom: é apenas um modelo para criar entradas adicionais no menu do GRUB2.

/etc/default/grub

O arquivo /etc/default/grub não é exatamente um script, nele é possível alterar diretamente o valor de varias variáveis de configuração, por isso, esse arquivo é bem mais amigável que os scripts do diretório grub.d.

Configurações

Configurar as cores do menu:

Tecnicamente o arquivo responsável por essa configuração é o script 05_debian_theme, mas por se tratar de um script, ele exige um certo conhecimento em programação, felizmente existe uma forma mais simples de fazer essa configuração: Crie o arquivo /boot/grub/custom.cfg e dentro dele coloque o seguinte conteúdo:

set color_normal=light-gray/black

set color_highlight=blue/white

set menu_color_normal=magenta-light-grayset

menu_color_highlight=blue/white

Onde:

color_normal : Cor da fonte e do background

color_highlight: Cor da fonte e do background com seleção

menu_color_normal:  Cor da fonte e do background do menu

menu_color_highlight: Cor da fonte e do background do menu com seleção

Alguma das cores possíveis são: black, blue, green, cyan, red, magenta, brown, light-gray, dark-gray, light-blue, light-green, light-cyan, light-red, light-magenta, yellow e white.

E pronto, não é necessário rodar o comando update-grub, o arquivo será carregado automaticamente.

Colocar uma imagem no GRUB2

Essa é outra opção que a principio deveria ser configurada no script 05_debian_theme, mas pelo mesmo motivo anterior vou mostrar uma forma alternativa: No arquivo /etc/default/grub altere ou crie a seguinte linha e rode o comando update-grub:

GRUB_BACKGROUND=“coloque aqui o caminho até a imagem”

Uma boa fonte de imagens para o menu GRUB2 é o pacote GRUB2-splashimages, após a instalação, verifique o diretório /usr/share/images/grub/ ( para ver como instalar pacotes no Debian clique aqui )

Alterar a resolução do GRUB2:

Para configurar a resolução da tela do GRUB2 altere a seguinte linha no arquivo /etc/default/grub e rode o comando update-grub:

GRUB_GFXMODE=640×480

Essa configuração altera apenas a resolução da tela do GRUB2, não terá efeito no sistema. É interessante manter a resolução do menu igual a resolução do sistema.

Configurar o boot padrão:

Essa configuração especifica qual a entrada do menu que vai ser executada automaticamente se o usuário não especificar nenhuma até o final do tempo de espera. Para configurar o boot padrão, altere a seguinte linha no arquivo /etc/default/grub e rode o comando update-grub:

GRUB_DEFAULT=0

onde o 0(zero) é a primeira entrada do menu do GRUB2, 1 a segunda, 2 a terceira… Também é possível utilizar GRUB_DEFAULT=saved, assim, a entrada padrão será sempre a última que foi selecionada, ou seja, se na última vez o usuário selecionou a entrada 1, essa será opção padrão até que ele selecione outra.

Ajustar o tempo de espera:

Esse é o tempo que o GRUB2 vai esperar antes de chamar o boot padrão. Para configurar, altere a seguinte linha no arquivo /etc/default/grub e rode o comando update-grub:

GRUB_TIMEOUT=5

Incluir ou retirar o recovery mode:

Para configurar a entrada do recovery mode altere o valor da seguinte linha no arquivo /etc/default/grub e rode o comando update-grub:

GRUB_DISABLE_LINUX_RECOVERY=”true”

se o valor for true, o recovery mode não vai ter sua entrada no GRUB2, se for false vai ter.

Configurar a entrada do memtest:

Para retirar a opção de memtest do menu execute os seguintes comandos:

chmod -x /etc/grub.d/20_memtest86+; update-grub;

Para habilitar essa opção novamente rode os seguintes comandos:

chmod +x /etc/grub.d/20_memtest86+; update-grub;

Se quiser habilitar essa opção, mas o script 20_memtest86+ não estiver no diretório grub.d, instale o pacote memtest86+ .

Personalizar as entradas do menu

Para editar as entradas que estão no menu do GRUB2, é possível copiar essas entradas da configuração que já está pronta no arquivo /boot/grub/grub.cfg (afinal ela está funcionando normalmente) e depois colar no script 40_custom. As entradas do menu do GRUB2 são configuras pela palavra chave menuentry e são delimitadas por chaves {}, segue um exemplo:

menuentry “Titulo da opção” {

aqui ficam os comandos

}

O arquivo /boot/grub/grub.cfg é dividido por blocos BEGIN e END, cada bloco é gerado por um dos scripts do diretório /etc/grub.d/.

É importante guardar o nome dos scripts que geraram os blocos de onde estão as menuentry que serão copiadas. Cuidado, copie apenas as menuentry’s.

Com as entradas já coladas no script 40_custom faça as alterações necessárias e salve. Com isso, se o comando update-grub fosse rodado as entradas personalizadas já estariam no GRUB2, mas as entradas padrão também, ou seja, as entradas ficariam em dobro.

Para evitar isso, é necessário tirar a permissão de execução dos scripts que geram as entradas padrão(os scripts do diretorio grub.d), para isso, execute o comando a seguir para cada um desses scripts, faça somente naqueles que o nome aparecia em um bloco BEGIN e END de onde foram copiadas as menuentry’s, não tire a permissão dos outros…

cd /etc/grub.d/;
chmod -x nome_do_script

E por último rode o comando update-grub.

Criar uma nova entrada para o menu:

A principio dificilmente será necessário criar uma entrada manualmente para o menu do GRUB2, se por algum motivo um sistema não for reconhecido após o comando update-grub, instale o pacote os-prober e rode os comandos abaixo:

os-prober; update-grub;

O os-porber é capaz de localizar sistemas que não estejam sendo reconhecidos pelo GRUB2. Se ainda assim, o sistema não for reconhecido, é possível criar uma entrada no menu manualmente através do script 40_custom que está no diretório /etc/grub.d/. Para criar uma entrada para uma distribuição GNU/Linux insira o seguinte conteúdo no script 40_custom e execute o update-grub:

menuentry “Titulo do Sistema” {

set root=(hd0,1)
linux /boot/vmlinuz-versão_do_kernel
initrd /boot/initrd.img-versão_do_kernel
}

Esse é o mínimo para se criar uma entrada para um sistema GNU/Linux no GRUB2.
Em set root=(hd0,1) está sendo especificado que o sistema está no primeiro disco(hd0) e na primeira partição desse disco. Obs.: Os discos iniciam no zero( hd0, hd1, hd2… ), mas as partições iniciam no 1.

Onde diz “versão_do_kernel” substitua pela versão do kernel que o sistema utiliza. Se tiver acesso a esse sistema, é possível verificar qual a versão do kernel com o comando uname -r.

Para criar uma entrada no menu para um sistema Windows( xp, vista, 7 ) use:

menuentry “Titulo do Sistema” {

set root=(hd0,1)
chainloader +1
}

Mais sobre o GRUB2:
http://www.vivaolinux.com.br/dica/Personalizando-o-Grub-2
http://www.gnu.org/software/grub/
http://www.vivaolinux.com.br/dica/Colocando-senha-criptografada-no-GRUB-2