Linux é o termo geralmente usado para designar qualquer sistema operativo ou sistema operacional que utilize o núcleo Linux. Foidesenvolvido pelo Finlandês Linus Torvalds, inspirado no sistema Minix. O seu código fonte está disponível sob licença GPL para qualquer pessoa que utilizar, estudar, modificar e distribuir de acordo com os termos da licença.

Inicialmente desenvolvido e utilizado por grupos de entusiastas em computadores pessoais, o sistema Linux passou a ter a colaboração de grandes empresas, como a IBM, a Sun Microsystems, a Hewlett-Packard, Red Hat, Novell e a Canonical. Com isso aumentou bastante também o número de colaborações dos usuários, o que ajudou muito o projeto, principalmente em sua tradução.

http://www.apostilaz.com.br

Linux é o termo geralmente usado para designar qualquer sistema operativo ou sistema operacional que utilize o núcleo Linux. Foi desenvolvido pelo Finlandês Linus Torvalds, inspirado no sistema Minix. O seu código fonte está disponível sob licença GPL para qualquer pessoa que utilizar, estudar, modificar e distribuir de acordo com os termos da licença. 

Inicialmente desenvolvido e utilizado por grupos de entusiastas em computadores pessoais, o sistema Linux passou a ter a colaboração de grandes empresas, como a IBM, a Sun Microsystems, a Hewlett-Packard, Red Hat, Novell e a Canonical. Com isso aumentou bastante também o número de colaborações dos usuários, o que ajudou muito o projeto, principalmente em sua tradução.

Fonte: http://www.apostilaz.com.br

Na falta de um roadmap formal, apontamos quatro incrementos que você pode esperar ver no sistema este ano, já em discussão na comunidade de desenvolvedores.

O último ano foi muito emocionante para o Linux. O que começou como passatempo, na Finlândia, completou 20 anos e dominou quase tudo, desde dispositivos móveis a supercomputadores.  E tudo leva a crer que 2012 ainda será um ano interessante para o sistema operacional.

O Linux não chega a ter um roadmap. O desenvolvimento é resultado da colaboração entre centenas de desenvolvedores de muitas empresas. Não existe ninguém elaborando uma lista de recursos a serem adicionados e direcionando desenvolvedores a trabalharem nela, ou em melhorias no kernel. Mas se você prestar atenção nas discussões da comunidade Linux, poderá ter uma ideia razoavelmente boa do que vai acontecer no futuro próximo.

Aqui estão algumas coisas que você pode esperar ver no Linux em 2012.

1 – Melhorias no Btrfs

Uma das grandes contribuições da Oracle para o kernel do Linux é o Btrfs, o sistema de arquivos que adiciona muitas características que as empresas gostariam de ver no OS. Por exemplo, o Btrfs suporta uma série de recursos e benefícios ausentes em outros sistemas para Linux, como pooling, instantâneos de estado do disco, soma de verificação, spanning integral de múltiplos dispositivos, uma maior integridade dos dados através da soma de verificação, instantâneos do sistema inteiro de arquivos antes de qualquer grande mudança, melhor gerenciamento de volume e RAID.

No entanto, faltam ao Btrfs algumas características- principalmente, a ferramenta fsck – que muita gente gostaria de ver implementada antes de colocá-lo em produção. A previsão era a de qu a ferramenta fsck estivesse diponível no fim de 2011. É provável que esteja pronta ainda no início de 2012, o que deve acelerar a adoção do Btrfs por algumas das distribuições Linux muito rapidamente.

Se eu tivesse que fazer uma previsão, diria que o Btrfs acabará por suplantar o Ext4 como sistema de arquivos padrão para a maioria das principais distribuições Linux. Mas não espere ver uso generalizado em ambientes de produção antes de meados de 2013.

2 – Android, alinhamento com plataforma ARM e foco nos sistemas embarcados

O Linux em sistemas embarcados vai continuar a ser um dos principais focos em 2012. Isso inclui tudo, desde set-top boxes, o Roku para telefones Android e tablets, e até sistemas para impressoras e qualquer outra coisa que você possa pensar.

Há muito barulho na imprensa especializada em TI sobre o fato do Android ser uma “ramificação” do Linux. Aqui está algo sobre o qual você não deve ter ouvido falar muito a respeito: o pessoal do kernel Linux e o do Android tem trabalhado duro para sincronizar o kernel principal e o kernel do Android.

Com o kernel 3.3, a maioria das funcionalidades do Android deve estar presente no kernel principal. Não tudo, mas progressos estão sendo feitos muito rapidamente. Se tudo correr bem, os usuários devem ser capazes de executar Android em cima de um vanilla kernel (kernel reduzido) até o fim do ano.

Note que este tipo de inclusão assíncrona não é incomum, e não há nenhuma razão para pânico. O Xen esteve fora do kernel padrão durante anos, enquanto sua equipe aprendia a trabalhar com a comunidade responsável pelo kernel (e vice-versa). A Red Hat e outras distribuições de Linux têm incluído patches para recursos ou dispositivos constantemente. É algom comum à plataforma.

Ao mesmo tempo, o pessoal do kernel continua a tentar domar o “oeste selvagem” da arquitetura ARM. Em um dado momento, havia cerca de 70 sub-arquiteturas ARM na árvore do kernel. Compare isso com outras arquiteturas, e você verá um problema aí. A boa notícia é que você também verá um esforço maior este ano para a resolução do problema.

Parte dele é o suporte a longo prazo da árvore do kernel para os fornecedores de eletrônicos de consumo. A Long Term Stable Kernel Initiative (LTSI) é focada na produção de um kernel estável, que estará disponível por aproximadamente a mesma quantidade de tempo de vida da maioria dos dispositivos eletrônicos de consumo (2 a 3 anos). O fato de muitos fornecedores estarem trabalhando juntos em um único núcleo deve fornecer uma série de benefícios.

A Canonical também anunciou na CES que está trabalhando em um Linux para set top boxes e DVRs. Será interessante ver a receptividade dos principais fabricantes desses dispositivos. Sou cético sobre suas chances de sucesso, a menos que consigam emplacar em algum dispositivo de uma grande marca, que o torne atraente para os usuários.

3 – Melhor ajuste e provisionamento

O cgroups é um recurso do Kernel do Linux, desde a versão 2.6.24, que tem como finalidade limitar, contabilizar e isolar o uso de recursos. Continua a evoluir e permitir um controle mais refinado do sistema. Por exemplo, no Linux 3.2 (lançado em 04 de janeiro) temos um novo recurso chamado CPU bandwidth control que permite que os administradores definam quanto tempo de CPU um grupo de processos pode usar.

A versão 3.2 acrescentou também ajustes finos de provisionamento ao Linux Device Mapper, que permite que administradores possam controlar o excesso de oferta de cotas de armazenamento para cada usuário. Isso pode parecer duvidoso, mas se você tiver algumas centenas de usuários em um sistema, será necessário definir um limite superior para a quantidade de armazenamento que poderão usar. Claro que, se configurado corretamente, a maioria dos usuários não se aproximará desse valor. Então você provavelmente não precisará de armazenamento suficiente para dar a cada usuário sua quota máxima.

Você pode esperar ver a melhoria contínua do cgroups e de outras áreas no kernel para permitir que os administradores de TI possam definir limites de recursos e outras formas de afinar seus sistemas ainda mais. As melhorias podem deixar de estar presentes em futuras versões do Linux por alguns ciclos, mas estão a caminho. Suspeito que o SUSE Enterprise Linux será lançado com um kernel 3.0 em 2013.

4 -Crescimento do OpenStack

Finalmente, esperamos ver o OpenStack sendo implantado até o fim de 2012 ou início de 2013. O projeto foi anunciado em 2010 e já atraiu mais de 140 empresas e organizações. É também a pilha de IaaS para o SUSE Linux e o Ubuntu. A partir das minhas conversas com membros da comunidade OpenStack, SUSE e Rackspace, digo, sem medo de errar, que o OpenStack terá um grande impulso em meados do ano.

Basicamente, o Linux vai continuar a melhorar para uso nas empresas e nas plataforma móveis. Com o Kindle Fire e o Nook, da Barnes & Noble, acho que veremos mais e mais tablets Android ganhando mercado. E, a não ser que algo drástico aconteça, o Android continuará a manter uma liderança firme no mercado de telefonia. O único lugar em que o Linux continuará a definhar será no desktop. Mas não se pode ter tudo, certo?

Fonte:

Joe Brockmeier, CIO/EUA

Publicada em 13 de janeiro de 2012

http://cio.uol.com.br/

Hoje em um servidor, seja ele web, de arquivos, ou qualquer outro serviço essencial para o dia-a-dia a ele denominado é primordial que um administrador possua alguma rotina de backup imposta sobre o mesmo.

É fato que esse trabalho é crítico pois no mundo da informação o que não queremos é perde-la, pois se isto acontecer poderá colocar os seus negócios no fio da navalha e certamente cabeças irão rolar. 

É complexo colocar nesta postagem um backup que resolva tudo, mas vou colocar e explicar como executar em um servidor web um backup das contas de usuários de sites hospedados e seus respectivos bancos de dados, ainda duplicando o backup efetuado como segurança para outro servidor. É claro que o conteúdo aqui proposto pode ser adaptado por você para executar rotinas de backup expecíficas.

O arquivo em shell script pode ser obtido neste link: backup-shell.sh (3)

Você pode fazer o download e colocar na “crontab” do seu sistema para que o mesmo efetue o backup na hora que melhor lhe convir.

Funcionamento

No início do arquivo shell script do link citado acima, teremos declarações de variaveis de controle do fluxo do programa.

O que vemos acima são variaveis de controle, como nome de usuário e senha do mysql, nomes de pastas para o armazenamento dos arquivos e diretórios capturados da origem, lista de exclusão de diretórios que não queremos que seja efetuado o backup e lista de servidores que queremos duplicar o backup ocorrido, ainda temos uma lista de e-mail para informar os responsáveis da ação efetuada pelo nosso backup.

Neste trecho é gerado uma lista de todos os bancos de dados existentes no Servidor MySQL excluindo as bases de dados da instalação básica do servidor como “information_schema” e “mysql” utilizando o comando “mysql” para efetuar o login e executar a ação.

Com o comando “mysqldump” efetuamos o backup das bases de dados existentes na lista capturada no comando anterior e salvamos a saida do resultado para um arquivo em disco contendo as informaçãoes como criação da base de dados, tabela e inserções de registros.

Aqui é executado o backup da pasta public_html de cada usuário existente, repare ainda que na sincronia podemos excluir diretórios utilizando a opção –exclude do comando rsync.

Com a lista de servidor(es) efetuamos um loop e sincronizamos os dados do diretório de backup efetuado com o comando anterior.

E por fim geramos um arquivo de log com as informações obtidas de cada comando efetuado no backup e enviamos para a lista de e-mail.

Claro que este backup pode ser melhorado e adaptado para outras situações que fogem do escopo desta postagem. A Idéia aqui é dar uma luz para aqueles que não a possui, espero que tenha ajudado.

Fonte:  http://www.nacaolivre.com.br

Você que tem IP Dinamico e não sabe como fazer para bloquear o acesso ao seu servidor, vai uma dica de regra de IPTables, onde você manipula a liberação de seu acesso com telnet.

Com a grande facilidade de se ter um servidor Cloud, Decidado ou outros, e o mesmo ficar aberto para a internet as portas de acesso como portas de SSH (22), FTP (21), Banco de Dados (mysql=3306); (postgres=5432) entre outros serviços, muitas vezes somos obrigados a mudar as portas para ter um pouco mais de segurança, com uma simples regra de firewall irei exemplificar uma forma de mudar isto, vamos a ela.

1- Crie um arquivo /etc/init.d/firewall ;

2- Setar permissão de execução chmod +x /etc/init.d/firewall ;

3- Adicionar o conteúdo abaixo neste arquivo (/etc/init.d/firewall);

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#!/bin/bash

# chkconfig: – 55 45
# description: Firewall IPTables
# Autor: Flávio Silva
# E-mail: contato@flaviosilva.net.br
# Site: http://www.deserv.com.br / http://blog.deserv.info
# probe: false

# Define o caminho do comando iptables
IPTABLES=`which iptables`
function OK() {
echo -e “\\033[1;39m [ \\033[1;32mOK\\033[1;39m ]\\033[1;0m"
}

function FALHOU() {
echo -e "\\033[1;39m [ \\033[1;31mFALHOU\\033[1;39m ]\\033[1;0m”
}

function STOP(){

###############################################################
# Flushing filter #
###############################################################
$IPTABLES -F
$IPTABLES -P INPUT ACCEPT
$IPTABLES -P OUTPUT ACCEPT
$IPTABLES -X
OK
}

function START(){
###############################################################
# Default Policies #
###############################################################
$IPTABLES -P INPUT DROP
$IPTABLES -P OUTPUT ACCEPT

###################
# Stateful Input #
###################
$IPTABLES -A INPUT -m state –state ESTABLISHED,RELATED -j ACCEPT

#######################################
# REGRA DE ACESSO DINAMICO SSH #
#######################################

HOST_IP=”0.0.0.0/0.0.0.0″

$IPTABLES -A INPUT -p tcp –dport 12345 -m recent –set –name SSH-ACCESS
$IPTABLES -A INPUT -p tcp -s $HOST_IP –dport 22 -m recent –rcheck –seconds 3600 –name SSH-ACCESS -j ACCEPT
$IPTABLES -A INPUT -m state –state NEW -m tcp -p tcp –dport 123456 -m recent –name SSH-ACCESS –remove

####################
# Loopback traffic #
####################
$IPTABLES -A INPUT -s 127.0.0.1 -i lo -j ACCEPT

##########################
# ICMP Filtering #
# and TRACEROUTE INPUT #
##########################
$IPTABLES -A INPUT -p icmp -j ACCEPT
$IPTABLES -A INPUT -p udp –dport 33434:33523 -j ACCEPT

#######################
# Drop stealth scans #
#######################
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,SYN FIN,SYN -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags SYN,RST SYN,RST -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,RST FIN,RST -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags FIN,ACK FIN -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags ACK,URG URG -j DROP
$IPTABLES -I INPUT -p tcp -m tcp –tcp-flags PSH,ACK PSH -j DROP

#################################
# Regras de Gerenciamento INPUT #
#################################

$IPTABLES -A INPUT -s XXX.XXX.XXX.XX -j ACCEPT #CASO TENHA ALGUM IP FIXO LIBERE ELE AQUI, SE NAO COMENTE ESTA LINHA COM “#”

#################################
# Fechando conexoes SSH OUTPUT #
#################################
$IPTABLES -A OUTPUT -p tcp –dport 22 -j DROP

#################################
# Regras de Clientes INPUT #
#################################
$IPTABLES -A INPUT -p tcp –dport 80 -j ACCEPT # HTTP
$IPTABLES -A INPUT -p tcp –dport 443 -j ACCEPT # HTTPS
$IPTABLES -A INPUT -p tcp –dport 3306 -j ACCEPT # MYSQL
$IPTABLES -A INPUT -p tcp –dport 21 -j ACCEPT # FTP

OK
}
#FW options

case $1 in
start)
echo “Carregando Modulo de firewall…”
START
;;

stop)
echo “Parando Modulo de firewall…”
STOP
;;

restart)
echo “Restartando Modulo de firewall…”
STOP
START
;;

*)

echo -e “Tente $0 {start|stop|restart}”
;;
Esac

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

OBS: Veja que a porta “12345″ indicada no bloco de “REGRAS DE ACESSO DINAMICO SSH”, foi configurada para efetuar a liberação da porta 22 neste exemplo, e a porta “123456″, para o bloqueio do acesso, abaixo efetuaremos os devidos testes.

4- Adicionar os modulos de Firewall a serem carregados

touch /etc/rc.modules
chmod 755 /etc/rc.modules

Conteudo do arquivo /etc/rc.modules

/sbin/modprobe ip_conntrack

source /etc/rc.modules <- Carrega o conteudo do arquivo

5- Execute o Arquivo de Firewall

OBS.: ANTES DE EXECUTAR O FIREWALL TENHA ALGUMA FORMA ALTERNATIVA DE ACESSO AO SERVIDOR PARA PODER EFETUAR OS DEVIDOS TESTES, POIS AO SUBIR O FIREWALL VOCÊ PODERÁ PERDER O ACESSO AO SERVIDOR

/etc/init.d/firewall start/stop/restart

6- Efetuando teste de acesso:
Com o Firewall habilitado, efetue o telnet na porta que você definiu para a abertura do SSH, no nosso exemplo a porta 12345:

telnet xxx.xxx.xxx.xxx 12345

Feito o telnet, seu IP será liberado no arquivo “/proc/net/ipt_recent/SSH-ACCESS” e o acesso é liberado para acessar o servidor diretamente na porta 22

O arquivo lhe mostrará o IP da seguinte forma: “src=xxx.xxx.xxx.xxx ttl: 61 last_seen: 523542876 oldest_pkt: 2 523539875, 523542876″

Para bloquear o acesso a porta 22 novamente, basta efetuar o telnet na porta de fechamento, no nosso caso a porta 123456.

telnet xxx.xxx.xxx.xxx 123456

PREENCHIMENTO DE ARQUIVOS:

 # duplicar o tamanho de um arquivo
 sed G

 # duplicar o tamanho de um arquivo que jah contém linhas em branco.
 # O arquivo de saída deve conter não mais que uma linha branca
 # entre linhas de texto
 sed '/^$/d;G'

 # triplicar o tamanho de um arquivo
 sed 'G;G'

 # desfazer a duplicação de tamanho (assume que as linhas de numeração par
 # estejam em branco)
 sed 'n;d'

 # insere uma linha em branco acima de cada linha que contem "regex"
 sed '/regex/{x;p;x;}'

 # insere uma linha em branco abaixo de cada linha que contem "regex"
 sed '/regex/G'

 # insere uma linha em branco acima e abaixo de cada linha que contem "regex"
 sed '/regex/{x;p;x;G;}'

NUMERACÃO:

 # numera cada linha de um arquivo (com alinhamento simples a esquerda). Usar
 # uma tabulação em vez do espaço vai preservar as margens. (veja a observação
 # sobre o '\t' no final desse arquivo)
 sed = arquivo | sed 'N;s/\n/\t/'

 # numera cada linha de um arquivo (números a esquerda, alinhados a direita)
 sed = arquivo | sed 'N; s/^/     /; s/ *\(.\{6,\}\)\n/\1  /'

 # numera cada linha de um arquivo, mas só imprime os números se a linha não
 # estiver em branco
 sed '/./=' arquivo | sed '/./N; s/\n/ /'

 # conta as linhas (emula o "wc -l")
 sed -n '$='

CONVERSÃO DE TEXTO E SUBSTITUIÇÃO:

 # EM AMBIENTE UNIX: converte o caractere de linha nova do DOS (CR/LF) para o
 # formato Unix
 sed 's/.$//'            # assume que todas as linhas terminam com CR/LF
 sed 's/^M$//'           # no bash/tcsh, pressione Ctrl-V depois Ctrl-M
 sed 's/\x0D$//'         # gsed 3.02.80, mas os scripts acima sao mais simples

 # EM AMBIENTE UNIX: converte o caractere de linha nova do Unix (LF) para
 # o formato DOS
 sed "s/$/`echo -e \\\r`/"            # comando usado com o ksh
 sed 's/$'"/`echo \\\r`/"             # comando usado com o bash
 sed "s/$/`echo \\\r`/"               # comando usado com o zsh
 sed 's/$/\r/'                        # gsed 3.02.80

 # EM AMBIENTE DOS: converte o caractere de linha nova do Unix (LF) para
 # o formato DOS
 sed "s/$//"                          # método 1
 sed -n p                             # método 2

 # EM AMBIENTE DOS: converte o caractere de linha nova do DOS (CR/LF) para
 # o formato Unix. Só pode ser feito com o sed UnxUtils, versão 4.0.7
 # ou maior. A versão do UnxUtils pode ser identificada pelo parâmetro padrão
 # "--text" que aparece quando o "--help" é usado. De outra forma, mudar
 # os caracteres de linha nova do DOS para o formato Unix não pode ser
 # feito em um ambiente DOS. Use o "tr" para isso.
 sed "s/\r//" arquivo_entrada >arquivo_saida         # sed UnxUtils versão v4.0.7 ou maior
 tr -d \r <arquivo_entrada >arquivo_saida            # tr GNU versão 1.22 ou maior

 # apaga o espaço em branco inicial (espaços, tabulações) do começo
 # de cada linha, puxando o texto para a esquerda
 sed 's/^[ \t]*//'                    # veja a nota sobre o '\t' no final
                                      # deste arquivo

 # apaga o espaço em branco final (espaços, tabulações) do final de cada linha
 sed 's/[ \t]*$//'                    # veja a nota sobre o '\t' no final
                                      # deste arquivo

 # deleta AMBOS os espaços em branco final e inicial de cada linha
 sed 's/^[ \t]*//;s/[ \t]*$//'

 # insere 5 espaços em branco no ínicio de cada linha (faz o offset da página)
 sed 's/^/     /'

 # alinha tudo a direita, numa coluna de 79 caracteres de largura
 sed -e :a -e 's/^.\{1,78\}$/ &/;ta'  # definido como 78 mais 1 espaço

 # centraliza todo o texto no meio de uma coluna de 79 caracteres de
 # largura. No método 1, os espaços no começo da linha são significativos,
 # e espaços em branco são anexados ao final de cada linha. No método 2,
 # os espaços no início de cada linha são descartados ao centralizar
 # a linha e não é adicionado nenhum espaço no final de cada linha.
 sed  -e :a -e 's/^.\{1,77\}$/ & /;ta'                     # método 1
 sed  -e :a -e 's/^.\{1,77\}$/ &/;ta' -e 's/\( *\)\1/\1/'  # método 2

 # substituir (achar e trocar) "foo" por "bar" em cada linha
 sed 's/foo/bar/'             # troca somente a 1a instância de uma linha
 sed 's/foo/bar/4'            # troca somente a 4a instância de uma linha
 sed 's/foo/bar/g'            # troca TODAS as instâncias de uma linha
 sed 's/\(.*\)foo\(.*foo\)/\1bar\2/' # troca o 'próximo-para-último'
 sed 's/\(.*\)foo/\1bar/'     # troca somente a última occorrência

 # substitui "foo" por "bar" SOMENTE nas linhas que contem "baz"
 sed '/baz/s/foo/bar/g'

 # substitui "foo" por "bar" EXCETO nas linhas que contem "baz"
 sed '/baz/!s/foo/bar/g'

 # troca "scarlet" ou "ruby" ou "pucy" para "red"
 sed 's/scarlet/red/g;s/ruby/red/g;s/puce/red/g'   # na maioria dos seds
 gsed 's/scarlet\|ruby\|puce/red/g'                # somente no GNU sed 

 # reverter a ordem das linhas (emula o "tac")
 # um bug/função do HHsed v1.5 fazia com que as linhas em branco fossem deletadas
 sed '1!G;h;$!d'              # método 1
 sed -n '1!G;h;$p'            # método 2

 # reverte cada caractere em cada linha (emula o "rev")
 sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'

 # une pares de linhas lado a lado (como o "paste")
 sed '$!N;s/\n/ /'

 # se uma linha termina com uma barra invertida, a próxima linha é
 # anexada a ela
 sed -e :a -e '/\\$/N; s/\\\n//; ta'

 # se uma linha termina com um sinal de igual, ela é anexada a linha
 # anterior e o sinal de "=" é substituído por um espaco simples.
 sed -e :a -e '$!N;s/\n=/ /;ta' -e 'P;D'

 # adiciona vírgulas a strings numéricos, mudando "1234567" para "1,234,567"
 gsed ':a;s/\B[0-9]\{3\}\>/,&/;ta'                     # GNU sed
 sed -e :a -e 's/\(.*[0-9]\)\([0-9]\{3\}\)/\1,\2/;ta'  # outros seds

 # adiciona vírgulas em números com pontos decimais e sinais de negativo (GNU sed)
 gsed -r ':a;s/(^|[^0-9.])([0-9]+)([0-9]{3})/\1\2,\3/g;ta'

 # adiciona uma linha em branco a cada 5 linhas (após as linhas 5, 10, 15, 20, etc.)
 gsed '0~5G'                  # somente no GNU sed
 sed 'n;n;n;n;G;'             # outros seds

IMPRESSÃO SELETIVA DE CERTAS LINHAS:

 # imprime as primeiras 10 linhas de um arquivo (emula o comportamento do "head")
 sed 10q

 # imprime a primeira linha de um arquivo (emula o "head -1")
 sed q

 # imprime as últimas 10 linhas de um arquivo (emula o "tail")
 sed -e :a -e '$q;N;11,$D;ba'

 # imprime as 2 últimas linhas de um arquivo (emula o "tail -2")
 sed '$!N;$!D'

 # imprime somente a última linha de um arquivo (emula o "tail -1")
 sed '$!d'                    # método 1
 sed -n '$p'                  # método 2

 # imprime somente as linhas que se encaixam na expressão regular
 # (emula o "grep")
 sed -n '/regexp/p'           # método 1
 sed '/regexp/!d'             # método 2

 # imprime somente as linhas que NÃO se encaixam na regexp (emula o "grep -v")
 sed -n '/regexp/!p'          # método 1, corresponde ao descrito acima
 sed '/regexp/d'              # método 2, sintaxe mais simples

 # imprime a linha imediatamente anterior a expressão regular, mas
 # não a linha contendo a expressão
 sed -n '/regexp/{g;1!p;};h'

 # imprime a linha imediatamente posterior a expressão regular, mas
 # não a linha contendo a expressão
 sed -n '/regexp/{n;p;}'

 # imprime uma linha de contexto antes e depois da expressão regular,
 # com o número da linha indicando onde a expressão regular
 # aparece (similar ao "grep -A1 -B1")
 sed -n -e '/regexp/{=;x;1!p;g;$!N;p;D;}' -e h

 # procura e imprime por AAA e BBB e CCC (em qualquer ordem)
 sed '/AAA/!d; /BBB/!d; /CCC/!d'

 # procura e imprime por AAA e BBB e CCC (nessa ordem)
 sed '/AAA.*BBB.*CCC/!d'

 # procura e imprime por AAA ou BBB ou CCC (emula o "egrep")
 sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d    # maioria dos seds
 gsed '/AAA\|BBB\|CCC/!d'                        # somente com o sed GNU

 # imprime um parágrafo se ele possuir AAA (linhas vazias separam os parágrafos).
 # Com o HHsed v1.5 deve ser inserido o 'G;' apos o 'x;', nos 3 scripts abaixo
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;'

 # imprime um parágrafo se ele possuir AAA e BBB e CCC (em qualquer ordem)
 sed -e '/./{H;$!d;}' -e 'x;/AAA/!d;/BBB/!d;/CCC/!d'

 # imprime o parágrafo inteiro se ele possuir AAA ou BBB ou CCC
 sed -e '/./{H;$!d;}' -e 'x;/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d
 gsed '/./{H;$!d;};x;/AAA\|BBB\|CCC/b;d'         # somente com o GNU sed

 # imprime somente as linhas com 65 caracteres ou mais
 sed -n '/^.\{65\}/p'

 # imprime somente as linhas com menos que 65 caracteres
 sed -n '/^.\{65\}/!p'        # método 1, corresponde ao descrito acima
 sed '/^.\{65\}/d'            # método 2, sintaxe mais simples

 # imprime uma parte do arquivo que vai da expressão regular até
 # o final do mesmo
 sed -n '/regexp/,$p'

 # imprime uma parte do arquivo baseada nos números das linhas (linhas 8-12,
 # inclusive)
 sed -n '8,12p'               # método 1
 sed '8,12!d'                 # método 2

 # imprime a linha de número 52
 sed -n '52p'                 # método 1
 sed '52!d'                   # método 2
 sed '52q;d'                  # método 3, eficiente com arquivos grandes

 # começando na linha 3, imprime cada sétima linha
 gsed -n '3~7p'               # somente o GNU sed
 sed -n '3,${p;n;n;n;n;n;n;}' # outros seds

 # imprime um pedaço de arquivo que está entre as duas
 # expressões regulares (inclusive)
 sed -n '/Iowa/,/Montana/p'             # é case sensitive

DELEÇÃO SELETIVA DE CERTAS LINHAS:

 # imprime todo o arquivo EXCETO a parte entre 2 expressões regulares
 sed '/Iowa/,/Montana/d'

 # deleta linhas duplicadas consecutivas de um arquivo (emula o "uniq"). A primeira
 # linha de um conjunto de linhas duplicadas é mantida, o resto é deletada
 sed '$!N; /^\(.*\)\n\1$/!P; D'

 # deleta linhas duplicadas não consecutivas. Tome cuidado para nao estourar
 # o tamanho do buffer do espaco de reserva (hold space), ou então use o sed GNU.
 sed -n 'G; s/\n/&&/; /^\([ -~]*\n\).*\n\1/d; s/\n//; h; P'

 # deleta todas as linhas exceto as linhas duplicadas (emula o "uniq -d").
 sed '$!N; s/^\(.*\)\n\1$/\1/; t; D'

 # deleta as 10 primeiras linhas de um arquivo
 sed '1,10d'

 # deleta a última linha de um arquivo
 sed'$d'

 # deleta as 2 últimas linhas de um arquivo
 sed 'N;$!P;$!D;$d'

 # deleta as 10 últimas linhas de um arquivo
 sed -e :a -e '$d;N;2,10ba' -e 'P;D'   # método 1
 sed -n -e :a -e '1,10!{P;N;D;};N;ba'  # método 2

 # deleta cada oitava linha
 gsed '0~8d'                           # somente no GNU sed
 sed 'n;n;n;n;n;n;n;d;'                # outros seds

 # deleta as linhas que combinarem com padrão
 sed '/padrao/d'

 # deleta TODAS as linhas em branco de um arquivo (o mesmo que "grep '.' ")
 sed '/^$/d'                           # método 1
 sed '/./!d'                           # método 2

 # deleta todas as linhas brancas CONSECUTIVAS de um arquivo exceto a primeira;
 # ainda deleta todas as linhas em branco do início e fim do arquivo (emula o
 # "cat -s")
 sed '/./,/^$/!d'          # método 1, permite 0 brancos no topo, 1 no
                           # final do arquivo
 sed '/^$/N;/\n$/D'        # método 2, permite 1 branco no top, 0 no
                           # final do arquivo

 # deleta todas as linhas em branco CONSECUTIVAS do arquivo, exceto as 2 primeiras:
 sed '/^$/N;/\n$/N;//D'

 # deleta todas as linhas em branco iniciais, no início do arquivo
 sed '/./,$!d'

 # deleta todas as linhas em branco finais, no final do arquivo
 sed -e :a -e '/^\n*$/{$d;N;ba' -e '}'  # funciona com todos os sed
 sed -e :a -e '/^\n*$/N;/\n$/ba'        # o mesmo, exceto gsed 3.02*

 # deleta a última linha de cada parágrafo
 sed -n '/^$/{p;h;};/./{x;/./p;}'

APLICAÇÕES ESPECIAIS:

 # remove overstrikes nroff (caracter, backspace) das man pages. O comando
 # 'echo' pode precisar da opção -e se você usar Unix System V ou uma
 # shell bash
 sed "s/.`echo \\\b`//g"    # as aspas duplas são necessárias em ambiente Unix
 sed 's/.^H//g'             # no bash/tcsh, pressione Ctrl-V e depois Ctrl-H
 sed 's/.\x08//g'           # expressão hexadecimal para o sed v1.5

 # mostra as mensagens de cabeçalho de um Usenet/e-mail
 sed '/^$/q'                # deleta tudo após a primeira linha em branco

 # mostra o corpo da mensagem de um Usenet/e-mail
 sed '1,/^$/d'              # deleta tudo até a primeira linha em branco

 # mostra o cabeçalho Subject, mas remove a porção inicial "Subject :"
 sed '/^Subject: */!d; s///;q'

 # pega o cabeçalho de endereço de resposta
 sed '/^Reply-To:/q; /^From:/h; /./d;g;q'

 # verifica o endereço de maneira correta. Pega o endereço de e-mail
 # através da 1a linha do cabeçalho de endereço de retorno (veja
 # o script acima)
 sed 's/ *(.*)//; s/>.*//; s/.*[:<] *//'

 # adiciona um sinal de maior com um espaço a cada linha (citação de uma
 # mensagem)
 sed 's/^/> /'

 # deleta o sinal de maior e o espaço de cada linha (remove a
 # citação de uma mensagem)
 sed 's/^> //'

 # remove a maioria das tags HTML (acomoda tags de múltiplas linhas)
 sed -e :a -e 's/<[^>]*>//g;/</N;//ba'

 # extrai binários uuencoded com múltiplos pedaços, removendo informações
 # estranhas/extras, fazendo com que só a parte uuencoded permaneça. Os
 # arquivos devem ser passados ao sed na ordem correta. A versão 1 pode
 # ser executada a partir da linha de comando; a versão 2 pode ser
 # executada a partir de um shell script Unix. (Modificado de um
 # script criado por Rahul Dhesi.)
 sed '/^end/,/^begin/d' arquivo1 arquivo2 ... arquivoX | uudecode   # vers. 1
 sed '/^end/,/^begin/d' $* | uudecode                      # vers. 2

 # Ordena parágrafos de arquivos alfabeticamente. Parágrafos são separados
 # por linhas em branco. O GNU sed usa o \v como tabulação vertical, ou qualquer
 # caracter único serve.
 sed '/./{H;d;};x;s/\n/={NL}=/g' file | sort | sed '1s/={NL}=//;s/={NL}=/\n/g'
 gsed '/./{H;d};x;y/\n/\v/' file | sort | sed '1s/\v//;y/\v/\n/'

 # zipa cada arquivo .TXT individualmente, deletando o arquivo fonte
 # e definindo o nome de cada .ZIP para o nome base do arquivo .TXT.
 # (no DOS: o comando "dir /b" retorna nomes de arquivo reduzidos e em caixa alta).
 echo @echo off >zipup.bat
 dir /b *.txt | sed "s/^\(.*\)\.TXT/pkzip -mo \1 \1.TXT/" >>zipup.bat

USO TÍPICO: O sed pega um ou mais comandos de edição e aplica todos eles,
em sequência, a cada linha de entrada. Após todos os comandos terem sido
aplicados a primeira linha de entrada, ela é jogada para a saída e a
segunda linha de entrada começa a ser processada, recomeçando o ciclo.
Os exemplos acima assumem que a entrada venha do dispositivo padrão  (por exemplo,
o console, onde  normalmente a entrada é via pipe). Um ou mais nomes de
arquivo podem ser passados na linha de comando se a entrada não vier da
entrada padrão. A saída é mandada para a saída padrão (a tela). Assim:

 cat arquivo | sed '10q'        # usa a entrada via pipe
 sed '10q' arquivo              # tem o mesmo efeito, mas evita o uso do "cat"
 sed '10q' arquivo > novo-arquivo    # redireciona a saída para o disco

Para instruções de sintaxe adicionais, incluindo a maneira de aplicar
comandos de edição a partir de um arquivo no disco, ao invés da linha
de comando, consulte "sed & awk, 2nd Edition," por Dale Dougherty e
Arnold Robbins (O'Reilly, 1997; http://www.ora.com), "UNIX Text
Processing," por Dale Dougherty e Tim O'Reilly (Hayden Books, 1987)
ou os tutoriais do Mike Arst distribuídos como U-SEDIT2.ZIP (em vários
sites). Para explorar totalmente o poder do sed, deve-se entender
as "expressões regulares". Para isso, veja "Mastering Regular Expressions"
de Jeffrey Friedl (O'Reilly, 1997). As páginas de manual ("man pages")
dos sistemas Unix podem ser úteis (tente "man sed", "man regexp", ou
a subseção sobre expressões regulares no "man ed"), mas as páginas
de manual são notadamente mais difíceis de se compreender. Elas
não são escritas para ensinar o uso do sed ou das expressões
regulares para usuários iniciantes, mas como texto de referência
para aqueles que já tem certa experiência com as duas ferramentas.

SINTAXE DAS ASPAS: Os exemplos acima utilizam as aspas simples ('...')
ao invés das aspas duplas ("...") para agrupar comandos de edição,
visto que o sed é comumente utilizado em plataformas Unix. As
aspas simples impedem que a shell Unix interprete o cifrão ($)
e a crase (`...`), os quais seriam expandidos pela shell se estivessem
dentro das aspas duplas. Usuários da shell "csh" e derivadas
ainda precisarão utilizar a barra invertida (\) antes do sinal de
exclamação (por exemplo \!) para conseguir rodar os exemplos acima, mesmo
usando as aspas simples. Versões do sed escritas para o DOS
invariavelmente necessitam das aspas duplas ("...") ao invés das
aspas simples para agrupar os comandos de edição.

USO DO '\t' NOS SCRIPTS SED: Para maior clareza na documentação, nós
utilizamos a expressão '\t' para indicar o caractere de tabulação
(0x09) nos scripts sed. Porém, a maioria das versões do sed não reconhece
a abreviação '\t', logo, quando for executar estes scripts via linha
de comando, você deve apertar a tecla TAB. A abreviação '\t' só
é reconhecida como um metacaractere nas expressões regulares no
awk, perl, HHsed, sedmod, e o GNU sed v3.02.80.

VERSÕES DO SED: As versões do sed diferem entre si, logo, algumas
variações na sintaxe são esperadas. Em particular, a maioria
não suporta o uso de rótulos (:nome) ou instruções ramificadas
(b,t) na edição dos comandos, exceto no final dos mesmos. Nós utilizamos
uma sintaxe que seria portável para a maioria dos usuários do sed,
mesmo sabendo que a popular versão GNU do sed permite uma sintaxe
mais sucinta. Quando o leitor vê um comando comprido como esse:

   sed -e '/AAA/b' -e '/BBB/b' -e '/CCC/b' -e d

é importante que ele saiba que o GNU sed permite uma redução, como:

   sed '/AAA/b;/BBB/b;/CCC/b;d'		# ou mesmo
   sed '/AAA\|BBB\|CCC/b;d'

Lembre-se ainda que, apesar de muitas versões do sed aceitarem comandos
como "/one/ s/RE1/RE2/", algumas não permitem o uso de "/one/! s/RE1/RE2/",
a qual contém um espaço antes do 's'. Omita o espaço quando for digitar
o comando.

OTIMIZANDO PARA MAIOR VELOCIDADE: Se a velocidade de execução precisa
aumentar (em virtude de grandes arquivos de entrada ou de processadores
e discos rígidos lentos), a substituição será executada mais rapidamente
se a expressão de "procura" é especificada antes da instrução
"s/.../.../". Assim:

   sed 's/foo/bar/g' arquivo         # comando de substituição padrão
   sed '/foo/ s/foo/bar/g' arquivo   # executa de forma mais rápida
   sed '/foo/ s//bar/g' arquivo      # sintaxe mais sucinta

Na seleção ou remoção de linhas nas quais você somente precisa
ver uma primeira parte de um arquivo, o comando "quit" (q) no script
irá reduzir drasticamente o tempo de processamento para arquivos
grandes. Assim:

   sed -n '45,50p' arquivo           # imprime as linhas 45-50
   sed -n '51q;45,50p' arquivo       # mesma coisa, mas faz muito mais
                                     # rapidamente

Fonte: http://sed.sourceforge.net/

Introdução

Apache é a implementação open source de um servidor HTTP. Ele é o webserver mais popular na Internet. Uma pesquisa realizada em 2005 pela NetCraft mostra que cerca de 70% dos sites na Internet rodam sobre o Apache.

Opções de Configuração em tempo de Compilação

Carrege apenas os módulos necessários

O servidor Apache é um programa modular onde o administrador pode escolher entre as funcinalidade que deseja incluir no servidor selecionando um pacote de módukis. Os módulos podem ser compilados estaticamente no binário httpd ou dinamicamente como DSOs(Dynamic Shared Objects). Módulos DSO podem ser compilados quando o servidor for compilado ou poem ser compilados utilizando o apxs para adicioná-los mais tarde. O modulo mod_so deve ser compilado estaticamente no Apache para que o suporte a DSO seja ativo.

Execute o apache apenas com os módulos necessários. Isto reduz o consumo de memória aumenta a performance do servidor. Compilar os módulos estaticamente irá reduzir o consumo de RAM que é utilizado para suportar módulos compilados dinamicamente, mas será necessário recompilar o apache toda vez que um módulo for adicionado ou removido. È aqui que o DSO se torna útil. Uma vez que o modulo mod_so seja compilado estaticamente, qualquer outro módulo pode ser inserido ou removido utilizando o comando LoadModule no arquivo httpd.conf – , mas você terá que compilar os módulos utilizando apxs se ele não foi compilado quando o servidor foi feito.

Escolha o MPM apropriado

O apache vem com uma selação de Módulos Multi-Processadores (MPMs) que são responsáveis por abrir as portas de rede na máquina, aceitando requisições, e despachando processos para cuidar das requisições. Apenas um MPM pode ser carregado por vez.

Escolher o MPM depende de vários fatores, por exemplo se o SO suporta threads, quanta memória está disponível, escalabilidade versus estabilidade, modulos externos,etc .. Sistemas Linux podem escolher entr utilizar um MPM com suporte (worker) a threads ou um prefork sem threads:

O MPM Worker utiliza múltiplos processos. Ele é multi-threaded com cada processo e cada thread cuidando de uma única conexão. Esté é mais rápido e mais escalável e a memória consumida e relativamente baixa. Funciona bem com múltiplos processadores. Porém, o worker é menos tolerante a módulos defeituosos, e threads defeituosas podem afetar todas as outras threads de um processo.

O MPM Prefork utiliza múltiplos processos filhos, cada filho cuidad de apenas uma conexão por vez. Prefork é muito bem gerenciada por processadores simples ou múlitplos, a velocidade é comparável ao worker e é mais tolerante a falhas em modulos e processos que terminam inesperadamente. Mas o consumo de memória é alto, mais tráfego leva a mais consumo de memória.

Opções de Configuração em Tempo de Execução

DNS lookup

A diretiva HostnameLookips habilita a consulta de DNS, então os hostnames podem ser logados ao invés de endereços IP. Isto adiciona latência em cada requisição desde que a consulta do DNS tem que ser completada antes que a requisição seja terminada. Esta opção é desabilitada por padrão no Apache 1.3 e superiores. Deixe isto inativo e utilize programas pós-processamento como o logresolve para determinar os IPs dos logs. Logresolve vem com Apache.

Quando utilizar as diretivas Allow from ou Deny from, utilize endereços IP ao invés de nomes de domínios. Caso contrário uma consulta dupla ao DNS será executada para ter certeza de que o domínio ou host não está sendo spoofado.

AllowOverride

Se o AllowOverride está setado para ‘None’, então o Apache irá tentar abrir o arquivo .htaccess (especificada pela diretiva AccessFileName) em cada diretório que for acessado. Por exemplo:

DocumentRoot /var/www/html
<Directory />
AllowOverride all
</Directory>

Se uma requisição for feita para acessar /index.html, o Apache irá tentar abrir /.htaccess, /var/.htaccess, /var/www/.htaccess, and /var/www/html/.htaccess. Estas tentativas aumentam a latência. Se o arquivo .htaccess for necessário para um diretório, habilite apenas para este diretório.

FollowSymLinks e SymLinksIfOwnerMatch

Se a opção FollowSymLinks estiver setada, então o servidor permitirá que links simbólicos possam ser seguidos neste diretório. Se a opção SymLinksIfOwnerMatch estiver setada, então o servidor permitirá acessar o link apenas se o destino dele bater com o dono do link.

Se a opção SymLinksIfOwnerMatch estiver setada, então o Apache terá que realizar consultas adicionais ao sistema para verificar se os donos coincidem. Chamadas adicionais também são necessárias quando a opção FollowSymLinks NÃO está setada. Por exemplo:

DocumentRoot /vaw/www/html
<Directory />
Options SymLinksIfOwnerMatch
</Directory>

Para uma requisição feita para /index.html, o Apache irá executar lstat() em /var, /var/www, /var/www/html, and /var/www/html/index.html. Estas requisições adicionais também irão aumentar a lantência. Os resultados do lstat não são cacheados, então as consultas irão ocorrer em cada requisição.

Para uma máxima performance, sete FollowSymLinks em cada lugar e nunca sete SymLinksIfOwnerMatch. Ou então, se SymLinksIfOwnerMatch for necessário para um diretório, sete ele para apenas este diretório.

Content Negotiation

Evite utilizar content negotiation para respostas mais rápidas. Se content negotiation é necessário para o site, utilize arquivos type-map ao invés da diretiva Options MultiViews. Com MultiViews, Apache precisa scanear o diretório em busca de arquivos, o que adiciona latência.

MaxClients

O MaxClients seta o número máximo de clientes simultâneos que pode ser suportada por cada servidor. Nenhum processo além do que está definido será aberto. Ele não deve conter um número muito baixo já que as requisições serão colacadas em fila, o que eventualmente irá dar time-out e os recursos do servidor continuarão não utilizados. Setar este valor muito alto irá causar o início de swap e o tempo de resposta irá cair drasticamente. O valor apropriado para MaxClientes pode ser calculado por: MaxClientes = Total RAM / Tamanho Máximo de Processos . O tamanho dos processos para arquivos estáticos é de mais ou menos 2-3MB. Para dinâmicos como PHP, deve ser por volta de 15MB. A coluna RSS de:

# ps -ylC httpd --sort:rss

Mostra a memória física non-swapped utilizada pelos processos do Apache em kilo Bytes.

Se existem mais usuários concorrentes do que MaxClients, as requisições serão colocadas em fila até o número baseado na diretiva ListenBacklog. Aumente o ServerLimit para setar o MaxClients acima de 256.

MinSpareServers, MaxSpareServers, e StartServers

MaxSpareServers e MinSpareServers determina quantos processos filhos devem ser mantidos rodando. Se MinSpareServers for muito baixo e muitas requisições forem iniciadas, então o Apache terá que abrir processos adicionais para atender as requisições. Criar processos filhos é relativamente caro. Se o servidor estiver ocupado criando processos, ele não estará disponível para servir as requisições imediatamente. MaxSpareServers não deve ser muito alto, ele pode causar problemas de recursos desde que cada processo consome os recursos da máquina.

Sete MinSpareServers e MaxSpareServers para um valor com que o Apache não precise frequentemente abrir mais de 4 processos por segundo. (O Apache pode abrir o máximo de 32 processos por segundo). Quando mais de 4 processos por segundo forem abertos, uma mensagem será logada no ErrorLog.

A diretiva StartServers define o número de processos criados na inicialização do Apache. O Apache irá continuar abrir os processos até que alcance o número de MinSpareServers. Não afeta muito a performance já que o servidor não é reiniciado frequentemente. Se existem muitas requisições e o Apache é reiniciado frequentemente, sete este valor para um número alto.

MaxRequestsPerChild

A diretiva MaxRequestsPerChild definie o número de requisições que um processo do servidor irá gerenciar. Depois as requisições MaxRequestsPerChild irão morrer. É definido para 0 por padrão, o que significa que o processo não irá expirar nunca. É apropriado setar este valor para alguns milhares. Isto pode ajudar a previnir vazamento de memória desde que o processo morre depois de servir um número de requisições. Não sete este valor muito baixo, já que criar novos processos causa overhead.

KeepAlive and KeepAliveTimeout

A diretiva KeepAilve permite que múltiplas requisições possam ser enviadas pela mesma conexão TCP. Isto é útil para páginas com muitas imagens. Se o KeepAlive estiver Off, então para cada imagem, uma nova conexão TCP precisa ser aberta.

KeepAliveTimeout determinada quanto tempo deve esperar até a próxima requisição. Sete para um valor baixo, por volta de 2 a 5 segundos. Se for setado para um valor muito alto, os processos ficam amarrados esperando pelo cliente quando eles poderiam ser utilizados para servir novos clientes.

Compressão HTTP & Caching

O servidor utiliza os métodos gzip ou deflate para as respostas payload antes que ele seja enviado para os clientes. Então o cliente descompacta o payload. Não existe necessidade de instalar softwares adicionais no lado do cliente desde que a maioria dos navegadores suporta isto. Utilizar compressão irá economizar banda e irá aumentar o tempo de resposta, estudos mostram que em média o ganho da compressão é de 75%. A compressão pode ser habilitada utilizando módulo mod_deflate. O Payload é compactado apenas se o navegador requisitar a compactação, ou então o conteúdo descompactado será enviado. Um navegador capaz de utilizar o conteúdo compactado envia o seguinte cabeçalho na requisição: “Accept-Encoding: gzip,deflate”. Então o servidor irá enviar o payload compactado e o cabeçalho da reposta é “Content-Encoding: gzip”

O exemplo a seguir utiliza o telnet para verificar os cabeçalhos de requisição e de resposta:

bash-3.00$ telnet www.webperformance.org 80
Trying 24.60.234.27...
Connected to www.webperformance.org (24.60.234.27).
Escape character is '^]'.
HEAD / HTTP/1.1
Host: www.webperformance.org
Accept-Encoding: gzip,deflate

HTTP/1.1 200 OK
Date: Sat, 31 Dec 2005 02:29:22 GMT
Server: Apache/2.0
X-Powered-By: PHP/5.1.1
Cache-Control: max-age=0
Expires: Sat, 31 Dec 2005 02:29:22 GMT
Vary: Accept-Encoding
Content-Encoding: gzip
Content-Length: 20
Content-Type: text/html; charset=ISO-8859-1

O module mod_cache pode ser utilizado no lado do servidor, está em produção estável na versão 2.2 do Apache.

Servidor separado para conteúdo estático e dinâmico

Processos do apache para conteúdo dinâmico consome cerca de 3-20MB de RAM. E cresce para acomodar o conteúdo e nunca diminui até que o processo termine. Digamos que um processo cresca até os 20MB para servir um conteúdo dinâmico. Depois de completar a requisição, ele está libre para servir outra requisição. Se vier uma requisição para uma imagem, então esses 20MB de processos está servindo um conteúdo estático que poderia ser executado por um processo de 1MB. A memória é utilizada ineficientemente.

Utilize uma pequena compilação do Apache (com o mínimo de módulos compilados estaticamente) como sendo o servidor front-end para servir conteúdos estáticos. As requisições para conteúdos dinâmicos serão encaminhadas para um apache robusto (compilado com todos os módulos necessários). Utilizar um servidor front-end leve tem a vantagem de que os conteúdos estáticos são enviados rapidamente sem o consumo alto de memória e apenas o conteúdo dinâmico é passado para o servidor robusto.

Encaminhamento de requisições pode ser implementado utilizando os módulos mod_proxy e mod_rewrite. Suponha que exista um servidor apache leve rodando na porta 80 e o robusto na porta 8088. Então a configuração a seguir pode ser utilizada no apache leve para encaminhar todas as requisições de conteúdo dinâmico para o servidor robusto.

ProxyPassReverse / http://%{HTTP_HOST}:8088/
RewriteEngine on
RewriteCond   %{REQUEST_URI} !.*\.(gif|png|jpg)$
RewriteRule ^/(.*) http://%{HTTP_HOST}:8088/$1 [P]

Todas as requisições, exceto as imagens serão encaminhadas para o apache robusto. As respostas são recebidas pelo servidor front-end que as encaminha para o cliente. Todas as respostas aparentam vir de um único servidor.

Conclusão

Configurar o Apache para obter o máximo de performance pode ser traiçoeiro, não existem regras rápidas. Entenda as necessidades do servidor web e experimente com várias opções. Utiliza ferramentas como ab e httperf para medir a performance do servidor. Servidores leves como tux, thttpd também podem ser utilizados como servidores front-end. Se um servidor de banco de dados é utilizado, tenha certeza de que ele está otimizado para que ele não crie nenhum gargalo. No caso do MySQL, mtop pode ser utilizado para monitorar querys lentas. Performance de scripts PHP pode ser melhorada utilizando produtos de cache como o Turck MMCache. Ele elimina o overhead da compilação realizando cache dos scripts em seu estado compilado.

Fonte

• http://www.howtoforge.net/configuring_apache_for_maximum_performance
• http://under-linux.org/wiki/Tutoriais/Apache/Apache-performance

Autor

Escrito por: Vishnu Ram is an MTech. in Communication Systems from IIT Madras. He joined Bobcares in 2003 and has been working for Poornam since then.

Port knocking funciona como um cadeado de segredo para ter acesso ao servidor, onde o usuário ou invasor terá que “bater” em um determinado número de portas com um limite de tempo também determinado para fazer a sequência para só assim liberar o ip que ele estiver usando também por um determinado tempo. O acesso a porta que queremos aqui no caso é a 22 (ssh).  

Vamos construir um cenário onde você queira primeiro liberar o acesso direto a alguns IPs sem precisar passar pelo segredo das portas, depois liberaremos todos os IPs (ou alguma rede específica) somente se acertarem a sequência das portas e por último bloquearemos todo o resto.

A configuração a seguir pode ser adicionada a seu script de firewall.

Como este é o primeiro tutorial que escrevo, tentarei ser o mais claro possível (espero que me perdoem se não conseguir):

Testando:

A forma mais fácil que eu acho para testar é utilizando o telnet. Por ex.:

$ telnet IP_SERVIDOR 100
$ telnet IP_SERVIDOR 200
$ telnet IP_SERVIDOR 300
$ telnet IP_SERVIDOR 400

e agora é só entrar com ssh normalmente.

Por: Leandro Lanini
Fonte: http://www.vivaolinux.com.br

Introdução

O e-mail é a forma de comunicação mais utilizada hoje em dia. Se o servidor de e-mails de uma empresa parar, é como se o mundo acabasse para os usuários! O telefone não vai parar de tocar, e-mails importantes não serão entregues/recebidos podendo gerar grandes prejuízos financeiros para empresas.

Imaginando um cenário desses, você com certeza não escolheria qualquer solução para implantar na sua empresa, certo? Atualmente, um dos melhores, mais seguros e mais estáveis softwares MTA (Mail Transport Agent) disponíveis é o Postfix.

Embora ele seja simples para quem já possui experiência na administração de servidores Linux, ele pode ser um pouquinho complicado para quem está apenas começando na administração de sistemas.

Por isso, neste artigo vou mostrar uma solução para facilitar a configuração do Postfix: o iRedMail. Este é um software que automatiza todo o processo de instalação e configuração de um servidor de e-mails utilizando as distribuições CentOS e Red Hat. Ele permite que você escolha o backend de gerenciamento de usuários (MySQL ou OpenLDAP), qual o webmail que você quer utilizar, gerenciador MySQL ou OpenLDAP, entre várias outras opções.

Aqui, vou assumir que você já possui um servidor CentOS configurado e funcional com acesso à Internet.

Quais os softwares que o iRedMail utiliza?

O iRedMail faz o download de todos os softwares automaticamente. Porém, obviamente você precisa saber quais são estes softwares que ele utiliza e suas versões também.

Segue uma lista de alguns dos softwares utilizados por ele:

• Amavisd-new 2.6.2-2
• Clamav 0.94.2-1
• Dovecot 1.1.11
• Postfix 2.5.6

Claro que esta não é a lista completa. Para verificar todos os pacotes que foram baixados para a sua máquina entre no diretório pkgs/rpms dentro do diretório criado quando você descompacta o iRedMail.

Download do iRedMail

O site oficial do iRedMail é http://code.google.com/p/iredmail/.

Vá até a seção “Downloads”. Lá você irá encontrar todas as versões do iRedMail que foram publicadas. Até a data de publicação deste texto, a versão mais recente é a 0.4.0, que pode ser obtida no link: http://iredmail.googlecode.com/files/iRedMail-0.4.0.tar.bz2.

Instalação

O script de instalação do iRedMail cuida de todo o processo, inclusive do download de todos os RPM’s necessários para que a instalação seja feita sem problemas. Vamos à instalação.

Primeiro, descompacte o arquivo que você baixou do site oficial:

# tar xjvf iRedMail-0.4.0.tar.bz2

Será criado um diretório chamado iRedMail-0.4.0. Entre nele:

# cd iRedMail-0.4.0

O seu diretório se parecerá com este:

Entre no diretório pkgs e execute o script que faz o download de todos os pacotes necessários:

# bash get_all.sh

E vá tomar um café. Dependendo da velocidade da sua conexão esta etapa poderá demorar um pouco para ser concluída. Quando ela terminar, podemos começar a configuração do nosso servidor de e-mail.

Para isso, faça o seguinte. Suba um nível em relação ao diretório pkgs (o diretório raíz do iRedMail) e execute o script iRedMail.sh:

# cd .. ; bash iRedMail.sh

Você verá a tela inicial da instalação do iRedMail:

Esta tela é apenas informativa. Aperte enter para passarmos para a próxima tela.

Esta tela permite que você escolha qual será o diretório home do usuário vmail. Como não serão criados usuários no sistema (todos os usuários serão virtuais), todos os e-mails serão entregues ao vmail e ele irá “distribuir” estas mensagens aos usuários certos.

Como este diretório irá conter todos os e-mails que chegam ao sistema, pode ser que ele cresça bastante com o tempo, portanto pense no futuro e reserve um espaço considerável para o home do usuário vmail.

Você pode deixar o padrão ou modificar para outro diretório que você queira. Depois selecione “OK”.

Agora, devemos escolher qual vai ser o backend do nosso servidor de e-mail. Isto irá informar ao iRedMail como nós queremos que ele guarde as informações de contas de usuários, autenticação, etc.

Se você escolher MySQL, o webmail será o RoundCube (um webmail excelente) e a ferramenta de administração será o PostfixAdmin. Se você escolher o OpenLDAP ele irá utilizar o SquirrelMail como webmail (o RoundCube não suporta OpenLDAP) e a ferramenta de administração será o phpLDAPadmin.

O MySQL é o recomendado, aqui iremos utilizá-lo. Obviamente, os passos daqui para frente serão diferentes dependendo do que você escolher aqui. Em outro artigo tratarei a configuração do OpenLDAP como backend. Vamos para a próxima tela.

Aqui devemos informar ao iRedMail qual a senha queremos utilizar para o usuário root do MySQL. Informe a senha com cuidado pois não haverá chance de confirmá-la mais tarde. Tenha certeza que digitou a senha corretamente.

Nesta tela devemos informar a senha do usuário administrador do Vmail. Aqui acontece a mesma coisa que aconteceu com a senha do root do MySQL: você não vai poder confirmar a senha que escreveu. Portanto, tenha certeza que digitou a senha corretamente.

Aqui acabam as diferenças de configuração entre MySQL e OpenLDAP.

Você precisa informar o domínio que você quer utilizar. Lembre-se, este é um domínio virtual. Você poderá adicionar outros domínios sem problema algum quando precisar.

Nesta tela você deve definir qual será o nome de usuário do administrador do domínio. O padrão em todos os servidores de e-mail é definir “postmaster” para este usuário. Seguiremos o padrão aqui.

Aqui devemos definir qual será a senha da conta “postmaster”, o administrador do domínio.

Nesta tela você pode criar o primeiro usuário “normal” do seu domínio. Ele não terá direito especial algum, é apenas um usuário.

Nesta tela você pode definir a senha para o usuário. Ele irá utilizar esta senha quando for ler o e-mail ou acessar o webmail.

Aqui você deve escolher se quer habilitar ou não o suporte a SPF e DKIM. Segue uma breve descrição sobre o que são ambos:

• DKIM: DomainKeys Identified Mail. Basicamente, o DKIM oferece um método para validar um nome de domínio associado a um e-mail através de autenticação criptográfica.
• SPF: O objetivo do SPF é impedir que worms, vírus e spammers utilizem endereços arbitrários (ou inexistentes) no campo “sender” do envelope do e-mail. Os administradores do domínio devem publicar registros SPF no DNS e os administradores do servidor de e-mail devem utilizar MTAs (como o Postfix) que possuam suporte ao SPF para que ele compreenda os registros SPF. Estes registros informam quais servidores possuem autoridade para enviar e-mails. Qualquer outro servidor enviando e-mails destes domínios não possui credibilidade e os e-mails são descartados.

Você pode habilitar ambos ou nenhum, fica à sua escolha.

O pysieved é um serviço que gerencia scripts Sieve que os usuários utilizam.

Sieve é uma linguagem especializada no tratamento e filtragem de e-mails. Não é uma linguagem de programação completa.

Ela permite que se desenvolva pequenos scripts (que podem ser implementados no cliente ou no servidor de e-mails) que filtram e-mails, como por exemplo recusando e-mails maiores de 1MB e enviando uma mensagem de aviso de volta à origem da mensagem (ao remetente).

O pysieved permite que os usuários executem scripts Sieve no servidor sem precisar de uma conta nele.

Nesta tela você pode escolher se vai prover suporte a POP3/IMAP utilizando SSL.

É recomendado que se utilize o SSL pois ele criptografa todo o conteúdo das mensagens impedindo que sniffers e ataques como “man in the middle” consigam ler todo o conteúdo transferido por estas mensagens.

Nesta tela você pode escolher o webmail que deseja utilizar no seu servidor. Escolha o seu favorito e selecione “OK”.

Neste passo da instalação você poderá definir qual será a língua principal utilizada no seu webmail. Basta utilizar a seta para baixo para rolar por todas as opções e utilizar a barra de espaço para selecionar.

Nesta tela você pode escolher se quer instalar o phpMyAdmin (para administrar o banco de dados MySQL via web), o PostfixAdmin (para gerenciar domínios e contas de usuários via web) e o AwStats (para verificar estatísticas sobre o servidor de e-mails).

Aqui você escolhe o usuário administrador do PostfixAdmin (não do domínio). O padrão é usar o “postmaster”, mas você pode usar qualquer usuário que deseje.

Aqui você irá criar um “alias”, um nome alternativo, para o usuário root. Isso é necessário pois é o usuário root quem irá receber as mensagens de falhas, problemas, etc do sistema.

Isso conclui toda a configuração do seu servidor de e-mail.

Depois, responda “Y” e pressione a tecla “enter” para dar continuidade ao processo de instalação do sistema.

Agora o iRedMail irá instalar e configurar (de acordo com os parâmetros passados a ele nos passos anteriores) todos os softwares envolvidos com o serviço de entrega de e-mails. Além disso, ele também irá atualizar todos os pacotes que já estão na máquina. O processo irá levar bastante tempo, seja paciente e aguarde até o final.

Quando o iRedMail perguntar se você deseja remover o sendmail, diga que sim.

Depois, o programa irá perguntar se você quer utilizar as regras de IPTables configuradas no iRedMail ou não. Se você quiser fazer as suas próprias regras, responda não. Caso deseje utilizar estas regras, responda sim. Se utilizar as regras, reinicie o IPTables quando for questionado.

Se você já estiver utilizando o MySQL para outras finalidades, responda não quando for questionado se quer sobrescrever o arquivo de configuração do MySQL utilizando um modelo fornecido pelo iRedMail. Caso não esteja utilizando o MySQL para outras finalidades, pode resopnder afirmativamente sem problemas.

Logo após, ele irá perguntar se você quer atualizar o Clamav. É recomendado que já faça isso para que você não corra o risco de esquecer de fazê-lo mais tarde. Para atualizar, responda “Y”.

Por último, o software irá perguntar se você quer inicializar o Postfix. Responda que sim. Ele irá inicializar o Postfix e todos os serviços que ele necessitar para funcionar corretamente.

Pronto! Seu servidor de e-mail está ativo! Basta agora você adicionar outros usuários ao banco de dados para que os outros usuários também possam utilizar o seu servidor (você pode utilizar o PostfixAdmin para isso).

Acessando webmail e o PostfixAdmin

Para acessar todos os serviços web configurados no seu servidor de e-mails, recomendo que configure um registro no seu DNS para facilitar as coisas.

Para acessar o webmail utilize a URL http://servidor/mail ou http://servidor/webmail. Isto irá acessar o webmail que você escolheu durante a configuração do iRedMail.

O Postfixadmin ficará ativo no endereço http://servidor/postfixadmin.

Estas e muitas outras informações como localização de logs, arquivos de configuração utilizados, etc. estão localizados no arquivo dentro do diretório criado quando você descompacta o pacote do iRedMail, chamado iRedMail.tips. Nele você irá encontrar todas as informações que precisar.

Conclusão

O iRedMail é uma excelente ferramenta que simplifica e muito o processo de configurar um servidor de e-mails para a sua empresa. Porém, não confie 100% nele.

Faça todas as análises de segurança necessárias para garantir que seu servidor não será comprometido. Atualize sempre os softwares utilizados, tente configurar CHRoot, atualize sempre o anti-vírus, utilize senhas fortes, etc. Sempre tente garantir que seu servidor está o mais seguro possível.

Fonte: http://www.pedropereira.net

O conceito de Distributed Denial of Service (DDoS) entrou na consciência pública após principais websites enorme como Change.org , WordPress , e vários governos e notíciassites de diferentes países foram recentemente vítimas de uma série de ataques.

Apelidado de instrumento moderno de cyber-guerra, uma maneira rápida e simples para descrever DDoS é que, sob a tática, códigos maliciosos infectam computadores para desencadear ataques em massa contra sites segmentados, fazendo-a ser inacessíveis ao tráfego legítimo. Ataques DDoS, apesar de sofisticados, são difíceis de defender e nesta parte, você vai descobrir o porquê.

Provavelmente, o maior equívoco sobre os ataques DDoS é que quando você tem um único software de proteção instalado e estão sendo executados em uma plataforma de Internet bem conhecidos ou hospedar, você já está seguro – recentes ataques a grandes sites que têm refutado. Temos muita sorte de ter caras da Radware , um sistema integrado de entrega de aplicativos empresa de soluções, especializada em DDoS prevenção e mitigação, para nos levar para um olhar mais atento sobre os ataques DDoS.

Como os principais sites, incluindo WordPress, foram violados com sucesso com os ataques DDoS

Radware nos disse que as metas ainda muito maiores têm sido privados de conectividade com a Internet básica no passado, incluindo infra-estruturas de Internet de países inteiros – cujos cidadãos não foram capazes de usar a Internet durante os ataques DDoS em curso.

Muitos destes ataques teve sucesso porque muitas empresas e redes ainda estão mal equipados, quando se trata de enfrentar os ataques DoS – enquanto os gerentes de segurança estão muito bem versados ​​na escolha das tecnologias mais adequado para combater as ameaças, como invasões, worms e explorações aplicação web – Há um equívoco comum entre a comunidade de segurança que estas mesmas tecnologias podem também ser invocado para proteção DoS.

Um exemplo seria o Intrusion Prevention System , que na maior parte se concentra em tecnologia baseada em assinaturas. A solução IPS contém regras pré-definidas ou assinaturas para a identificação de tráfego malicioso conhecido. Ela geralmente usa hardware especializado para a detecção de tráfego, tais com taxas de alto rendimento, bem como a análise do complexo da camada de protocolos e 7 a normalização do tráfego para evitar técnicas de evasão diferentes. Além disso, tradicionalmente fornece básica “Anti-DoS” características tais como taxa de limites.

Radware explica:

Proteger contra ataques DoS, distribuídos ou não, normalmente não exigem a funcionalidade acima (por exemplo, detecção baseada em assinaturas normalização do tráfego) – cada pedido, enviado como parte de um ataque DoS, pode ver completamente legítimo em si renderização assinatura de detecção de inútil e taxa-limite de características tipicamente limitar o tráfego legítimo da mesma forma que o tráfego ilegítimo – trazendo a condição de DoS à IPS ao invés da entidade sob ataque como o IPS inicia bloqueando o tráfego legítimo.

Soluções mais tradicionais IPS são, portanto, incapaz de proteger contra os ataques DDoS.

O caminho, manual ineficaz

Uma vez afetado, enquanto despreparados, embora exija conhecimentos técnicos, pode-se tentar manualmente analisar o tráfego, distinguir as características de ataque da norma – então tentar bloquear o ataque, usando as características de ataque com base em métodos, dependendo do tipo de ataque. Radware explica:

Se o dilúvio é stateful (exigindo a realização de um handshake TCP completa, garantindo os endereços IP de origem não são falsificados), por exemplo uma inundação HTTP – e é fácil de pegar que o atacante é pelo cruzamento de transação HTTP layer-7 estatísticas por endereço IP, os endereços de IP pode ser seguramente na lista negra no ACL router.

A questão é que fazer o acima manualmente pode ser muito demorado e muitas vezes não vai produzir nenhum resultado se o ataque é muito intenso para hardware commodity de manusear.

O melhor esforço para prevenir ataques DDoS

Uma solução Anti-DoS deve ser composto de tecnologia Anti-DDoS e Anti-DDoS serviços de resposta de emergência a fim de ser eficaz, e chegar a 100% de prevenção DDoS:

I. Anti-DDoS tecnologia

• Desempenho de mitigação – DDoS alta taxa deve ser mitigado por hardware especializado para suportar a carga de ataque, permitindo o tráfego legítimo para passar – por exemplo, Anti-DDoS soluções usando ASIC baseada em motores de Mitigação de DDoS
• Reduzindo o tempo de reação – Análise Comportamental de Rede Tecnologia (NBA) deve ser utilizado para automaticamente e com precisão distinguir o tráfego ataque de tráfego legítimo – em todas as camadas, incluindo camada 7 (por exemplo, HTTP)
• Bloqueio de múltiplos vetores de ataque – usando NBA, IPS e DoS tecnologias dentro de uma solução anti-DDoS único garante nenhum ataque é negligenciado durante uma campanha de ataque multi-vector

II. Anti-DDoS serviços

• Resposta de emergência – usando a tecnologia anti-DDoS avançadas deve ser complementado por engenheiros de segurança comprovada, experiente e conhecedor que são bem versados ​​na mitigação DDoS ataque e o funcionamento da solução escolhida Anti-DDoS. A 24 × 7 centralizado serviço desse tipo (por exemplo, fornecido por um vendedor de Anti-DDoS) pode garantir o fator humano necessário para mitigar os ataques DDoS forma mais eficiente possível

Você deve se preocupar?

Quando afetados, o impacto direto é simplesmente um “Denial of Service” – o serviço sob o ataque irá parar de responder – às vezes, toda a rede do serviço sob o ataque pode parar de responder, se o ataque é forte o suficiente para afetar equipamentos de rede no perímetro do alvo (por exemplo, firewalls).

O elemento chave compartilhada por todos os alvos de ataques DDoS tem sido a incapacidade de lidar com uma década de idade ameaça. No entanto, isso não tem a ver com a falta de preparação, mas mais de vítimas de queda de um dedicado, ataques coordenados por hacktivistas, como podemos chamá-los.

Embora não seja um impacto direto de DoS – ataques podem ser lançados não só para derrubar um serviço, mas também para servir como uma distração, enquanto se infiltrar em outros servidores na organização e de devastar – comprometer informações confidenciais, o plantio de código malicioso e muito mais.

A menos que você está um blog ou site grandes que são especificamente orientadas por hackers, você não tem muito que se preocupar. No entanto, se você for, seria melhor ter uma equipe dedicada ao monitoramento e mitigação de tais ataques, ou apenas pegar um especialista de terceiros no fornecimento de soluções para fazê-lo.

Fonte: http://thenextweb.com/

Várias vulnerabilidades foram reportadas no phpMyAdmin, de acordo com a empresa de segurança Secunia. Elas podem ser exploradas para conduzir ataques XSS e potencialmente comprometer um sistema vulnerável ou revelar dados sensíveis e privados.

1) Certas entradas passadas para o table name no script de table print view não são adequadamente tratadas antes de serem retornadas ao usuário. Isso pode ser explorado para executar código malicioso de HTML e de script em uma sessão do navegador do usuário, no contexto de um site afetado. Essa vulnerabilidade é reportada na versão 3.4.3.1 e anteriores.

2) Certas entradas passadas para o parâmetro de transformação MIME-type não são adequadamente verificadas antes de serem usadas para incluir arquivos. Isso pode ser explorado para incluir arquivos maliciosos de recursos locais.

3) Certas entradas passadas para um parâmetro não-especificado no código ‘relational schema‘ não são adequadamente tratadas antes de serem usadas para concatenar um nome de classe. Isso também pode ser explorado para incluir arquivos maliciosos de recursos locais. As vulnerabilidades 2 e 3 são reportadas nas versões 3.4.0 a 3.4.3.1.

4) Um erro não-especificado na autenticação Swekey pode ser explorado para sobreescrever variáveis de sessão. Essa vulnerabilidade é reportada na versão 3.4.3.1 e anteriores.

A solução é atualizar para a versão 3.4.5

Clique Aqui para Baixar a versão mais recente

Fonte: http://www.hackerinfo.com.br  |  http://www.net-security.org

http://www.net-security.org/

Para quem tem o VMWare Esxi 4.0 aqui vão os comandos para atualizar para o 4.1, a grande novidade no 4.1 é o suporte USB para as máquinas virtuais.

Baixar o pacote de atualização do VMWare Esxi no site, .zip:

• http://downloads.vmware.com/d/info/datacenter_downloads/vmware_vsphere_hypervisor_esxi/4

ESXi 4.1 (upgrade ZIP from ESXi 4.0)
07/13/10 | 4.1 | 202 MB | Binary (.zip)

Conectar ao seu servidor Esxi com o VMware vSphere Client.

Desligar todas as máquinas virtuais do servidor.

Clicar com botão direito na árvore e colocar o esxi em modo de manutenção.

Feito isso, acesse o datastore pelo VMware vSphere Client, configurações – datastore – clicar com botão direito em “datastoreI” e explorar.

Note que nas opções acima tem “UPLOAD”, clique nela e em seguida faça upload do arquivo .zip para o seu datastore.

Próximo passo é acessar o servidor VMWare por putty.

Caso não esteja habilitado o ssh no VMWARE, fazer os seguintes passos no console do servidor:

1. alt + F1, para que apareça algo na tela, digite “unsupported”
2. digite a senha de root
3. vi /etc/inetd.conf
4. descomente a linha que contém os parâmetros do SSH e salve o arquivo.
5. reinicie o servidor.

Pronto, com o SSH habilitado acesse o servidor via putty.

Checando o arquivo:

# esxupdate –bundle=/vmfs/volumes/datastoreI/upgrade-from-ESXi4.0-to-4.1.0-0.0.260247-release.zipcheck

Caso “Check ok”, rodar update:

# esxupdate –bundle=/vmfs/volumes/datastoreI/upgrade-from-ESXi4.0-to-4.1.0-0.0.260247-release.zip update

Assim que ele terminar o UPDATE o servidor vai reiniciar sozinho, assim que ele subir basta conectar nele com o VMware vSphere Client, tirar do modo manutenção e subir as máquinas virtuais.

Obs. importante:

Para funcionar a USB, as máquinas virtuais devem estar na versão 7 e adicionar o USB Controller na VM, caso esteja na versão 4, com a máquina virtual desligada é só clicar com o botão direito em cima dela de upgrade versão 7.

Fonte: http://www.vivaolinux.com.br

Como foi noticiado aqui no Blog do Vicente, a VMware lançou gratuitamente o produto para virtualização VMWARE ESXi. É um produto robusto que, acredito, deve alterar sensivelmente os datacenters por todo o mundo. Na minha opinião, a não ser que o servidor tenha uma carga muito alta, já não faz mais sentido instalar o sistema operacionaldiretamente no hardware. O VMware ESXi deve então se tornar a plataforma padrão para servidores.

Hoje vamos ver como criar máquinas virtuais. Como pré-requisito para este tutorial você deve ter instalado o VMware ESXi, baixado e instalado o software de gerenciamento.

Execute o VMware Infrastructure Client do seu desktop ou do menu iniciar. Digite o IP ou nome do seu servidor, o usuário root e a senha que você cadastrou na configuração do servidor. Para acessar o servidor pelo nome você precisa ter cadastrado o nome no DNS da sua rede.

Depois de logar, esta é a tela inicial do cliente de administração do VMware.

Clique com o botão direito no servidor e escolha a opção New Virtual Machine.

Será iniciado um wizard (assistente) para a criação da máquina virtual. Selecione a opção Typical e clique em Next.

Nesta opção você deve informar o nome da máquina virtual e clicar em Next.

Aqui você deve informar em qual datastore serão armazenados os discos. Se você tiver só discos internos aparecerá só uma opção. Se você tiver acesso a discos externos via SAN ou NFS, outras opções de datastore poderão estar disponíveis. Selecione o datastore desejado e clique em Next.

Selecione qual sistema operacional será instalado. Escolha a opção desejada e clique em Next. IMPORTANTE: 32 e 64 bits fazem diferença aqui.

Escolha quantos processadores você vai atribuir à máquina. Neste exemplo como o servidor tem 2 processadores, é possível escolher 1 ou 2. Se você tiver mais processadores, é possível escolher 1, 2 ou 4 processadores. Se a máquina que você for criar não precise de tantos recursos, crie com somente 1, pois 2 ou 4 processadores vão gastar mais memória. Selecione a quantidade desejada e clique em Next. Observação: Em máquinas Dual o Quad Core, cada core é considerado um processador.

Selecione a quantidade de memória desejada e clique em Next.

Selecione em qual rede a máquina será conectada. É possível colocar redes diversas na mesma máquina. Por exemplo: Uma máquina virtual pode estar ligada na sua rede interna e na internet servindo como seu servidor Web. Para isso é possível usar 2 placas de rede ou utilizar VLANs pelo protocolo 802.1Q na mesma placa de rede. Selecione a rede desejada e clique em Next.

Selecione o tamanho do disco da máquina virtual e clique em Next.

Revise as opções selecionadas para a sua máquina virtual e clique em Finish para concluir.

Agora que sua máquina virtual foi criada, é preciso selecionar a mídia de instalação para sua máquina virtual. Para isso edite a máquina virtual clicando com o botão direito do mouse na máquina virtual recém-criada e selecione a opção Edit Settings.

Selecione o CD/DVD Drive 1 e escolha a opção desejada. Neste caso usaremos a opção Client Device, que é utilizar o CD da máquina em que está sendo gerenciado o servidor. As outras opções são: Host Device, que usa o CD do servidor e Datastore ISO file, que pode instalar a máquina virtual a partir de uma imagem de disco ISO que esteja no datastore. A última opção é a mais rápida, já que o acesso a disco é mais rápido que do CD ou DVD. Clique em OK para sair.

Agora você já pode iniciar a máquina virtual clicando com o botão direito do mouse na máquina virtual e clicando na opção Power ON. Para utilizar o CD do seu computador, insira do disco de instalação do sistema operacional desejado no drive e clique no botão Connect CD/DVD 1.

Pronto! Agora é só instalar a máquina virtual do mesmo jeito que instalaria se fosse uma máquina física. Com a vantagem de que é muito mais rápido! Verifique se a versão instalada é afetada pelo bug do dia 12 de agosto. Se for aplique os patches necessários para evitar a ocorrência do erro General System Error Ocurred: Internal Error.

Atualização em 17/11/2008: Depois que instalar o sistema operacional, não esqueça de instalar o software VMware Tools que é indispensável para haver a comunicação entre Host VMware e a máquina virtual, bem como otimizar o uso de memória no Host. Para instalar basta clicar com o botão direito do mouse na máquina virtual e clicar na opção Install/Upgrade VMware Tools. Será aberta uma tela em que é possível instalar o software de modo interativo ou automático. Na maior parte das vezes, o modo automático funciona bem.

IMPORTANTE: Se você for instalar Windows XP por exemplo, precisará do driver da placa SCSI Bus Logic, que o VMware emula. Não é possível simular hds IDE no VMware ESXi. Do mesmo jeito que se usa CDs virtuais, é possível capturar imagens de disquetes.

Fonte: http://blogdovicente.com

Este dias eu mostrei as vantagens de utilizar o VMware ESXi no seu datacenter. Hoje eu vou mostrar como instalá-lo. Para este tutorial foi utilizado um servidor Dell PowerEdge 2950 com 4GB de RAM e 2 processadores Xeon Dual Core 1.6 GHz. As telas foram capturadas pela console remota provida pela DRAC do servidor.

Baixe o software e registre-se no site da VMware.

Queime a imagem em um CD, coloque do drive e reinicie o servidor.

Quando a tela abaixo aparecer tecle Enter para instalar:

Pressione F11 para aceitar a licença e continuar o processo de instalação:

Escolha o disco que quer instalar o VMware ESXi. IMPORTANTE: Não é possível utilizar Dual Boot, uma vez que você escolha a partição que quer instalar, todos os dados que estiverem lá serão perdidos:

Tecle Enter para excluir as partições existentes no disco:

Tecle F11 para começar a instalação:

Aguarde os arquivos serem copiados:

Depois de instalado tecle Enter para reiniciar o servidor:

Aguarde:

Uma vez iniciado, o ESXi está disponível para uso. Eu não gosto de deixar servidores utilizando IP da rede DHCP. Eles podem mudar e você precisaria ir lá na frente do servidor para descobrir que IP ele pegou. Para tanto, vamos configurar um a rede do servidor. Tecle F2 para alterar as configurações do servidor:

Selecione a opção abaixo e tecle Enter para criar uma senha para o usuário root:

Digite uma senha, de preferência bem complexa, confirme e tecle Enter para continuar:

Selecione a terceira opção na tela inicial de configuração para configurar a rede:

Selecione a opção IP Configuration e na tela que abrir configure para utilizar IP estático e preencha o IP, máscara e Gateway e tecle Enter para continuar:

Na tela de configuração de rede, selecione a opção DNS Configuration, preencha os servidores DNS da sua rede e preencha o nome do servidor que está configurando e tecle Enter:

Tecle Esc para voltar à tela inicial e selecione a opção Restart Network Management para efetivar as alterações que foram feitas:

Tecle F11 para continuar:

Pronto! Tecle Enter para continuar e tecle Esc para sair do utilitário de configuração:

Uma vez configurado o seu servidor, abra um browser no seu micro, faça download e instale o software cliente:

Fonte: http://blogdovicente.com

O vírus chamado de Rootkit se instala no computador de um jeito completamente invisível para abrir acesso irrestrito aos seus dados, por isso o nome “root” que vem do termo utilizado em acesso privilegiado nos sistemas Unix, com a palavra kit do software ou componente instalado.

O Rootkit para ser instalado no seu computador precisa explorar alguma vulnerabilidade do navegadortal como o Internet Explorer, e depois de instalado ele permite que o atacante acesse todos seus dados de forma invisível. O Rootkit pode ser também chamado de Malware mas é mais complicado do que este de ser detectado por anti-vírus comuns do mercado.

Para quem tem o computador realmente infectado, uma boa solução é baixar o CD de boot Disk Rescue 10 da Kaspersky. Mas você precisa de um computador funcionando para poder gravar no CD o arquivo ISO que irá baixar.

Como Remover Rootkit do Computador?

Para detectar e remover um rootkit você precisa de um bom anti-vírus como o Kapersky, mas que é mais caro, ou então utilizar de ferramentas específicas para este típo de vírus. Vou listar aqui algumas ferramentas grátis que podem ser encontradas na internet.

1. RootkitRevealer: Uma avançada ferramenta de detecção para Windows XP (32-bit) e Windows Server 2003 (32-bit) que monta uma lista de discrepâncias encontradas no registro do sistema operacional assim como em outras bibliotecas do Windows. O RootkitRevealer é parte da própria Microsoft e está hospedado no site technet.

Baixar Rootkit Revealer

2. TDSSKiller by Kaspersky: Criado pela empresa Kaspersky, mesma que desenvolve um dos melhores antivírus, o TDSSKiller encontra rootkits que nenhum outro programa pode encontrar como da família rootkit.win32.tdss e também do tipo bootkits (MBR).

Baixar TDSSKiller

3. Sophos Anti-Rootkit: Um dos mais avançados e completos programas de remoção de rootkit, o Sohos tem uma interface fácil e simples de usar. Ele tem a vantagem de ser grátis e ser compatível desde o Windows 2000, XP, Vista até com o Windows 7 e Server, inclusive plataformas 64-bits.

Baixe Sophos Anti-Rootkit

Fonte: http://www.gusleig.com

Depois de apresentar a configuração do Apache, PHP, APC e Memcached na primeira parte, agora é hora do Nginx. Basicamente, vamos utilizar o Nginx para servir apenas conteúdo estático (imagens, css, javascript, etc), pois ele possui recursos que garantem uma boa performance para este fim, como por exemplo usar o Memcached como cache. Quando ele recebe uma requisição para processar um arquivo PHP, ele “passa a bola” para o Apache, servindo também como um proxy. Fica mais fácil de entender olhando o fluxo abaixo:

                                PHP
requisição --> [Nginx] ------------> [Apache] ---> (PHP + APC)
                  |
                  |
                  |
                  | conteúdo estático
                  | (imagens, js, css, etc)
                  |
            (Memcached)

Após o famoso comando apt-get install nginx, devemos editar os arquivos de configuração e acertar os detalhes para que tudo isso aí em cima funcione corretamente. Vamos começar pelo arquivo /etc/nginx/nginx.conf, onde estão as configurações globais:

Não há muito segredo, principalmente se você já mexeu com os arquivos de configuração de outros web servers, como o Apache. O próximo passo agora é a configuração do virtual server, onde ficam os detalhes mais importantes. O arquivo para configuração do virtual server default é o /etc/nginx/sites-enabled/default:

Após acertar as configurações, reinicie o daemon do Nginx com o comando /etc/init.d/nginx restart. Podemos conferir o benchmark usando o Apache Benchmark:

Fonte: http://www.bragil.net/

A seguir vou detalhar o passo-a-passo resumido da configuração usada, que eu apelidei carinhosamente de NAPALM (sigla para Nginx + Apache + PHP + APC + Linux + Memcached).

Nginx é um servidor web que tem ganhado fama por ser extremamente rápido e também por ser uma excelente escolha para servir conteúdo estático, sendo usado como proxy para servidores de aplicação.

O Apache dispensa apresentações, assim como o PHP.

O APC é uma extensão para o PHP que otimiza o código intermediário e mantém um cache dos dados e do código compilado na memória compartilhada. Isto faz aumentar sensivelmente a performance de aplicações PHP.

O Memcached é um sistema de cache em memória de alta performance, bastante usado por grandes nomes da Internet, como Twitter, Flickr, Wikipedia, Youtube, dentre outros.

Quer performance para sua aplicação PHP? Basta misturar isso tudo!! E o melhor, a configuração é tranquila.

Para começar, instale o Apache 2 e o PHP 5. Não vou abordar a instalação e configuração do servidor Apache 2 + PHP 5, pois basta ir no Google, você encontrará bastante coisa.

Configuração do Apache

Depois do Apache + PHP instalados e configurados, altere a porta onde o Apache receberá as conexões para 8080. No Debian, edite as seguintes linhas do arquivo /etc/apache2/ports.conf para o seguinte:

E altere também a porta na configuração do virtual host:

Isto significa que o Apache deixará de atender as requisições na porta 80 (padrão). Ou seja, usaremos o Apache apenas para processar os arquivos PHP, deixando todo o conteúdo estático (imagens, javascript, css, etc) para o Nginx.

Reinicie o servidor Apache. No Debian, o comando é /etc/init.d/apache2 restart.

Instalação e Configuração do APC

Agora é a instalação do APC. No Debian 5, isso é extremamente simples:

Após instalar, edite o arquivo /etc/php5/conf.d/apc.ini, adicionando as seguintes linhas:

É possível configurar vários parâmetros, consulte a documentação do APC.

Para a nova configuração surtir efeito, reinicie o Apache:

Instalação e Configuração do Memcached

Após a instalação, edite o arquivo /etc/memcached.conf. Geralmente não é necessário mudar muita coisa, a não ser o tamanho máximo da memória para o Memcached (o default é 64 MB). O Memcached usa a porta 11211 por padrão, mas também é possível mudar. O arquivo de configuração vem todo comentado, não há segredo.

Para alterar o tamanho do espaço de memória, altere a linha -m 64 para o quanto for necessário (128, 256, 512, 1024,…). Lembrando que o Memcached só ocupa o espaço de memória que estiver em uso pelo cache, ele não reserva todo o espaço inicialmente. Feita a configuração, reinicie o daemon do Memcached com o comando:

/etc/init.d/memcached restart

Agora só falta o Nginx.

Instalação do Nginx

Adivinhem?

Vamos abordar a configuração em um outro artigo. Até lá, que tal dar uma olhada nos arquivos de configuração do Nginx, em /etc/nginx ? Bons estudos!

Fonte: http://www.bragil.net/

Um problema que enfrentava sempre que colocava um aplicativo utilizando o MySQL é o tamanho sempre crescente do arquivo /var/lib/mysql/ibdata1. Este arquivo armazena as tableas do tipo InnoDB e, mesmo que os dados sejam removidos ou elimine tabelas e, até mesmo, banco de dados, o tamanho do ibdata1 não diminui, o que pode ocasionar problemas de espaço em disco mais para frente.

O programa tune2fs pode adicionar um journal em um sistema de arquivo ext2 existente sem alterar os dados já contidos na partição. Se o sistema de arquivo já está montado ao ser transicionado, o journal será visto como o arquivo .journal no diretório raiz do sistema de arquivo. Se o sistema de arquivo não está montado, o journal será escondido e não aparecerá de modo algum no sistema de arquivo.

Para converter um sistema de arquivo ext2 para ext3, autentique-se como root e digite:

/sbin/tune2fs -j /dev/hdbX

No comando acima, substitua /dev/hdb pelo nome do dispositivo e X pelo número da partição.

Após fazer isso, certifique-se de alterar o tipo de partição de ext2 para ext3 no /etc/fstab.

Se você está transicionando seu sistema de arquivo root, terá que usar uma imagem initrd (ou disco RAM) para inicializar a máquina. Para criá-la, execute o programa mkinitrd. Para informações sobre o uso do comando mkinitrd, digite man mkinitrd. Também certifique-se de que a configuração de seu GRUB ou LILO carregue o initrd.

Se você não conseguir executar esta alteração, o sistema ainda inicializará, mas o sistema de arquivo será montado como ext2 ao invés de ext3.