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.

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/

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/

O PgFouine é um gerador de relatório para os logs do banco PostgreSQL, criado pela pgFoundry. Ele segue a licença para distribuição GNU.

Esse tutorial foi confeccionado baseado na plataforma BSD. Sendo assim, haverão algumas diferenças nas localidades dos arquivos de configurações do Apache e PostgreSQL, que pode variar conforme a distribuição.

Instalação

Afim de instalar a última versão, pegaremos o arquivo direto do site do PgFouine.

Download:

Faça o wget para um local que você tenha permissão de escrita e descompacte o arquivo.

# wget http://pgfoundry.org/frs/download.php/2178/pgfouine-1.1.tar.gz
# tar -zxvf pgfouine-1.1.tar.gz

Obs.: Verifique se existe uma versão mais atual no site do PgFouine antes de baixar.

Configuração

Mova a pasta/diretório gerada(o) para /usr/local/.

# mv pgfouine-1.1 /usr/local/pgfouine

Crie um link simbólico para você poder executá-lo em seu PATH:

# ln -s /usr/local/pgfouine/pgfouine.php /usr/local/bin/

Referência:

• http://pgfouine.projects.postgresql.org/tutorial.html

Preparação do ambiente

Antes de executar o comando para a geração dos relatórios faremos algumas customizações necessárias.

Logs do PostgreSQL

O PgFouine requer um padrão nos logs dos PostgreSQL.

Edite o arquivo postgresql.conf:

# vi /usr/local/pgsql/data/postgresql.conf

Adicione o seguinte conteúdo no Grupo ERROR REPORTING AND LOGGING:

Reinicie o PostgreSQL:

# /usr/local/etc/rc.d/postgresql restart

Disponibilização dos logs:

Para a disponibilização web usaremos o Apache e um alias para que você possa permitir somente para o IP que necessite.

Edite o arquivo httpd.conf (estou deduzindo que você tem a última versão do Apache):

# vi /usr/local/etc/apache22/httpd.conf

Adicione o seguinte conteúdo:

Crie a pasta dentro do diretório do Apache:

# mkdir /usr/local/www/analizer/

Obs.: Pode-se utilizar qualquer pasta contanto que você altere PATH no alias do httpd.conf do Apache.

Reinicie o Apache:

# apachectl restart

Gerando os relatórios:

Agora é só executar o pgfouine para a geração dos relatórios:

# pgfouine.php -file /var/log/pgsql/postgresql-(Data) > /usr/local/www/analizer/relatorio.html -debug -logtype stderr’

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

I. Editando as configurações do banco

Edite o arquivo postgresql.conf:

# vi /usr/local/pgsql/data/postgresql.conf.

Altere as sentenças nos seguintes grupos para:

Crie uma pasta para armazenar os logs e após altere suas permissões:

# mkdir /var/log/pgsql
# chmod -R 775 /var/log/pgsql
# chown -R pgsql:pgsql /var/log/pgsql

II. Adicionando Segurança

Edite o arquivo pg_hba.conf para liberação de acesso externo ao banco:

# vi /usr/local/pgsql/data/pg_hba.conf

Caso outro servidor ou rede precise, acesse esse banco, adicione os IPs dos mesmos no grupo IPv4 local connections (Não retirar a permissão do 127.0.0.1).

Segue o formato:

a) liberação para de uma rede especifica:

b) liberação para um determinado IP:

III. Crie um usuário no banco para acessar ao banco

Para aumentar a segurança usaremos um usuário próprio no banco de dados:

# createuser -U pgsql (nome do usuário que você quer criar) -W

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

(Por Pedro Ortale Neto) – Percebendo a falta de documentos relativos a Detecção de Intrusos em Portugues, escrevi este artigo (O primeiro de uma série), tratando da teoria básica sobre IDS e o uso de uma ferramenta para deteccao e check de integridade de arquivos, o tripwire, assim como detecção em Rede, usando o Snort. Em breve estarei publicando novo artigo, só que aprofundado ao IDS em rede, utilizando como base o SNORT & PortSentry. 
INTRUSION DETECTION SYSTEMs
———————————————-
Pedro Ortale Neto < ortale@unsecurity.com.br >
Unsecurity Systems

http://www.unsecurity.com.br

A internet hoje é um veículo imenso para disseminação do comércio,
quebra de barreiras entre povos e nações e ao mesmo tempo, um meio
de acesso de grande valia na mão de vândalos virtuais.
Existe uma necessidade muito grande para que o mercado que circula
por meio da Internet funcione e seja confiável: Segurança. Existem
inúmeras ferramentas para que o grau de segurança seja um pouco
mais elevado, porém, o único sistema realmente seguro é aquele que
não está conectado a nenhuma rede. Sendo assim, uma solução
obrigatória para qualquer rede que circula dados de missão crítica
é um Sistema IDS, Intrusion Detection System.

Existem pelo menos dois tipos de IDS:

* Deteção de Invasão em Host
* Deteção de Invasão em Rede

DETECÇÃO DE INVASÃO EM HOST
—————————

É importante realçar que um sistema de detecção de invasão eficaz não
é aquele que simplesmente registra dados em um sistema que está
sofrendo ataque, mas sim aquele que ao perceber qualquer anormalidade
na rede inicia uma série de procedimentos que possam impedir o ataque
ou minimizar as perdas.
O sistema de deteção de invasão em host é geralmente útil para
detectar ataques já consagrados e localizar aquivos modificados com a
intenção de abrir portas para futuro uso do host, seja como ponte
de ataque para outras redes, capturar os dados da rede interna ou
simplesmente alterar aquivos vitais do host.

A primeira ferramenta que usaremos de exemplo é o TripWare, da
Tripwire (R) Security Systems, Inc.

INSTALANDO O TRIPWARE
———————

Faça o download do Tripwire em: http://www.tripwire.com/downloads/

Crie um diretório e mova o arquivo .tar.gz para dentro

# mkdir tripwire
# cp Tripwire_221_for_Linux_x86.tar.gz tripwire

Descompresse o arquivo e em seguida execute a instalação

# tar zxpvf Tripwire_221_for_Linux_x86.tar.gz
#./install.sh

Leia e aceite a licença de uso (é preciso rolar até o fim e digitar
accept). Em seguida, a instalação iniciará após confirmação dos
diretórios de destino.

O TripWare baseia-se em guardar informações sobre estrutura dos
arquivos em seus sistema, sendo assim, para garantir a integridade do
índice de verificação dos arquivos, são usadas duas frases, uma para
a chave do SITE e outra para LOCAL, respectivamente.
Escolha a Frase, lembrando que quanto mais diversos caracteres você
colocar, mais difícil de descriptografar esse arquivo será, impedindo
o cracker de modificar seu sistema e alterar também os indices do IDS.

Após você digitar as frases, o Tripwire cria uma política padrão e
para acessá-la, você deve digitar novamente as frases.

Inicie o tripwire para criar um banco de dados primário

#cd /usr/TSS/bin
#./tripwire –init

Em seguida, digite sua senha/frase de acesso LOCAL. Alguns erros de
aquivos não encontrados poderão surgir, mas é uma etapa normal. Os
erros serão corrigidos nos procedimentos descritos logo mais abaixo.

Antes de atualizar o banco de dados de arquivos, primeiramente,
procure por todos os arquivos setuid/setgid e grave a lista em um
arquivo de log. Estes arquivos fornecem privilégios especiais ao
usuário que esta executando o mesmo, sendo assim esses arquivos podem
ser usado paraaccessar partes restritas do sistema.

# find / -type f -perm +6000 -ls >> setgiduid.log

É bom monitorar arquivos que possuem permissão de gravação configurada
para todos usuários e arquivos que nao possuem dono ou grupo. Grave a
lista em um arquivo de log

# find / -perm -2 ! -type l -ls >> todosrwx.log
# find / -nouser -o -nogroup >> sem.log

A partir de agora, você tem uma lista de arquivos potênciais em relação
a segurança, o próximo passo é adicioná-los no arquivo de políticas

# joe /usr/TSS/policy/twpol.txt (Use o editor de texto de sua preferência)

Procure por:

setuid/setgid root programs
(rulename = “setuid/setgid”, severity = $(SIG_HI))
{

Apague todas as linhas entre os dois colchetes ( { & } ) e adicione toda a
lista dos arquivos setgid/uid, respeitando a seguinte sintaxe:

/caminho/do/arquivo -> $(SEC_SUID);

Exemplo:

{
/usr/X11R6/bin/Xwrapper -> $(SEC_SUID);
/usr/X11R6/bin/xterm -> $(SEC_SUID);
/usr/X11R6/bin/xhextris -> $(SEC_SUID);
/usr/X11R6/bin/kterm -> $(SEC_SUID);
/usr/X11R6/bin/XConsole -> $(SEC_SUID);
}

Configure todas as partes do arquivo de configuração conforme seu sistema,
assim como arquivos de shells, configurações, segurança e diretórios de
arquivos temporários.

Atualize o arquivo de políticas e em seguida Entre com a sua password/frase
do Site, em seguida atualize o banco de dados de arquivos do tripwire:

# ./twadmin -m p ../policy/twpol.txt
# ./tripwire –init

Para verificar a Integridade dos arquivos, simplesmente digite:

# ./tripwire –check

Todas as modificações nos arquivos configurados são informadas.

Recomendo que os arquivos de configuração sejam gravados em uma mídia não
regravável, assim como um cd-rom, sendo assim jamais os dados do índice
poderão ser alterados.

Para maiores informações sobre o uso do tripwire, consulte a documentação.

DETECÇÃO DE INVASÃO EM REDE
—————————

Detecção de invasão em redes não é uma tarefa fácil, depende de muita
análise, às vezes a nível de protocolo e muito conhecimento técnico,
mas não é por isso que o administrador deve se desencorajar, pelo
contrário, faça experiências, experimente produtos e simule ataques
para maior compreensão dos dados obtidos por programas dessa classe.

Utilizaremos dois softwares para detecção de intrusão (Ou tentativa
de intrusão), PortSentry, da Psionic e o Snort.

INSTALAÇÃO E USO DO PORTSENTRY
——————————

Faça o download de http://www.psionic.com/tools/portsentry-1.0.tar.gz,
descompresse, compile e instale a distribuição:

# tar zxpvf portsentry-1.0.tar.gz
# cd portsentry-1.0
# ./configure
# make
# make install

O Portsentry será instalado no diretório /usr/local/psionic/portsentry

Basicamente, o portsentry opera em quatro modos (Plataforma Linux)

- Simples Detecção de Portas TCP
# ./portsentry -tcp
- Simples Detecção de Portas UDP
# ./portsentry -udp
- Detecção de Stealth Portscan TCP
# ./portsentry stcp
- Detecção de Stealth Portscan UDP
# ./portsentry sudp

Para maiores informações sobre configuração/instalação do portsentry,
leia o texto de Renato Murilo Langona:

http://www.linuxsecurity.com.br/renato/antiscan.html

INSTALAÇÃO E USO DO SNORT
————————-

Antes de iniciar a instalação do software, precisamos planejar como
o Snort será instalado, respondendo algumas questões simples:

A máquina é dedicada?
A máquina possui uma ou mais placas de rede?
Qual o Sistema Operacional?

O modo mais simples de instalar o Snort é uma máquina dedicada, com uma
placa de rede e Linux, porém, o recomendado é uma máquina dedicada com
duas placas de rede, então vamos la…

Quando se trata de duas placas de redes no Snort, uma é usada em modo
Promíscuo, ou seja, agindo com um sniffer e outra como porta para
administraçào remota (Via outra máquina na rede interna).
Sendo assim, teremos o seguinte diagrama:

[ADMINISTRATIVO]——–[SNORT]—–INTERNET
| |
[COMP 1] [DMZ]
|
[COMP 2]

Após escolhermos esse modelo de implantação, iniciaremos a instalação

Puxe e instale o pacote para RedHat em:

http://www.linuxsecurity.com/programs/snort-1.6.2.2-1.i386.rpm

# rpm -i snort-1.6.2.2-1.i386.rpm

Após instalar via RPM, é nescessário configurar algumas definições no
arquivo /etc/snort/rules.base

Será algo parecido com:

var INTERNAL 192.168.1.0/24
var EXTERNAL 63.87.101.0/24
var DNSSERVERS 63.87.101.90/32 63.87.101.92/32

Substitua usando os dados de sua rede, lembre-se de adicionar os hosts
confiáveis no arquivo rules.base respeitando o formato abaixo:

preprocessor portscan-ignorehosts: 63.87.101.90/32 63.87.101.92/32

Adicione no arqivo /etc/passwd:
snort:x:201:201:Snort:/etc/snort:/bin/false

e no arquivo /etc/group
snort:x:201:

Teste a configuração pelo comando abaixo;

# snort -d -l /var/log/snort -c /etc/snort/rules.base

Irá resultar em algo parecido com:

Initializing Network Interface…
User level filter, protocol ALL, raw packet socket
Decoding Ethernet on interface eth0
Initializing Preprocessors!
————————————————-
Keyword | Preprocessor @
————————————————-
http_decode : 0×8053070
minfrag : 0×8053290
portscan : 0x8053ce0
portscan-ignorehosts: 0×8054340
————————————————-

Initializing Plug-ins!
————————————————-
Keyword | Plugin Registered @
————————————————-
content : 0×8052050
offset : 0×8052080
depth : 0x80520f0
nocase : 0×8052160
flags : 0×8052710
itype : 0x80528f0
icode : 0x8052a00
ttl : 0x8052b10
id : 0x8052bf0
ack : 0x8052cd0
seq : 0x8052dc0
dsize : 0x8052ec0
ipopts : 0×8054420
rpc : 0×8054670
icmp_id : 0×8054830
icmp_seq : 0×8054930
session : 0×8055300
————————————————-

Initializating Output Plugins!
————————————————-
Keyword | Output @
————————————————-
alert_syslog : 0x8054a20
log_tcpdump : 0x8054ff0
————————————————-

+++++++++++++++++++++++++++++++++++++++++++++++++++
Initializing rule chains…
255 Snort rules read…
255 Option Chains linked into 140 Chain Headers
+++++++++++++++++++++++++++++++++++++++++++++++++++

Performing Rule List Integrity Tests…
—————————————
Alert TCP Chains : OK
Alert UDP Chains : OK
Alert ICMP Chains : OK
Log TCP Chains : Empty list…
Log UDP Chains : Empty list…
Log ICMP Chains : Empty list…
Pass TCP Chains : Empty list…
Pass UDP Chains : Empty list…
Pass ICMP Chains : Empty list…
—————————————

-*> Snort! <*-
Version 1.6
By Martin Roesch (roesch@clark.net, www.clark.net/~roesch)

Pressione Control + C para cancelar

A partir de agora você pode usar o Daemon pelo comando:

# /usr/sbin/snort -s -d -D -i eth0 -l /var/log/snort
-c /etc/snort/rules.base

ou

#./etc/rc.d/init.d/snortd start

Exemplificando um portscan: (Onde Hacker é o host de quem ataca)

[HACKER]#nmap -p 25,53 -sX -P0 -D 1.2.3.4,5.6.7.8 192.168.200.189

Starting nmap V. 2.54BETA1 by fyodor@insecure.org (www.insecure.org/nmap/)
Interesting ports on smtp.mydomain.com (192.168.200.189):
Port State Service
25/tcp open smtp
53/tcp open domain

Nmap run completed — 1 IP address (1 host up) scanned in 19 seconds

No host do snort (/var/log/snort/portscan.log)

Jun 18 15:57:52 krypton snort[9131]: spp_portscan: PORTSCAN DETECTED from
1.2.3.4
Jun 18 15:57:52 krypton snort[9131]: spp_portscan: PORTSCAN DETECTED from
5.6.7.8
Jun 18 15:57:58 krypton snort[9131]: spp_portscan: portscan status from
192.168.1.100: 2 connections across 1 hosts: TCP(2), UDP(0) STEALTH
Jun 18 15:57:58 krypton snort[9131]: spp_portscan: portscan status from
1.2.3.4: 2 connections across 1 hosts: TCP(2), UDP(0) STEALTH
Jun 18 15:57:58 krypton snort[9131]: spp_portscan: portscan status from
5.6.7.8: 2 connections across 1 hosts: TCP(2), UDP(0) STEALTH

CONCLUSAO
———

Este artigo foi apenas uma demonstração sobre os dois tipos de
sistemas IDS, o de Host e o de Network, exemplificando o emprego
de 3 aplicações de excelência (Tripwire, PortSentry & Snort).
Estas ferramentas ajudam o administrador a posicionar-se diante
a ataques que muitas vezes não sabem que siquer ocorrem. Este
é o primeiro de uma série de artigos exclusivos para a o site
Linuxsecurity Brasil sobre a área de Detecção de Intrusão, em
breve os principais utilitários em IDS serão comentados. Até lá.

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

Dicas sobre Desempenho e Otimizações do PostgreSQL

Existem duas principais formas de melhorar o desempenho de SGBDs: uma é melhorando o hardware, com CPUs, RAM, Discos mais novos, rápidos e confiáveis. A outra é otimizando as consultas realizadas nos bancos (usando VACUUM, VACUUM ANALYZE, EXPLAIN, criando CLUSTERS, entre outros).
Uma das medidas básicas adotada para melhorar o desempenho de tabelas com grandes quantidades de registros e especialmente com muitos acessos, é a inclusão de índices estratégicos. Além da chave primária é importante inserir índices em campos que compõem a cláusula WHERE, que fazem parte de cláusulas ORDER BY, GROUP BY entre outras. Em consultas com WHERE de vários campos usando OR, não adianta inserir índice, pois não será utilizado pelo PostgreSQL, somente usando AND.

Na criação do banco de dados e especialmente na criação das consultas é muito importante atentar para um bom planejamento, normalização, consultas otimizadas tendo em vista o planejador de consultas do PostgreSQL através do uso dos comandos EXPLAIN e ANALYZE.

A administração do PostgreSQL também é muito importante para tornar o SGBD mais eficiente e rápido. Desde a instalação e configuração temos cuidados que ajudam a otimizar o PostgreSQL.

Adaptação do Artigo sobre otimização do PostgreSQL do Diogo Biazus e do original do Bruce Momjian (http://www.ca.postgresql.org/docs/momjian/hw_performance).

Hardware

No computador as informações são manipuladas pelos registradores da CPU, pelo cache da CPU, pela memória RAM e pelos discos rígidos.

Na prática as informações utilizadas com mais freqüência são colocadas próximas à CPU. Quem determina que informações devem ficar nos registradores são os compiladores. Cache da CPU guarda ar informações utilizadas recentemente. O Sistema Operacional controla o que está armazenado na RAM e o que mandar para o disco rígido.
Cache e Registradores da CPU não podem ser otimizados diretamente pelo administrador do SGBD. Efetivamente otimização em bancos de dados envolvem aumento da quantidade de informações úteis na RAM, prevenindo acesso a disco sempre que possível.

Não é tarefa simples de ser colocada em prática, pois a memória RAM guarda muitas outras informações: programas em execução, pilhas e dados de programas, memória cache compartilhada do PostgreSQL, cache do buffer de disco do kernel e kernel.

Otimização correta de bancos de dados procura manter a maior quantidade possível de informações do banco na memória RAM ao mesmo tempo que não afeta as demais áreas do sistema operacional.

Existem dois tipos de configuração de memória no PostgreSQL, a compartilhada e a individual. A compartilhada tem um tamanho fixo, ela é alocada sempre que o PostgreSQL inicializa e então é compartilhada por todos os clientes. Já a memória individual é tem um tamanho variável e é alocada separadamente para cada conexão feita ao SGBD.

Memória Cache Compartilhada do PostgreSQL

O PostgreSQL não altera as informações diretamente no disco. Ao invés disso ele solicita que os dados sejam lidos da memória cache compartilhada do PostgreSQL. O cliente PostgreSQL então lê e escreve os blocos e finalmente escreve no disco.

Clientes que precisam acessar tabelas primeiro procuram pelos blocos necessários no cache. Caso estejam aí então continuam processando normalmente. Caso contrário é feita uma solicitação ao sistema operacional para carregar os blocos. Os blocos são carregados do cache de buffer de disco do kernel ou diretamente do disco. Estas operações podem ser onerosas (lentas).

Na configuração default do PostgreSQL 8.1.3 ele aloca 1000 shared buffers. Cada buffer usa 8KB, o que soma 8MB.

Aumentando o número de buffers fará com que os clientes encontrem as informações que procuram em cache e evita requisições onerosas ao sistema operacional. Mas cuidado, pois se aumentar muito a memória compartilhada (shared buffers) pode acarretar uso da memória virtual (swap). As alterações podem ser feitas através do comando postmaster na linha de comando ou através da configuração do valor do shared_buffers no postgresql.conf.

Que Porção da RAM Reservar para o PostgreSQL?

A maior porção útil que não atrapalhe os outros programas. Nos sistemas UNIX as informações saem da RAM (quando insuficiente) para o swap. Ruim é quando as informações voltam do swap para a RAM, pois então os programas são suspensos até que as mesmas sejam carregadas.

Tamanho da Cache

Imaginemos que o PostgreSQL shared buffer cache seja suficiente para manipular uma tabela inteira. Repetidas buscas seqüenciais da tabela não devem necessitar de acesso ao disco já que todos os dados já estão em cache. Agora vamos imaginar que o cache é menor que a tabela, então neste caso as informações irão para o disco (swap) e terão um desempenho bem inferior. Tamanho Adequado da Shared Buffer Cache

Idealmente a PostgreSQL shared buffer cache (Memória Cache Compartilhada do PostgreSQL) deve ser:

Grande o suficiente para conseguir manipular as tabelas mais comumente acessadas. Pequena o bastante para evitar atividades de swap pagein.

Exemplo:

Por exemplo queremos x MB para memória compartilhada ( x / 8 ) * 1024 = Resultado a ser configurado em shared_buffer

Se x = 768 MB

(768 / * 1024

Resultado a ser configurado em shared_buffer = 98304

Para informações sobre uma configuração do kernel para que vários sistemas operacionais trabalharem com o

PostgreSQL:

http://developer.postgresql.org/docs/postgres/kernel-resources.html

Memória Individual (Sort Memory)

Principalmente utilizada em ordenações de registros das tabelas, em operações de criação de índices, ordenação (order by), merge join, etc.

Esta memória pode ser configurada através do parâmetro sort_mem do postgresql.conf.

Para a configuração leve em conta sua memória disponível (incluindo a memória já alocada para o shared buffers), também o número médio de conexões e o uso da memória virtual (swap).

Exemplo:

Considerando um servidor dedicado (rodando somente o servidor PostgreSQL), com memória RAM de 1,5GB e com até 10 conexões simultâneas com o SGBD:

shared_buffers = 80000 # 80.000 blocos de 8KB = 625 MB

sort_mem = 64000 # tamanho em KB = 62,5 MB, para cada usuário com

# 10 usuários = 526 MB

vacuum_mem = 2000

Por exemplo: queremos x KB para memória individual sort_men

( x * 1024 ) = resultado para memória individual
x = 16
(16 * 1024) = sort_mem = 16384

Seria bom mudar também memória para vaccum

vacuum_mem = 131072 (mesmo cálculo do sort_mem)

Uso de Vários Discos

Em sistemas com mais de um disco podemos melhorar a performance do mesmo distribuindo algumas tarefas entre discos diferentes.

Supondo que temos dois HDs, hda e hdb:

Movendo os logs de transação para outro disco:

- Parar o PostgreSQL

- Montar hdb em /mnt/hdb

- Mover a pasta /usr/local/pgsql/data/pg_xlog para o /mnt/hdb

- Criar um link simbólico para o diretório original:

     ln -s /mnt/hdb/pg_xlog /usr/local/pgsql/data/pg_xlog

- Banco – /usr/local/pgsql/data (no hda)

- Logs – /usr/local/pgsql/data/pg_xlog (link simbólico para /mnt/hdb/pg_xlog).

Os logs de transação são os únicos registros que não podem ter o seu salvamento em disco adiado sem comprometer a segurança do sistema.

Mover os índices para um HD diferente de onde estão as tabelas:

- Parar PostgreSQL

- Mover os índices para o hdb

- Criar link simbólico para o local original

Para recriar os índices em outro Tablespace:

ALTER TABLE nometabela DROP CONSTRAINT nomeconstraint;
CREATE INDEX nome_idx ON nometabela (nomecampo) TABLESPACE nometablespace;

ALTER TABLE nometabela ADD CONSTRAINT nome_pk PRIMARY KEY (nomecampo);
ALTER INDEX nome_idx SET TABLESPACE nometablespace;

Ainda podemos separar astabelas mais utilizadas para o hdb, utilizando o comando tablespace no PostgreSQL 8.1.3 podemos fazer isso:

- Criar diretório /mnt/hdb/hotcluster e tornar postgres seu dono

CREATE TABLESPACE hotcluster OWNER postgres LOCATION ‘/mnt/hdb/hotcluster’;

Criando um banco no novo cluster:

CREATE DATABASE hotbanco TABLESPACE = hotcluster;

Exportar as tabelas para este banco.

Uso de Mais de Um Processador

Atualmente o PostgreSQL está otimizado para uso de vários processadores, reforçando que cada conexão é gerenciada por um processo diferente.

Sistemas de Arquivos

Para sistemas BSD usa-se o tradicional UFS, que é robusto, rápido e tem a vantagem em relação ao PostgreSQL, de possuir os blocos de disco com um tamanho padrão de 8KB.

Para quem utiliza Linux as sugestões vão para EXT3 e ReiserFS.

Checkpoints

O wal_files é o parâmetro do postgresq.lconf que determina o número de arquivos usados pelo PostgreSQL para armazenar os logs de transação. Estes arquivos focam em pg_xlog, na pasta de dados.

Para que apareçam as datas e horas nos arquivos de logs usa-se no postgresql.conf:

log_timestamp = true

Para reduzir a freqüência dos checkpoints devemos aumentar o parâmetro do postgresql.conf:

checkpoint_segments = 3 (valor default)

O PostgreSQL não precisa de muito ajuste. Boa parte dos parâmetros é automaticamente ajustada para uma performance ótima. O cache size e sort size são dois parâmetros que o administrador pode controlar para ter um melhor uso da memória.

Tradução do Tutorial “Tuning PostgreSQL for Performance”

De Shridhar Daithankar e John Berkus

Shared Buffers

Definem um bloco de memória que o PostgreSQL usará para lidar com requisições que estão aguardando atenção no buffer do kernel e na CPU.

Deve ser manipulada com cuidado, pois simplesmente ampliada pode prejudicar a performance. Esta é a área que o

PostgreSQL usa atualmente para trabalhar. Ela deve ser suficiente para controlar a carga do servidor do SGBD, do contrário o PostgreSQL irá iniciar empurrando dados para arquivos e isto irá prejudicar a performance geral. Esta é a principal configuração em termos de performance.

Seu valor deve ser configurado tendo em vista o tamanho do conjunto de bancos que se supões que no máximo o servidor irá carregar e da memória RAM (ter em mente que a memória RAM utilizada pelos demais aplicativos do servidor não estarão disponíveis).

Recomendações:

- Iniciar com 4MB (512) Workstation

- Médio tamanho do conjunto de bancos de dados e 256 a 512MB disponível de RAM: 16-32MB (2948 a 4096)

- Grande conjunto de bancos de dados e muita memória RAM disponível (1 a 4GB): 64 -256MB (8192 a 32768)

Obs.: Até para um conjunto de bancos de dados (dataset) que exceda 20GB, uma configuração de 128MB deve ser muito, caso você tenha apenas 1GB de RAM e um agressivo sistema de cache em Sistema Linux.

Sort Memory (Memória para Ordenação)

Limite máximo de memória que uma conexão pode usar para executar sort (ordenação). Caso suas consultas usem as cláusulas ORDER BY ou GROUP BY que ordenem grandes conjuntos de dados, incrementar este parâmetro deverá ajudar.

Uma Recomendação:

Ajustar o parâmetro por conexão como e quando precisar: pouca para consultas mais simples e muita para consultas complexas e para dumps de dados.

Effective Cache Size (Tamanho do Cache Efetivo)

Permite ao PostgreSQL fazer melhor uso da RAM disponível no servidor.

Exemplo:

Caso exista 1,5GB de RAM na máquina, shared buffers deve ser ajustado para 32MB e effective cache size para 800MB.
Fsync and the WAL files (Fsync e arquivos de WAL)

Caso não reste nenhuma opção, poderá usar a proteção do WAL e melhor performance. Simplesmente mova seus arquivos de WAL, montando outro dispositivo ou criando um link simbólico para o diretório pg_xlog, para um disco separado ou para o conjunto dos arquivos do seu cluster principal de arquivos de dados.

random_page_cost (custo de página aleatória)

Configura o custo para trazer um registro aleatório de um banco de dados, que influencia a escolha do planejador em usar index ou table scan.

Caso tenha um disco razoavelmente rápido como SCSI ou RAID, pode baixar o custo para 2.

Vacuum_mem

Configura a memória alocada para Vacuum. Deve acelerar permitindo que PostgreSQL copie grandes quantidades para a memória.

Entre 16-32MB é uma boa quantidade para muitos sistemas.

max_fsm_pages

PostgreSQL grava espaço livre em cada uma de suas páginas de dados.

Caso tenha um banco que usa muitos updates e deletes, que irá gerar registros mortos, devido ao sistema MVCC do PostgreSQL, então expanda o FSM para cobrir todos estes registros deads (mortos) e nunca mais precisará rodar vacuum full a não ser em feriados.

O mínimo FSM é max_fsm_relations * 16.

max_fsm_relations

Diz quantas tabelas devem ser localizadas no mapa de espaço livre.

wal_buffers

Esta configuração decide a quantidade de buffers WAL (Write Ahead Log) que pode ter.

Para chegar a uma quantidade ótima experimente e decida.

Um bom início está em torno de 32 a 64 correspondendo a 256-516 KB de memória.

Ativar o subprocesso do auto Vacuum

Vem desabilitado por defualt (autovacuum = off no 8.1.3). Para ativar edite o arquivo de configuração postgresq.conf e altere para autovacuum = on. Irá executar o vacuum quando necessário.

Melhor é executar o comando vacuum juntamente com o comando analyze:

vacuumdb -U postgres -a, caso seja executado na linha de comando.

Para adquirir informações sobre os índices (tornando a performance ainda melhor):

vacuumdb -U postgres -a -z

EXPLAIN

1. !/usr/bin/perl

$count = 1;

$arquivosaida = “populate.sql”;

@chars = (“A” .. “Z”, “a” .. “z”, 0 .. 9);

@numbers = (1 .. 9);

@single_chars = (“a” .. “e”);

$totalrecords = 5000; # 5 milhões

open(OUTPUT, “> $arquivosaida”);

print OUTPUT “DROP TABLE index_teste;\n”;

print OUTPUT “CREATE TABLE index_teste (“;

print OUTPUT “codigo INT, nome VARCHAR(10), numero INT, letra CHAR(1)”;

print OUTPUT “);\n”;

print OUTPUT “COPY index_teste (codigo, nome, numero, letra) FROM stdin;\n”;

while ($count <= $totalrecords){

   $randstring = join("", @chars [map{rand @chars} ( 1 .. 8 ) ]);

   $randnum = join("", @numbers [map{rand @numbers} ( 1 .. 8 ) ]);

   $randletter = join("", @single_chars [map{rand @single_chars} (1)]);

   print OUTPUT

   #print OUTPUT "INSERT INTO index_teste VALUES($count,'$randstring',$randnum,'$randletter');\n";

   $count."\t".$randstring."\t".$randnum."\t".$randletter."\n";

   $count++;

};

1. print OUTPUT “\n”;

1. print OUTPUT “\nCREATE INDEX indexteste_codigo_index ON index_teste(codigo);\n”;

1. print OUTPUT “CREATE INDEX indexteste_numero_index ON index_teste(numero);\n”;

1. print OUTPUT “VACUUM ANALYZE index_teste;\n”;

close OUTPUT;

Um bom artigo sobre performance no PostgreSQL “PostgreSQL 8.0 Checklist de Performance” encontra-se na revista eletrônica DBFree Magazine, número 02.

Fonte: http://pt.wikibooks.org/

Metadados (Catálogo)

Metadados são dados sobre dados.

Uma consulta normal retorna informações existentes em tabelas, já uma consulta sobre os metadados retorna informações sobre os bancos, os objetos dos bancos, os campos de tabelas, seus tipos de dados, seus atributos, suas constraints, etc.

Retornar Todas as Tabelas do banco e esquema atual

SELECT schemaname AS esquema, tablename AS tabela, tableowner AS dono
 FROM pg_catalog.pg_tables
 WHERE schemaname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
 ORDER BY schemaname, tablename

Informações de Todos os Tablespaces

SELECT spcname, pg_catalog.pg_get_userbyid(spcowner) AS spcowner, spclocation
 FROM pg_catalog.pg_tablespace

Retornar banco, dono, codificação, comentários e tablespace

SELECT pdb.datname AS banco,
 pu.usename AS dono,
 pg_encoding_to_char(encoding) AS codificacao,
 (SELECT description FROM pg_description pd WHERE pdb.oid=pd.objoid) AS comentario,
 (SELECT spcname FROM pg_catalog.pg_tablespace pt WHERE pt.oid=pdb.dattablespace) AS tablespace
 FROM pg_database pdb, pg_user pu WHERE pdb.datdba = pu.usesysid ORDER BY pdb.datname

Tabelas, donos, comentários, registros e tablespaces de um schema

SELECT c.relname as tabela,
 pg_catalog.pg_get_userbyid(c.relowner) AS dono,
 pg_catalog.obj_description(c.oid, 'pg_class') AS comentario, reltuples::integer as registros,
 (SELECT spcname FROM pg_catalog.pg_tablespace pt WHERE pt.oid=c.reltablespace) AS tablespace
 FROM pg_catalog.pg_class c
 LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
 WHERE c.relkind = 'r' AND nspname='public'
 ORDER BY c.relname

Mostrar Sequences de um Esquema

SELECT c.relname AS seqname, u.usename AS seqowner, pg_catalog.obj_description(c.oid, 'pg_class') AS seqcomment,
    (SELECT spcname FROM pg_catalog.pg_tablespace pt WHERE pt.oid=c.reltablespace) AS tablespace
     FROM pg_catalog.pg_class c, pg_catalog.pg_user u, pg_catalog.pg_namespace n
     WHERE c.relowner=u.usesysid AND c.relnamespace=n.oid
     AND c.relkind = 'S' AND n.nspname='public' ORDER BY seqname

Mostrar Tablespaces

SELECT spcname, pg_catalog.pg_get_userbyid(spcowner) AS spcowner, spclocation
 FROM pg_catalog.pg_tablespace

Mostrar detalhes de uma function

SELECT
 pc.oid AS prooid,
 proname,
 lanname as prolanguage,
 pg_catalog.format_type(prorettype, NULL) as proresult,
 prosrc,
 probin,
 proretset,
 proisstrict,
 provolatile,
 prosecdef,
 pg_catalog.oidvectortypes(pc.proargtypes) AS proarguments,
 proargnames AS proargnames,
 pg_catalog.obj_description(pc.oid, 'pg_proc') AS procomment
FROM pg_catalog.pg_proc pc, pg_catalog.pg_language pl
WHERE pc.oid = 'oid_da_function'::oid
AND pc.prolang = pl.oid

Este exemplo mostra uma consulta que lista os nomes dos esquemas, tabelas, colunas e chaves das chaves estrangeiras, e os nomes dos esquemas, tabelas e colunas referenciadas. Exemplo tirado da lista de discussão pgsql-sql

CREATE TEMPORARY TABLE t1 (id SERIAL PRIMARY KEY, nome TEXT);
CREATE TEMPORARY TABLE t2 (id INT REFERENCES t1, nome TEXT);
SELECT
   n.nspname AS esquema,
   cl.relname AS tabela,
   a.attname AS coluna,
   ct.conname AS chave,
   nf.nspname AS esquema_ref,
   clf.relname AS tabela_ref,
   af.attname AS coluna_ref,
   pg_get_constraintdef(ct.oid) AS criar_sql
FROM pg_catalog.pg_attribute a
   JOIN pg_catalog.pg_class cl ON (a.attrelid = cl.oid AND cl.relkind = 'r')
   JOIN pg_catalog.pg_namespace n ON (n.oid = cl.relnamespace)
   JOIN pg_catalog.pg_constraint ct ON (a.attrelid = ct.conrelid AND
        ct.confrelid != 0 AND ct.conkey[1] = a.attnum)
   JOIN pg_catalog.pg_class clf ON (ct.confrelid = clf.oid AND clf.relkind = 'r')
   JOIN pg_catalog.pg_namespace nf ON (nf.oid = clf.relnamespace)
   JOIN pg_catalog.pg_attribute af ON (af.attrelid = ct.confrelid AND
        af.attnum = ct.confkey[1]);

Mostrar Esquemas e Tabelas

SELECT n.nspname as esquema, c.relname as tabela, a.attname as campo, format_type(t.oid, null) as tipo_de_dado
 FROM pg_namespace n, pg_class c,
      pg_attribute a, pg_type t
 WHERE n.oid = c.relnamespace
   and c.relkind = 'r'     -- no indices
   and n.nspname not like 'pg\\_%' -- no catalogs
   and n.nspname != 'information_schema' -- no information_schema
   and a.attnum > 0        -- no system att's
   and not a.attisdropped   -- no dropped columns
   and a.attrelid = c.oid
   and a.atttypid = t.oid
 ORDER BY nspname, relname, attname;

Mostrar Esquemas e respectivas tabelas do Banco atual:

SELECT n.nspname as esquema, c.relname as tabela  FROM pg_namespace n, pg_class c
 WHERE n.oid = c.relnamespace
   and c.relkind = 'r'     -- no indices
   and n.nspname not like 'pg\\_%' -- no catalogs
   and n.nspname != 'information_schema' -- no information_schema
 ORDER BY nspname, relname

Contar Todos os Registros de todas as tabelas de todos os bancos:

<?php
$conexao=pg_connect("host=127.0.0.1 user=postgres password=postabir");
$sql="SELECT datname AS banco FROM pg_database ORDER BY datname";
$consulta=pg_query($conexao,$sql);
$banco = array();
$c=0;
while ($data = @pg_fetch_object($consulta,$c)) {
   $cons=$data->banco;
   $banco[] .= $cons;
   $c++;
}
$sql2="SELECT n.nspname as esquema,c.relname as tabela  FROM pg_namespace n, pg_class c
WHERE n.oid = c.relnamespace
   and c.relkind = 'r'     -- no indices
   and n.nspname not like 'pg\\_%' -- no catalogs
   and n.nspname != 'information_schema' -- no information_schema
ORDER BY nspname, relname";
for ($x=0; $x < count($banco);$x++){
   if ($banco[$x] !="template0" && $banco[$x] != "template1" && $banco[$x] !="postgres"){
       $conexao2=pg_connect("host=127.0.0.1 dbname=$banco[$x] user=postgres password=postabir");
       $consulta2=pg_query( $conexao2, $sql2 );
           while ($data = pg_fetch_object($consulta2)) {
               $esquematab=$data->esquema.'.'.$data->tabela;
               $sql3="SELECT count(*) FROM $esquematab";
               $consulta3=pg_query($conexao2,$sql3);
               $res=@pg_fetch_array($consulta3);
               print 'Banco.Esquema.Tabela ->
               '.$banco[$x].'.'.$data->esquema.'.'.$data->tabela.' - Registro(s) -  '.$res[0].'
';
               $total += $res[0];
           }
   }
}
print "Total de Registro de todas as tabelas de todos os bancos ". $total;
?>

Dado o banco de dados, qual o seu diretório:

select datname, oid from pg_database;

Dado a tabela, qual o seu arquivo:

select relname, relfilenode from pg_class;

Mostrar chaves primárias das tabelas do esquema public

select indexrelname as indice, relname as tabela from pg_catalog.pg_statio_user_indexes as A
INNER JOIN pg_catalog.pg_index as B  ON A.indexrelid=B.indexrelid WHERE A.schemaname='public' AND B.indisprimary = true;

Para visualizar como as consultas são feitas internamente via psql usamos o comando assim:

psql -U user banco -E

Vamos usar o banco municipios, criado com os municípios do Brasil. A tabela opt_cidades.

Veja Um Exemplo Que Retorna a Chave Primária da Tabela opt_cidades

SELECT ic.relname AS index_name, bc.relname AS tab_name, ta.attname AS column_name, i.indisunique AS unique_key, i.indisprimary AS primary_key

FROM pg_class bc, pg_class ic, pg_index i, pg_attribute ta, pg_attribute ia WHERE bc.oid = i.indrelid AND ic.oid = i.indexrelid AND ia.attrelid = i.indexrelid AND ta.attrelid = bc.oid AND bc.relname = ‘opt_cidades’ AND ta.attrelid = i.indrelid AND ta.attnum = i.indkey[ia.attnum-1] ORDER BY index_name, tab_name, column_name;
Retornará:

index_name | tab_name | column_name | unique_key | primary_key

opt_cidades_pkey | opt_cidades | id          | t          | t

Retornando o Nome do Esquema

            SELECT  n.nspname AS "Esquema"
            FROM  pg_catalog.pg_namespace AS n,
                   pg_catalog.pg_class AS c
             WHERE c.relnamespace = n.oid AND c.relname='opt_cidades';

Retorno: Esquema
Retornar nomes de bancos:
SELECT datname AS banco FROM pg_database WHERE datname != ‘template0′ and datname != ‘template1′ and datname != ‘postgres’ ORDER BY datname
Retornar nomes e OIDs dos bancos:

SELECT oid, datname FROM pg_database;
Dado a tabela, qual o seu arquivo: select relname, relfilenode from pg_class;
No Windows

Podemos passar parâmetros para as macros, por exemplo:
doskey /exename=psql.exe dbinfo=SELECT datname,pg_encoding_to_char(encoding) FROM pg_database WHERE datname=’$1′;
E então apenas passar o parâmetro na linha de comando:

postgres=# dbinfo postgres
Listar tabelas, e dono do esquema atual:

SELECT n.nspname as “Schema”,

c.relname as “Tabela”,

CASE c.relkind WHEN ‘r’ THEN ‘table’ WHEN ‘v’ THEN ‘view’ WHEN ‘i’ THEN

‘index’ WHEN ‘S’ THEN ‘sequence’ WHEN ‘s’ THEN ‘special’ END as “Tipo”,

u.usename as “Dono”

FROM pg_catalog.pg_class c

LEFT JOIN pg_catalog.pg_user u ON u.usesysid = c.relowner

LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace

WHERE c.relkind IN (‘r’,)

AND n.nspname NOT IN (‘pg_catalog’, ‘pg_toast’)

AND pg_catalog.pg_table_is_visible(c.oid)

ORDER BY 1,2;
Listar Tabelas

select c.relname FROM pg_catalog.pg_class c

LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace

WHERE c.relkind IN (‘r’,) AND n.nspname NOT IN (‘pg_catalog’, ‘pg_toast’)

AND pg_catalog.pg_table_is_visible(c.oid);
SELECT tablename FROM pg_tables WHERE tablename NOT LIKE ‘pg%’ AND tablename NOT LIKE ‘sql\_%’
Listar todas as tabelas, índices, tamanho em KB e OIDs:

VACUUM; –Executar antes este comando

SELECT c1.relname AS tabela, c2.relname AS indice,

c2.relpages * 8 AS tamanho_kb, c2.relfilenode AS arquivo

FROM pg_class c1, pg_class c2, pg_index i

WHERE c1.oid = i.indrelid AND i.indexrelid = c2.oid

UNION

SELECT relname, NULL, relpages * 8, relfilenode

FROM pg_class

WHERE relkind = ‘r’

ORDER BY tabela, indice DESC, tamanho_kb;
Tabelas e Soma

SELECT tablename, SUM( size_kb )

FROM

( SELECT c1.relname AS “tablename”,

c2.relpages * 8 AS “size_kb”

FROM pg_class c1, pg_class c2, pg_index i

WHERE c1.oid = i.indrelid

AND i.indexrelid = c2.oid

UNION

SELECT relname, relpages * 8

FROM pg_class

WHERE relkind = ‘r’ ) AS relations

GROUP BY tablename;

– r = ordinary table, i = index, S = sequence, v = view, c = composite type, – s = special, t = TOAST table
Tamanho em bytes de um banco:

select pg_database_size(‘banco’);
Tamanho em bytes de uma tabela:

pg_total_relation_size(‘tabela’)
Tamanho em bytes de tabela ou índice:

pg_relation_size(‘tabelaouindice’)
Lista donos e bancos:

SELECT rolname as dono, datname as banco

FROM pg_roles, pg_database

WHERE pg_roles.oid = datdba

ORDER BY rolname, datname;
Nomes de bancos:

select datname from pg_database where datname not in (‘template0′,’template1′) order by 1
Nomes e colunas:

select tablename,’T’ from pg_tables where tablename not like ‘pg\_%’ and tablename not in (‘sql_features’, ‘sql_implementation_info’, ‘sql_languages’, ‘sql_packages’, ‘sql_sizing’, ‘sql_sizing_profiles’)

union

select viewname,’V’ from pg_views where viewname not like ‘pg\_%’
Tamanho de esquema e índice:

SELECT nspname,

sum(relpages * cast( 8192 AS bigint )) as “table size”,

sum( ( select sum(relpages)

     from pg_class i, pg_index idx

     where i.oid = idx.indexrelid

     and t.oid=idx.indrelid ) ) * cast( 8192 AS bigint ) as "index size",

sum ( relpages * cast( 8192 AS bigint ) + ( select sum(relpages)

     from pg_class i, pg_index idx

     where i.oid = idx.indexrelid

     and t.oid=idx.indrelid ) * cast( 8192 AS bigint ) ) as "size"

FROM pg_class t, pg_namespace

WHERE relnamespace = pg_namespace.oid

and pg_namespace.nspname not like ‘pg_%’

and pg_namespace.nspname != ‘information_schema’

and relkind = ‘r’ group by nspname;
Retornando Tabelas e Seus Donos de um Esquema
SELECT n.nspname as “public”,

 c.relname as "opt_cidades",

 CASE c.relkind WHEN 'r' THEN 'tabela' WHEN 'v' THEN 'view' WHEN 'i' THEN 'índice' WHEN 'S' THEN

‘sequencia’ WHEN ‘s’ THEN ‘especial’ END as “Tipo”, u.usename as “Dono”

FROM pg_catalog.pg_class c

    LEFT JOIN pg_catalog.pg_user u ON u.usesysid = c.relowner

    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace

WHERE c.relkind IN (‘r’,)

     AND n.nspname NOT IN ('pg_catalog', 'pg_toast')

     AND pg_catalog.pg_table_is_visible(c.oid)

ORDER BY 1,2;
Retorno:

public |   opt_cidades    |  Tipo  |   Dono

public | opt_cidades      | tabela | postgres

public | opt_estado       | tabela | postgres

Retornando o OID e o Esquema de uma Tabela

SELECT c.oid AS “OID”,

 n.nspname AS "Esquema",

 c.relname AS "Tabela"

FROM pg_catalog.pg_class c

    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace

WHERE pg_catalog.pg_table_is_visible(c.oid)

     AND c.relname ~ '^opt_cidades$'

ORDER BY 2, 3;
Retorno:

 OID  | Esquema |   Tabela

Este exemplo mostra uma consulta que lista os esquemas, nomes das tabelas e nomes das colunas das chaves primárias de um banco de dados. Exemplo tirado da lista de discussão pgsql-sql .

CREATE TEMP TABLE teste1 (id INT, texto TEXT, PRIMARY KEY (id));

CREATE TEMP TABLE teste2 (id1 INT, id2 INT, texto TEXT, PRIMARY KEY (id1,id2));

\dt

SELECT

   pg_namespace.nspname AS esquema,

   pg_class.relname AS tabela,

   pg_attribute.attname  AS coluna_pk

FROM pg_class

   JOIN pg_namespace ON pg_namespace.oid=pg_class.relnamespace AND

        pg_namespace.nspname NOT LIKE 'pg_%'

   JOIN pg_attribute ON pg_attribute.attrelid=pg_class.oid AND

        pg_attribute.attisdropped='f'

   JOIN pg_index ON pg_index.indrelid=pg_class.oid AND

        pg_index.indisprimary='t' AND

        (

        pg_index.indkey[0]=pg_attribute.attnum OR

        pg_index.indkey[1]=pg_attribute.attnum OR

        pg_index.indkey[2]=pg_attribute.attnum OR

        pg_index.indkey[3]=pg_attribute.attnum OR

        pg_index.indkey[4]=pg_attribute.attnum OR

        pg_index.indkey[5]=pg_attribute.attnum OR

        pg_index.indkey[6]=pg_attribute.attnum OR

        pg_index.indkey[7]=pg_attribute.attnum OR

        pg_index.indkey[8]=pg_attribute.attnum OR

        pg_index.indkey[9]=pg_attribute.attnum

        )

ORDER BY pg_namespace.nspname, pg_class.relname,pg_attribute.attname;

Este exemplo mostra uma consulta que lista os nomes dos esquemas, tabelas, colunas e chaves das chaves estrangeiras, e os nomes dos esquemas, tabelas e colunas referenciadas. Exemplo tirado da lista de discussão pgsql-sql

CREATE TEMPORARY TABLE t1 (id SERIAL PRIMARY KEY, nome TEXT);

CREATE TEMPORARY TABLE t2 (id INT REFERENCES t1, nome TEXT);

SELECT

   n.nspname AS esquema,

   cl.relname AS tabela,

   a.attname AS coluna,

   ct.conname AS chave,

   nf.nspname AS esquema_ref,

   clf.relname AS tabela_ref,

   af.attname AS coluna_ref,

   pg_get_constraintdef(ct.oid) AS criar_sql

FROM pg_catalog.pg_attribute a

   JOIN pg_catalog.pg_class cl ON (a.attrelid = cl.oid AND cl.relkind = 'r')

   JOIN pg_catalog.pg_namespace n ON (n.oid = cl.relnamespace)

   JOIN pg_catalog.pg_constraint ct ON (a.attrelid = ct.conrelid AND

        ct.confrelid != 0 AND ct.conkey[1] = a.attnum)

   JOIN pg_catalog.pg_class clf ON (ct.confrelid = clf.oid AND clf.relkind = 'r')

   JOIN pg_catalog.pg_namespace nf ON (nf.oid = clf.relnamespace)

   JOIN pg_catalog.pg_attribute af ON (af.attrelid = ct.confrelid AND

        af.attnum = ct.confkey[1]);

Retorno:

 esquema  | tabela | coluna |   chave    | esquema_ref | tabela_ref | coluna_ref |

criar_sql

pg_temp_1 | t2     | id     | t2_id_fkey | pg_temp_1   | t1         | id | FOREIGN KEY (id)

REFERENCES t1(id)
SELECT a.attnum, a.attname AS field, t.typname as type, a.attlen AS length, a.atttypmod-4 as lengthvar, a.attnotnull as notnull

        FROM pg_class c, pg_attribute a, pg_type t

        WHERE c.relname = 'apagar' AND a.attnum > 0 AND a.attrelid = c.oid AND a.atttypid = t.oid

        ORDER BY a.attnum;

Saída:

ID do campo, nomecampo, tipo, tamanho, nulo/nãonulo
Outros

SELECT ic.relname AS index_name, bc.relname AS tab_name, ta.attname AS column_name, i.indisunique AS unique_key, i.indisprimary AS primary_key

         FROM pg_class bc, pg_class ic, pg_index i, pg_attribute ta, pg_attribute ia

         WHERE (bc.oid = i.indrelid)

             AND (ic.oid = i.indexrelid)

             AND (ia.attrelid = i.indexrelid)

             AND (ta.attrelid = bc.oid)

             AND (bc.relname = 'apagar')

             AND (ta.attrelid = i.indrelid)

             AND (ta.attnum = i.indkey[ia.attnum-1])

             ORDER BY index_name, tab_name, column_name

Saída:

nomeindex/chave, nometabela, nomecampo, unique(t/f), nomepk (t/f)
SELECT rcname as index_name, rcsrc

         FROM pg_relcheck, pg_class bc

         WHERE rcrelid = bc.oid

             AND bc.relname = 'apagar'

              AND NOT EXISTS (

                  SELECT *

                      FROM pg_relcheck as c, pg_inherits as i

                      WHERE i.inhrelid = pg_relcheck.rcrelid

                          AND c.rcname = pg_relcheck.rcname

                          AND c.rcsrc = pg_relcheck.rcsrc

                          AND c.rcrelid = i.inhparent

              )

Saída: retorna as constraints check.

SELECT pg_class.relname, pg_attribute.attname, pg_type.typname, pg_attribute.atttypmod-4
  FROM pg_class, pg_attribute, pg_type
  WHERE pg_attribute.attrelid = pg_class.oid
  AND pg_attribute.atttypid = pg_type.oid
  AND pg_class.relname = 'apagar'
  AND pg_attribute.attname = 'descricao'

Saída: tabela, campo, tipo, tamanho (varchar)
Outros Exemplos

create table tabela_exemplo (

campo_1 integer default 5, campo_2 text default ‘exemplo’, campo_3 float(10),

campo_4 serial, campo_5 double precision, campo_6 int8, campo_7 Point,

campo_8 char(3), campo_9 varchar(17) );

Depois de criada a tabela vamos criar a consulta que nos retornará as informações da tabela:

SELECT

rel.nspname AS Esquema, rel.relname AS Tabela, attrs.attname AS Campo, “Type”, “Default”, attrs.attnotnull AS “NOT NULL”

FROM (

SELECT c.oid, n.nspname, c.relname

FROM pg_catalog.pg_class c

LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace

WHERE pg_catalog.pg_table_is_visible(c.oid) ) rel

JOIN (

SELECT a.attname, a.attrelid, pg_catalog.format_type(a.atttypid, a.atttypmod) as “Type”,

(SELECT substring(d.adsrc for 128) FROM pg_catalog.pg_attrdef d

WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef) as “Default”, a.attnotnull, a.attnum

FROM pg_catalog.pg_attribute a WHERE a.attnum > 0 AND NOT a.attisdropped ) attrs ON (attrs.attrelid = rel.oid ) WHERE relname = ‘tabela_exemplo’ ORDER BY attrs.attnum;

Retorno: testes-# WHERE relname = ‘tabela_exemplo’ ORDER BY attrs.attnum;

esquema |     tabela     |  campo  |         Type          |                     Default                     | NOT NULL

Antes de tudo devemos criar um novo tipo de dado relacionado ao retorno que obteremos da função:

CREATE TYPE tabela_estrutura AS (Esquema text, Tabela text, Campo text, Tipo text, Valor text, AutoIncremento bool);
A função abaixo é definida em PL/PgSQL, linguagem procedural muito semelhante ao PL/SQL do Oracle. A função foi criada nesta linguagem devido a certas limitações que as funções em SQL possuem.

CREATE OR REPLACE FUNCTION Dados_Tabela(varchar(30))
 RETURNS SETOF tabela_estrutura AS '
DECLARE
 r tabela_estrutura%ROWTYPE;
 rec RECORD;
 vTabela alias for $1;
 eSql TEXT;
BEGIN
 eSql := SELECT
 CAST(rel.nspname as TEXT), CAST(rel.relname AS TEXT) , CAST(attrs.attname AS TEXT),
 CAST("Type" AS TEXT), CAST("Default" AS TEXT), attrs.attnotnull
      FROM
              (SELECT c.oid, n.nspname, c.relname
              FROM pg_catalog.pg_class c
              LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
              WHERE pg_catalog.pg_table_is_visible(c.oid) ) rel
       JOIN
              (SELECT a.attname, a.attrelid,
              pg_catalog.format_type(a.atttypid, a.atttypmod) as "Type",
                     (SELECT substring(d.adsrc for 128) FROM pg_catalog.pg_attrdef d
                     WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef)
              as "Default", a.attnotnull, a.attnum
              FROM pg_catalog.pg_attribute a
              WHERE a.attnum > 0 AND NOT a.attisdropped ) attrs
       ON (attrs.attrelid = rel.oid )
       WHERE relname LIKE '% || vTabela || %'
       ORDER BY attrs.attnum;
 FOR r IN EXECUTE eSql
LOOP
RETURN NEXT r;
END LOOP;
IF NOT FOUND THEN
       RAISE EXCEPTION Tabela % não encontrada, vTabela;
END IF;
RETURN;
END
'
LANGUAGE 'plpgsql';

Para utilizar esta função, utilize o seguinte comando:

SELECT * FROM Dados_Tabela('tabela');

Retorno:

esquema | tabela | campo | tipo | valor | autoincremento

Exemplos contidos no arquivo:

/usr/local/src/postgresql-8.1.3/src/tutorial/syscat.sql

SELECT rolname as "Donos", datname as Bancos
 FROM pg_roles, pg_database
 WHERE pg_roles.oid = datdba
 ORDER BY rolname, datname;

Retorno: Donos e Bancos

SELECT n.nspname as esquema, c.relname as tabela
 FROM pg_class c, pg_namespace n
 WHERE c.relnamespace=n.oid
   and c.relkind = 'r'                   -- not indices, views, etc
   and n.nspname not like 'pg\\_%'       -- not catalogs
   and n.nspname != 'information_schema' -- not information_schema
 ORDER BY nspname, relname;

Retorno: Esquemas e Tabelas

SELECT n.nspname as esquema, c.relname as tabela, a.attname as campo, format_type(t.oid, null) as tipo_de_dado
 FROM pg_namespace n, pg_class c,
      pg_attribute a, pg_type t
 WHERE n.oid = c.relnamespace
   and c.relkind = 'r'     -- no indices
   and n.nspname not like 'pg\\_%' -- no catalogs
   and n.nspname != 'information_schema' -- no information_schema
   and a.attnum > 0        -- no system att's
   and not a.attisdropped   -- no dropped columns
   and a.attrelid = c.oid
   and a.atttypid = t.oid
 ORDER BY nspname, relname, attname;

Retorno: esquemas, tabelas, campos, tipos de dados

SELECT n.nspname, o.oprname AS binary_op,
      format_type(left_type.oid, null) AS left_opr,
      format_type(right_type.oid, null) AS right_opr,
      format_type(result.oid, null) AS return_type
 FROM pg_namespace n, pg_operator o, pg_type left_type,
      pg_type right_type, pg_type result
 WHERE o.oprnamespace = n.oid
   and o.oprkind = 'b'         -- binary
   and o.oprleft = left_type.oid
   and o.oprright = right_type.oid
   and o.oprresult = result.oid
 ORDER BY nspname, left_opr, right_opr;

Retorno: operadores binários
Baypassar os de sistema:

and n.nspname not like ‘pg\\_%’ — no catalogs

SELECT n.nspname, p.proname, format_type(t.oid, null) as typname
 FROM pg_namespace n, pg_aggregate a,
      pg_proc p, pg_type t
 WHERE p.pronamespace = n.oid
   and a.aggfnoid = p.oid
   and p.proargtypes[0] = t.oid
 ORDER BY nspname, proname, typname;

Retorno: lista todas as funções agregadas e os tipos que podem ser aplicados
Dado o banco de dados, qual o seu diretório:

select datname, oid from pg_database;

Dado a tabela, qual o seu arquivo:

select relname, relfilenode from pg_class;

Exemplo que retorna índice, campo, tipo, comprimento, null, default:

 SELECT pg_attribute.attnum AS index,
   attname AS field,
   typname AS type,
   atttypmod-4 as length,
   NOT attnotnull AS "null",
   adsrc AS default
 FROM pg_attribute,
   pg_class,
   pg_type,
   pg_attrdef
 WHERE pg_class.oid=attrelid
   AND pg_type.oid=atttypid
   AND attnum >0
   AND pg_class.oid=adrelid
   AND adnum=attnum
   AND atthasdef='t'
   AND lower(relname)='datas'
 UNION
 SELECT pg_attribute.attnum AS index,
   attname AS field,
   typname AS type,
   atttypmod-4 as length,
   NOT attnotnull AS "null",
    AS default 
 FROM pg_attribute,
   pg_class,
   pg_type
 WHERE pg_class.oid=attrelid
   AND pg_type.oid=atttypid
   AND attnum>0
   AND atthasdef='f'
   AND lower(relname)='datas';

Fonte: http://pt.wikibooks.org/wiki/

O Apache é o servidor mais popular da web, foi criado em Abril de 1996 com o intuito de ser um servidor HTTP gratuito para sistemas UNIX e Windows. O objetivo do projeto é de fornecer um servidor seguro, eficiente e extensível que forneça serviços de HTTP em sincronia com os padrões HTTP.

O intuito desse post é de tonar você capacitado a instalar o Apache, o PHP, o MySQL, e o phpMyAdmin no Windows 7, Vista ou XP sem a utilização desses sistemas prontos, como o WampServer, XAMPP, PHP Triad. A vantagem de instalar tudo separado é que você não fica sujeito as configurações que os programas já impõem, ou muitas vezes podem até não funcionar corretamente como deveriam.

Índice

• Passo 1: Instalação e configuração do Apache
• Passo 2: Instalação e configuração do PHP
• Passo 3: Instalação e configuração do MySQL
• Passo 4: Instalação e configuração do PhpMyAdmin

Pré-requisitos

• Apache HTTP Server (2.2.14) – Download Apache
• PHP 5.3.1 – Download PHP 5
• MySQL 5.1.43 Download MySQL 5
• phpMyAdmin 3.2.5 Download phpMyAdmin

Passo 1: Instalação do Apache 2.2

Eu resolvi instalar o Apache em uma pasta chamada Webserver, mas você pode instalá-lo onde quiser, se quiser seguir a minha lógica basta criar uma pasta chamada Webserver na raiz do seu HD, ficando da seguinte forma: C:\Webserver. Após incie o instalador do Apache, a primeira tela de instalação é semelhante a essa:

Basta seguir os passos, e você irá chegar a seguinte tela de configuração. Aqui é onde iremos efetuar algumas configurações do servidor, basta preencher o primeiro campo com o valor localdomain, o segundo campo com localhost e o terceiro um e-mail que desejar. É recomendável que você deixe o Apache rodando na porta 80, não que isso seja obrigatório, você pode alterar caso queira. Basta após clicar em Next:

Chegamos no passo onde iremos escolher o tipo de instalação, eu selecionei Custom pois quero personalizar a pasta de instalação do Apache:

Por padrão, o Apache será instalado na pasta Arquivos de Programas > Apache Software Foundation > Apache 2.2, mas vou instalá-lo dentro da minha pasta Webserver, ficando da seguinte forma:

Basta agora clicar em Install e a instalação será iniciada:

Após o término da instalação, você verá que apareceu na sua System Tray (aqueles ícones que ficam ao lado do relógio do Windows) um novo ícone, o Apache Monitor:

Através dele temos acesso ao status do Apache, onde podemos obter informações se ele está rodando, podemos também parar o sevidor, reiniciá-lo e iniciá-lo. Basta clicar com o botão direito no ícone e escolher Open Apache Monitor:

Já que o Apache está rodando corretamente, vamos testá-lo na prática, abra o seu browser e digite o seguinte na barra de endereços: http://localhost/. Você verá uma mensagem semelhante a abaixo:

As versões mais antigas do Apache exibiam outras informações, mas a 2.2.XX mostra só isso. As páginas ficam por padrão dentro da pasta “htdocs”, no diretório onde o Apache foi instalado. No meu caso ela fica na seguinte pasta: C:\Webserver\Apache2.2\htdocs. Caso você queira agora pode substituir o arquivo “index.html” pelo arquivo do seu site e também pode adicionar alí pastas e subpastas representando outros diretórios de seu site. Por exemplo, se existir uma pasta chamada wordpress dentro do diretório htdocs: C:\Webserver\Apache2.2\htdocs\wordpress, ela deve ser acessada dessa forma: http://localhost/wordpress/.

Se você ao acessar localhost em seu browser e ele ficar buscando o servidor, abrir uma página de busca, ou até mesmo retornar Servidor não encontrado, atente-se se o Apache está rodando corretamente e o mesmo foi iniciado. Se você efetuou esses passos e mesmo assim ele não está funcionando, instale-o novamente seguindo os passos acima que o problema pode ser resolvido.

Até agora nosso servidor lê somente HTML puro. Porém, é diferente a forma de acesso do endereço “http://localhost/index.html” de “C:\Webserver\Apache2.2\htdocs\index.html”. No primeiro caso, o navegador solicita a página ao servidor “localhost” (que é o seu computador), recebe a página do servidor, armazena a mesma no cache, e só depois então a exibe. Ele trata como se fosse um site que estivesse realmente hospedado em algum servidor da Internet. Como o servidor do site está no seu próprio PC, trata-se então de uma Intranet. No segundo caso, você está acessando o arquivo diretamente do seu HD. O navegador pode até armazenar algum dado no cache, mas não há nenhuma comunicação com qualquer servidor. Ele lê o arquivo como qualquer programa leria qualquer arquivo.

Configurações extras para o Apache

Após a instalação do Apache, vamos efetuar algumas configurações adicionais simples, para isso, vamos alterar o arquivo httpd.conf que está localizado dentro da pasta conf no diretório de instalação do Apache. Cuidado ao editar esse arquivo, pois qualquer erro e seu servidor pode parar de funcionar. Para habilitar o uso de URL’s amigáveis no servidor, você deve habilitar o módulo de mod_rewrite, bastando localizar a linha:

E substituir a mesma por:

Vamos definir agora também quais arquivos o Apache irá servir quando um diretório for requisitado. Procure a seguinte linha:

E substituir a mesma por:

Passo 2: Instalação e Configuração do PHP 5.3.1

A partir de agora vamos proporcionar mais interatividade ao nosso servidor com a instalação do PHP, a versão que vamos utilizar aqui é a 5.3.1. O PHP é um módulo para o Apache. Ao processar uma página PHP, o Apache envia a página ao módulo PHP, que a processa e devolve o resultado ao Apache, que por sua vez, envia ao browser que fez a solicitação. Para isso, a instalação do PHP consiste basicamente em colocar os arquivos numa pasta, e configurar o Apache para que “enxergue” os módulos PHP e chame-os sempre que encontrar um arquivo .php.

As telas de instalação poderão ser diferentes em outras versões, mas as idéias serão basicamente as mesmas:

Basta agora você ir seguindo os passos até chegar a tela onde você escolherá a pasta de instalação do PHP. Como já fiz anteriormente com o Apache, também vou personalizar a pasta do instalação do PHP, que será a seguinte: C:\Webserver\PHP5:

Nesse passo, ele irá pedir o tipo de servidor você está utilizando, basta escolher o Apache 2.2.XX:

Nesse próximo passo, ele irá solicitar o local dos arquivos de configuração do Apache. Localize a pasta “conf”, dentro da pasta onde foi instalado o Apache, senão a configuração não será automatizada e você terá que efetuar a mesma manualmente:

O próximo passo é onde você escolhe quais extensões quer instalar junto com o PHP, escolha as que julgar necessário ou simplesmente deixe como está:

Ao final do processo, caso esteja tudo OK, basta agora clicar no botão install:

Se tudo ocorreu bem até aí, nenhuma mensagem de erro será exibida. Basta agora você reiniciar o Apache e as páginas .php serão processadas e entregues corretamente ao browser. Ainda não foi configurado um servidor de banco de dados, então apenas os recursos diretos do PHP funcionarão (e os dos outros módulos pré-instalados do Apache). Um ótimo meio de testar o PHP e ver diversas informações do servidor é criar uma página PHP, com o seguinte conteúdo:

Salve a mesma dentro da pasta htdocs com o nome info.php e então acesse a página pela seguinte URL: http://localhost/info.php.

Você terá acesso agora a uma página com todas as informações do PHP e os componentes instalados:

Configuração do PHP

A configuração do PHP envolve a edição do arquivo php.ini, na pasta onde o PHP for instalado, portanto, mãos a obra. Uma configuração útil é a ativar o uso de delimitadores < ? … ?>, muito usados por serem mais simples. No arquivo php.ini, localize a linha que começa com short_open_tag e troque seu valor Off para On (Fique atento as letras maiúsculas e minúsculas). Ela deve ficar dessa forma:

Caso você deixe Off, scripts PHP que iniciem com <? não serão identificados, somente os scripts que inciem com <?php funcionarão.

Permitir estilo ASP

Ative este item apenas se você gostar de usar as tags no estilo ASP, como em <% … %>, caso contrário, pode deixar desativado.

Habilitar a exibição de erros

Por questões de segurança esse item vem com valor Off. Sua função é a de imprimir erros de sintaxe ou funcionamento do PHP na página. Por questões de segurança, é bom deixá-lo em Off, pois entre as mensagens de erros muitas vezes vêm nomes de arquivos, caminhos locais, e até a senha do banco de dados, se tiver algum erro de sintaxe justamente na declaração da mesma. Mas em contrapartida, para aprender PHP, é recomedável deixá-lo em On.

Passo 3: Instalação e Configuração do MySQL 5.1

O MySQL é um famoso gerenciador de Banco de Dados. Nesse tutorial iremos utilizar a versão 5.1.43 essential. Existe um outro pacote maior que vem com algumas coisas a mais, como documentação, mas para nosso tutorial resolvi optar pela versão mais leve.

A interface de instalação é semelhante a do Apache e a do PHP, não existe muito segredo, basta ir seguindo os passos que serão mostrados abaixo. Ao executar o instalador, você terá acesso a uma tela semelhante a essa:

O próximo passo é onde iremos selecionar o tipo de instalação: Típica, Completa ou Customizada. Eu optei pela instalação customizada pois quero personalizar a pasta de instalação do MySQL:

Localização da pasta de instalação do MySQL:

Estando tudo Ok, basta clicar em Install:

Após o final da instalação, vamos efetuar as configurações do MySQL, basta seguir os passos que serão mostrados aqui:

A seguir escolha configuração detalhada:

Escolha Developer Machine:

Escolha Multifunctional Database:

No passo ao que se refere a instalação do InnoDB, deixe como o caminho Installation Patch:

Deixe selecionado Decision Support (DSS)/OLAP:

Nesse passo, não se esqueça de deixar selecionado a caixa “Adicionar excessão ao Firewall”:

Selecione Best Support for Multilingualism:

A próxima opção é de incluir o caminho do MySQL na variável de ambiente “Path” do Windows. Deixe-a selecionada pois assim você pode chamar os executáveis do MySQL a partir de qualquer prompt, em qualquer pasta:

No próximo passo deve-se definir a senha de root, ele é o administrador do MySQL. Caso você já programe em PHP já sabe que para acessar um banco de dados é necessário fornecer um nome de usuário e senha válidos para aquele banco. Você poderá usar o “root” e a senha definida aqui, ou outra conta. Mas tenha em mente que para criar outras contas você precisará do root, e para alterar as configurações ou criar novos bancos de dados, também. Por isso é importante ter essa senha guardada em um local seguro:

No próximo passo basta você clicar em execute para que o MySQL dê início ao processo de configuração:

Caso tudo tenha corrido OK, você verá uma tela como essa, caso tenha algum problema, efetue as configurações novamente:

Caso queira checar se o serviço do MySQL está rodando corretamente no Windows, basta fazer o seguinte. Abra um prompt de comando, e digite: mysql -u root – p, ele irá pedir a senha de root que você havia configurado anteriormente, basta então digitar a mesma:

Após digite status e pronto, você terá informações sobre o MySQL:

Problemas de conexão dos scripts PHP com o MySQL

Alguns usuários de Windows 7, inclusive eu, andaram passando por problemas de conexão dos scripts PHP com o banco de dados. Se por um acaso você verificar que o serviço de MySQL está rodando corretamente, seu script PHP também está OK e mesmo assim ele não consegue conectar no banco de dados, aqui vai a solução. Verifique o arquivo hosts do Windows, ele fica localizado em: C:\Windows\System32\drivers\etc, abra o aquivo hosts e descomente a linha que contém o seguinte conteúdo:

Bastando somente você remover o sinal de #. Observe na screenshot abaixo como ele deve ficar:

Esse problema ocorre devido ao conector nativo do PHP. A partir da versão php5.3 é utilizado o cliente mysql nativo mysqlnd, não se usa mais o libmysql.dll. Esse novo conector não reconhece named pipe, por isso, deve-se especificar no arquivo hosts do Windows.

Passo 4: Instalação do PhpMyAdmin

Após efetuar o download do PhpMyAdmin, descompacte o mesmo e renomeie a pasta para phpmyadmin. Após, coloque a pasta dentro do diretório htdocs da pasta de instalação do Apache. Para acessar agora o PhpMyAdmin basta você digitar o seguinte: http://localhost/phpmyadmin/, entre com o usuário root e senha que você configurou para o mesmo na instalação do MySQL e pronto, você já tem acesso ao PhpMyAdmin.

Se você quiser pular esse passo de toda vez ao acessar o PhpMyAdmin ter de se logar, basta fazer o seguinte. Na pasta do mesmo abra o arquivo config.sample.inc.php e o renomeie para config.inc.php. Agora basta substituir a linha $cfg['Servers'][$i]['auth_type'] = ‘cookie’; por:

Pronto, agora toda vez ao acessar o PhpMyAdmin ele irá pular a tela de autenticação pois o usuário e senha já estão cadastrados no arquivo de configuração.

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

Imagine que, em um futuro distante, o Google decida transformar o Android em um sistema para robôs pessoais. Seu robô com o Android poderia ser então instruído a executar qualquer tipo de tarefa, desde que você conseguisse explicar para ele o que precisa fazer na forma de instruções simples. Uma ida até a geladeira para pegar uma lata de refrigerante poderia ser explicada dessa forma:

Ir até a cozinha.
Abrir a geladeira.
Olhar a prateleira da direita.
Se encontrar uma lata de coca-cola, trazer para mim.
Senão, trazer a lata de guaraná.
Se não encontrar lata alguma, fechar a geladeira e voltar.

Este mesmo princípio, de dividir a tarefa a ser feita em instruções simples, é comum a todas as linguagens de programação. Elas podem variar em complexidade, mas a ideia central é sempre a mesma: explicar ao sistema o que fazer, em uma linguagem que ele seja capaz de entender.

No caso do shell-script, você precisa apenas pensar em uma maneira de “explicar” o que você quer que seja feito através de comandos de terminal. Conforme você vai adquirindo mais familiaridade com o sistema, este acaba se tornando um processo natural, já que qualquer conjunto de comandos para executar uma determinada tarefa pode ser transformado em um script rapidamente. Vamos então a alguns exemplos básicos para quebrar o gelo.

O tipo mais simples de script consiste em um bloco de comandos, que automatiza alguma tarefa repetitiva. Estes scripts “burros” são uma excelente forma de simplificar o uso do sistema, evitando que você precise memorizar sequências de comandos. Um bom exemplo é este mini-script que uso para conectar um mouse bluetooth:

#!/bin/sh
# Checagem para ter certeza que o suporte a bluetooth está ativado:
hciconfig hci0 down
/etc/init.d/bluetooth restart
hciconfig hci0 up
# Ativa o mouse:
hidd –connect 00:07:61:62:cb:bb

Estes quatro comandos permitem ativar o mouse em qualquer distribuição, de forma que preciso apenas executar o script e colocá-lo para ser inicializado automaticamente, sem precisar me preocupar com as peculiaridades de cada uma.

Para usá-lo, é necessário apenas criar um arquivo de texto chamado “btmouse.sh” (ou qualquer outro nome que escolher), colocá-lo dentro do seu home, ou da sua partição de dados (para que ele não seja perdido ao reinstalar o sistema) e marcar a permissão de execução (“chmod +x btmouse.sh”).

A partir daí, você pode passar a executar o script quando precisar ativar o mouse:

# /mnt/sda6/btmouse.sh

… ou adicionar o comando no final do arquivo “/etc/rc.d/rc.local” (ou outro arquivo de inicialização) para que ele passe a ser executado automaticamente.

O problema com esses scripts simples é que eles servem para propósitos bem específicos, já que os passos executados são sempre os mesmos. Este script para ativar o mouse bluetooth, por exemplo, funciona apenas com o meu mouse, já que o endereço de conexão está gravado dentro do próprio script.

Scripts mais complexos começam quase sempre com alguma pergunta. Um gerenciador de downloads precisa saber qual é a URL do arquivo a baixar, um discador precisa saber qual modem será utilizado e qual o número de acesso do provedor, um instalador de programas precisa saber qual programa deve ser instalado e assim por diante.

Dependendo da situação, as perguntas podem ser feitas diretamente, no estilo “digite a URL do arquivo a baixar”, ou através de um menu de seleção, onde você lista as funções oferecidas pelo script e o usuário clica na opção desejada.

Para fazer uma pergunta direta (que é o formato mais simples), usamos o comando “read“, que lê uma resposta e a armazena em uma variável. Quase sempre ele é usado em conjunto com o “echo”, que permite escrever texto na tela, fazendo a pergunta, como em:

echo “Digite a URL do arquivo a baixar”
read arquivo
wget -c $arquivo

Com estes três comandos, criamos um gerenciador de downloads primitivo, que pede a URL do arquivo (que você poderia colar no terminal usando o botão central do mouse) e faz o download usando o wget, que é um gerenciador em modo texto, muito usado em scripts.

A URL digitada é armazenada na variável “arquivo”, que pode ser usada ao longo do script. Ao usá-la, é necessário incluir um “$”, que faz com que o shell entenda que se trata da variável “arquivo” e não de um trecho de texto qualquer. Quando o script fosse executado, o “wget -c $arquivo” seria transformado em algo como “wget -c http://gdhpress.com.br/arquivo.zip”, iniciando o download.

O “-c” é uma opção para o wget, que faz com que ele continue o download caso interrompido. Se você pressionasse “Ctrl+C” durante o download para encerrar o script e o executasse novamente, fornecendo a mesma URL, ele continuaria o download de onde parou.

Você poderia incrementar o script, incluindo mais perguntas e usando mais opções do wget. A primeira parada nesse caso seria o “man wget”, onde você poderia garimpar as opções suportadas pelo comando e selecionar algumas que poderiam ser úteis dentro do script. Um bom exemplo é a opção “–limit-rate=” que permite limitar a taxa de download. Você poderia incluir a opção no script adicionando mais uma pergunta, como em:

echo “Digite a URL do arquivo a baixar”
read arquivo
echo “Digite a taxa máxima de download, em kbytes. ex: 48″
read taxa
wget -c –limit-rate=$taxa $arquivo

Este formato simples funciona bem para scripts rudimentares, destinados a simplesmente automatizarem alguma tarefa específica, a partir de algumas perguntas simples. Para scripts mais completos, precisamos começar a usar as operações lógicas, que permitem que o script tome decisões. O formato mais básico é o “se, então, senão”, que no shell script é representado pelos operadores “if”, “then” e “else”.

Imagine que você está fazendo um script conversor de vídeos, que é capaz de gerar arquivos em quatro diferentes formatos. O script começa perguntando qual formato usar e, de acordo com a resposta, executa os comandos apropriados para fazer a conversão.

Para simplificar, vamos fazer com que o script simplesmente converta todos os arquivos dentro do diretório atual, em vez de perguntar quais arquivos converter ou de exibir uma caixa de seleção.

A parte da pergunta poderia ser feita com o “echo”, como no exemplo anterior. Como agora são várias linhas de texto, usei aspas simples ( ‘ ) em vez de aspas duplas. As aspas simples permitem que você inclua quebras de linha e caracteres especiais dentro do texto, fazendo com que o shell simplesmente escreva tudo literalmente:

echo ‘Escolha o formato de saída:
1) MPEG4, 320×240 (vídeos no formato 4:3)
2) MPEG4, 320×176 (vídeos em formato wide)
3) Real Player, 320×240 (vídeos no formato 4:3)
4) Real Player, 320×176 (vídeos em formato wide)
(Responda 1, 2, 3 ou 4, ou qualquer outra tecla para sair)‘
read resposta

No final deste trecho, teríamos a variável “resposta”, que armazenaria um número de 1 a 4. Precisamos agora fazer com que o script decida o que fazer de acordo com a resposta.

O jeito mais simples de fazer isso seria simplesmente colocar um bloco com 4 comandos “if” (se), um para cada possibilidade. Cada “if” é sempre acompanhado por um “then” (então) e um “fi” (fim do se), como em:

if [ "$resposta" = "1" ]; then
[comandos ...]
fi
if [ "$resposta" = "2" ]; then
[comandos ...]
fi
if [ "$resposta" = "3" ]; then
[comandos ...]
fi
if [ "$resposta" = "4" ]; then
[comandos ...]
fi

Uma forma mais elegante (e mais à prova de falhas), seria usar o “elif” (que poderia ser traduzido para “senão se”) e o “else” (senão), como em:

if [ "$resposta" = "1" ]; then
[comandos ...]
elif [ "$resposta" = "2" ]; then
[comandos ...]
elif [ "$resposta" = "3" ]; then
[comandos ...]
elif [ "$resposta" = "4" ]; then
[comandos ...]
else
echo “Você digitou uma opção inválida. O script termina aqui.”
fi

Como pode ver, ao usar o elif você não precisa mais incluir um “fi” para cada possibilidade. Outra vantagem é que você pode agora incluir um “else” no final, que faz com que o script responda com uma mensagem de erro ao receber alguma resposta que não estava esperando. Dentro de cada uma das condições, você incluiria um bloco de comandos destinado a gerar os arquivos convertidos com os parâmetros correspondentes, como em:

if [ "$resposta" = "1" ]; then
for i in *; do
mencoder -oac mp3lame -lameopts cbr:br=128 -ovc lavc -lavcopts \
vcodec=mpeg4:vbitrate=512 -ofps 16 -vf scale=320:176 -o “c-$i” “$i”
done

elif [ "$resposta" = "2" ]; then
[o resto do script...]

Esse comando gigante que se esparrama pela terceira e a quarta linha é um comando de conversão do mencoder (um pequeno utilitário de conversão de arquivos de mídia em modo texto, que é bastante flexível), que gera um arquivo de vídeo otimizado para ser assistido em smartphones. Esse é o tipo de comando que é longo demais para ser escrito manualmente, mas que pode perfeitamente ser usado através de um script.

Veja que a variável “i” é usada no final da quarta linha, para indicar o nome do arquivo. O “c-$i” “$i” faz com que o script adicione o prefixo “c-” no nome dos arquivos convertidos, permitindo que eles sejam incluídos na pasta sem apagar os arquivos originais.

O comando do mencoder é colocado dentro de outra condicional, agora usando o “for” (enquanto), que permite que o script execute um conjunto de comandos repetidamente.

No exemplo, ele é usado para fazer com que o comando de conversão do mencoder seja executado uma vez para cada arquivo dentro da pasta. Ao ser executado, a variável “i” (poderia ser qualquer outro nome) recebe o nome do primeiro arquivo, o que faz com que ele seja convertido.

Ao chegar no “done”, o interpretador volta à linha inicial e a variável “i” recebe agora o nome do segundo arquivo. O processo é então repetido para cada um dos arquivos da pasta, até o último (a lista dos arquivos a converter é gerada pelo interpretador no início do script, por isso não existe o risco do conversor ficar em loop). O “for i in *; do” poderia ser traduzido como “para cada arquivo dentro da pasta atual, execute”.

Você pode baixar o script pronto, incluindo os comandos de conversão no:
http://www.gdhpress.com.br/blog/converter-video/

Outro exemplo de uso para o “for” seria baixar uma lista de arquivos ISO especificada em um arquivo de texto. Imagine que você goste de testar novas distribuições e, de vez em quando, queira deixar o PC ligado durante a madrugada colocando os downloads em dia. Você poderia facilitar as coisas usando um script como:

#!/bin/sh
echo “Digite a taxa máxima de download, em kbytes. ex: 48″
read taxa

for i in `cat /home/$USER/downloads.txt`; do
wget -c –limit-rate=$taxa $i
done

Para usá-lo, você precisaria apenas criar um arquivo “downloads.txt” dentro do seu diretório home, colocando os links de download dos ISOs das distribuições, um por linha, como em:

http://ftp.heanet.ie/pub/linuxmint.com/stable/6/LinuxMint-6.iso
ftp://ftp.nluug.nl/pub/os/Linux/distr/dreamlinux/stable/DL3.5_20092802.iso

http://sidux.c3sl.ufpr.br/release/sidux-2009-01-ouranos-kde-lite-i386.iso

Ao executar o script, ele começaria perguntando a taxa máxima de download (com a resposta sendo armazenada na variável “taxa”), leria o arquivo e baixaria os arquivos listados para o diretório atual. A linha do wget inclui duas variáveis: a taxa de download e o arquivo a baixar. Por causa do “for”, o comando é repetido para cada um dos links listados no arquivo, fazendo com que eles sejam baixados um de cada vez.

Embora simples, este script introduz algumas idéias novas. A primeira é o uso das crases (“), que permitem usar o resultado de um comando. Graças a elas, podemos usar o “cat” para ler o arquivo de texto e assim fazer com que o script carregue as URLs dentro da variável “i”, uma de cada vez.

Outra novidade é o uso do “/home/$USER”, uma variável de sistema que contém sempre o diretório home do usuário que executou o script. Isso faz com que o script procure pelo arquivo “downloads.txt” dentro do seu diretório home, e não em uma localização específica.

Uma prática um pouco mais avançada é o uso de funções. Elas permitem que você crie blocos de código destinados a executarem tarefas específicas que podem ser usados ao longo do script. Em outras palavras, as funções são pequenos scripts dentro do script.

A grande vantagem de criar funções (em vez de simplesmente repetir os comandos quando precisar) é que, ao atualizar o script, você precisa alterar apenas um bloco de comandos, em vez de precisar procurar e alterar os comandos manuais em vários pontos do script. Por permitirem reaproveitar o código, as funções fazem com que o script seja mais organizado e fique com menos linhas, o que facilita muito a manutenção em scripts complexos.

Imagine, por exemplo, que você precisa repetir uma mesma mensagem de erro várias vezes ao longo do script. Você poderia usar uma função como esta:

msgerro()
{
echo “Algo deu errado durante a conexão. O erro foi:”
echo “$msg”
}

Veja que a função começa com uma declaração (“msgerro()”), onde você especifica um nome e adiciona o “()”, que faz com que o sistema entenda que se trata de uma função e não de um outro bloco de comandos qualquer. Os comandos são, em seguida, colocados dentro de um par de chaves ( { …. } ), que indicam o início e o final. A partir daí, você pode executar os comandos dentro do script chamando o nome da função (msgerro), como se fosse um comando qualquer.

Um exemplo é o script para conectar usando modems e smartphones 3G que escrevi em 2008, que está disponível no: http://www.gdhpress.com.br/blog/script-vivo-zap/

Ele prevê o uso de diversos tipos de conexão e inclui várias funções de checagem e solução de problemas (que são usadas repetidamente ao longo do script), por isso ele é bastante longo e complexo, com quase 900 linhas. Se tiver curiosidade em acessar o tópico e olhar o código, vai ver que crio diversas funções no início do script (a “bpairing()” contém os comandos para fazer o pareamento com smartphones e conectar via Bluetooth, enquanto a “checaporta()” verifica em que porta o modem ou smartphone está conectado, por exemplo) que são usadas ao longo do script.

Outra necessidade comum é salvar parâmetros e configurações, evitando que o script precise perguntar tudo novamente cada vez que for executado. Uma forma simples de implementar isso é fazer com que o script salve as variáveis com as configurações usadas em arquivo de texto (é geralmente usado um arquivo oculto dentro do diretório home), como em:

echo “tel=\”$tel\”" > /home/$USER/.myscript
echo “porta=\”$porta\”" >> /home/$USER/.myscript

Esses comandos criariam o arquivo “.myscript” dentro do diretório home do usuário que executou o script. Graças ao uso do ponto, ele se torna um arquivo oculto, assim como os demais arquivos de configuração do sistema.

O arquivo de configuração pode ser carregado dentro do script com um “. /home/$USER/.myscript” (ou seja, ponto, espaço e a localização do arquivo), o que faz com que o interpretador processe os comandos dentro do arquivo como se fossem parte do script principal.

Um exemplo de uso seria uma versão aperfeiçoada do script para ativar mouses Bluetooth que mostrei a pouco, que perguntasse o endereço do mouse da primeira vez que fosse executado e passasse a usar a configuração salva daí em diante:

#!/bin/sh

if [ -e "/home/$USER/.btmouse" ]; then
echo “Carregando configuração salva no arquivo /home/$USER/.btmouse.”
. /home/$USER/.btmouse
else
# Se o arquivo não existir, pergunta o endereço e salva a configuração.
echo “Digite o endereço do mouse que será usado (ex: 00:07:61:62:cb:bb):”
read addr
echo “addr=\”$addr\”" > /home/$USER/.btmouse
fi

# Mensagem explicativa:
echo “Conectando a $addr”
echo “Delete o arquivo /home/$USER/.btmouse para trocar o endereço.”

# O script propriamente dito:
hciconfig hci0 down
/etc/init.d/bluetooth restart
hciconfig hci0 up
hidd –connect $addr

Embora estes exemplos utilizem apenas perguntas simples, em texto, os shell-scripts podem também exibir janelas, avisos, perguntas e menus de seleção gráficos de maneira muito simples, utilizando o Xdialog, Kdialog ou o Zenity, que permitem mostrar janelas gráficas de forma surpreendentemente fácil.

Para mostrar uma mensagem de texto, por exemplo, você usaria o “zenity –info –text” seguido da mensagem a mostrar, como em:

zenity –info –text “Conexão ativa.”

Para abrir uma janela de seleção de arquivo, você usaria o “zenity –file-selection”, que exibe uma janela similar à do gerenciador de arquivos, permitindo escolher o arquivo que será usado.

Normalmente, a localização do arquivo seria simplesmente escrita no terminal. Para que ela seja armazenada em uma variável (permitindo que você a use posteriormente ao longo do script), você usaria:

arquivo=`zenity –file-selection –title “Escolha o arquivo”`

Estes dois comandos simples poderiam ser usados para criar um aplicativo rudimentar de gravação de CDs, veja só:

#!/bin/sh

zenity –info –text “Coloque uma mídia virgem no drive”
iso=`zenity –file-selection –title “Escolha o arquivo ISO para gravar:”`
wodim dev=/dev/scd0 speed=16 -dao -eject -v $iso

Quando executado, o script mostraria as duas janelas e gravaria o arquivo ISO selecionado usado o wodim, que é um aplicativo de gravação de CDs via linha de comando, usado por diversos outros aplicativos. Quando você queima um CD usando o Brasero ou o K3B, é o wodim quem faz o trabalho pesado, assim como no caso do nosso script:

Graças à opção “-eject” adicionada à linha de gravação, o script ejeta a mídia depois de gravada, o que torna desnecessário incluir mais uma janela avisando que a gravação foi concluída. O wodim suporta diversas outras opções de gravação (que você pode consultar no “man wodim”), que poderiam ser usadas para aperfeiçoar o script. Você precisaria apenas incluir algumas perguntas adicionais, salvar as respostas em variáveis e incluí-las na linha de gravação.

Concluindo essa breve introdução, dois outros comandos fundamentais em se tratando de shell-scripts são o pipe e o grep. Aqui vai uma explicação resumida sobre eles:

pipe: Junto com as setas de redirecionamento (> e >>), o pipe ( | ) é muito usado em scripts e comandos diversos. Ele permite fazer com que a saída de um comando seja enviada para outro ao invés de ser mostrada na tela. Parece uma coisa muito exótica, mas acaba sendo incrivelmente útil, pois permite “combinar” diversos comandos que originalmente não teriam nenhuma relação entre si, de forma que eles façam alguma coisa específica. Um exemplo simples é o “modprobe -l | more”, que vimos no tópico sobre o kernel, onde o pipe é usado para que a enorme lista gerada pelo comando “modprobe -l” seja enviada ao “more”, que se encarrega de criar as quebras de página.

grep: O grep permite filtrar a saída de um determinado comando, de forma que ao invés de um monte de linhas, você veja apenas a informação que está procurando. Ele é frequentemente usado em conjunto com o pipe, sobretudo em scripts.

Um exemplo simples: sua placa de rede não está funcionando e você quer saber se o módulo de kernel “sis900″, que dá suporte a ela, está carregado. Você pode ver os módulos que estão carregados usando o comando “lsmod”, mas a lista é um pouco longa. Você poderia completar o lsmod com o “| grep sis900″, que vai filtrar usando o grep, mostrando na tela apenas as linhas contendo “sis900″. O comando ficaria então “lsmod | grep sis900″.

Se não aparecer nada na tela, você sabe de antemão que o módulo não está ativo. Neste caso, você poderia tentar carregá-lo manualmente usando o comando “modprobe sis900″, como root.

Em um script, o mesmo comando poderia ser usado para detectar se o módulo está carregado ou não e, a partir daí, mostrar uma mensagem na tela, ou carregá-lo automaticamente.

Ao longo do livro, veremos mais alguns exemplos de uso do shell-script, esta foi apenas uma introdução rápida destinada a apresentar alguns dos conceitos básicos. Uma característica importante do shell-script é que assim que você toma coragem e começa a escrever alguns scripts básicos, você acaba se empolgando e passa a, gradualmente, incorporar novos truques, aprendendo uma coisa aqui e outra ali, mesmo sem estudar especificamente sobre o assunto.
Fonte: http://www.gdhpress.com.br

Nome

createuser – cria uma conta de usuário do PostgreSQL

$ createuser joel
O novo papel será um superusuário? (s/n) n
O novo papel poderá criar bancos de dados? (s/n) n
O novo papel poderá criar novos papéis? (s/n) n
CREATE USER

$ createuser -h eden -p 5000 -S -D -R -e joel
CREATE ROLE joel NOSUPERUSER NOCREATEDB NOCREATEROLE INHERIT LOGIN;
CREATE ROLE

$ createuser -P -s -E -e joel
Digite a senha do novo papel: xyzzy
Digite novamente: xyzzy
CREATE ROLE joel PASSWORD 'md58c5635dc3b41432cacfbb67c661a0e36' SUPERUSER CREATEDB CREATEROLE INHERIT LOGIN;
CREATE ROLE

$ createuser -P -s -N -e joel
Digite a senha do novo papel: xyzzy
Digite novamente: xyzzy
CREATE ROLE joel PASSWORD 'xyzzy' SUPERUSER CREATEDB CREATEROLE INHERIT LOGIN;
CREATE ROLE

Notas

Fonte: http://pgdocptbr.sourceforge.net

O mod_deflate permite comprimir de forma automática as páginas html (e também outros tipos de arquivos) enviados aos clientes, de forma a economizar banda e a reduzir o tempo de carregamento das páginas. Se os sites hospedados no servidor utilizam páginas com grandes volumes de texto, a redução pode ser bastante significativa. 

O uso de compressão é negociado entre o servidor e o cliente no momento em que ele requisita a página, de forma que você não precisa se preocupar em excluir navegadores móveis ou clientes com browsers antigos. Ao perceber que o cliente não suporta o recurso, o servidor simplesmente envia a página sem compressão.

O uso do deflate aumenta sutilmente o uso de processamento no servidor, já que ele terá o trabalho de comprimir cada página solicitada antes de enviá-la ao cliente, mas isso é compensado pelo fato de o cliente demorar menos tempo para carregar cada página, o que permite que o servidor mantenha um número menor de instâncias do Apache carregadas na memória.

Do ponto de vista do cliente, o deflate é bastante benéfico, pois o texto das páginas carrega mais rápido. Uma página html comprimida pelo deflate fica com, tipicamente, um quarto do tamanho original. Com isso, uma página de 100 KB, que demoraria até 15 segundos para ser carregada por um cliente acessando via modem, passaria a ser carregada em apenas 3 ou 4 segundos. Depois disso, ainda teríamos o tempo de carregamento das imagens e de outros elementos da página, como de praxe, mas com o html carregado o cliente pode já ir adiantando a leitura.

Note que, as “páginas em html” que citei no parágrafo anterior, incluem também páginas dinâmicas em php e em outras linguagens, pois, de qualquer forma, depois de serem processadas pelo servidor, elas são enviadas ao cliente como uma página html.

Nas distribuições derivadas do Debian, o módulo é ativado usando o a2enmod:

# a2enmod deflate

Nas distribuições derivadas do Red Hat, verifique se a linha a seguir está presente dentro da seção “Dynamic Shared Object (DSO) Support” do arquivo “/etc/httpd/conf/httpd.conf“. Adicione-a manualmente caso necessário (não se esqueça de reiniciar o Apache para que a configuração entre em vigor):

LoadModule deflate_module modules/mod_deflate.so

Esta linha tem exatamente a mesma função desta outra, usada em algumas distribuições. A única diferença é que neste segundo exemplo é especificado o caminho completo até o arquivo: LoadModule deflate_module /usr/lib/apache2/modules/mod_deflate.so Em seguida, vem a configuração do módulo. No Debian, a configuração vai no arquivo “/etc/apache2/mods-available/deflate.conf“, enquanto do CentOS e no Fedora é usado o arquivo “/etc/httpd/conf.d/httpd-deflate.conf“.

Uma configuração simples, e bastante usada, é fazer com que o deflate comprima apenas arquivos em html, texto puro ou xml, sem tentar comprimir outros tipos de arquivos (como imagens ou arquivos diversos disponibilizados para download, que via de regra já estarão compactados). Esta configuração exige uma única linha e é a configuração padrão no Debian:

<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html text/plain text/xml
</IfModule>

Outra abordagem é orientar o deflate a comprimir todos os tipos de arquivos, com exceção das imagens em .gif, .png e .jpg. Isso pode ser interessante se, além das páginas html, você disponibiliza arquivos em formatos com baixos índices de compressão, como arquivos do MS Office, por exemplo. Nesse caso, a configuração ficaria:

<IfModule mod_deflate.c>
# Comprime tudo, com exceção de arquivos .gif, .jpg e .png:
SetOutputFilter DEFLATE
SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png)$ no-gzip dont-vary
</IfModule>

Note que esta configuração deve ser usada apenas em casos específicos, pois ela faz com que o servidor tente comprimir todo tipo de arquivos, incluindo arquivos em formatos já compactados, o que resultará em um grande aumento no uso de processamento, sem que haja uma redução tangível no tamanho dos arquivos.

Concluindo, uma recomendação geral é incluir exceções para versões antigas do Netscape 4 e do IE 3 que não são capazes de negociar a compressão de páginas com o servidor corretamente. Estes navegadores são extremamente raros hoje em dia, por isso mesmo os sites movimentados não recebem mais do que um punhado de visitas diárias de clientes utilizando um deles, mas não custa deixar o servidor preparado para atender a esses casos específicos. Para isso, são incluídas três linhas adicionais na configuração:

<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html text/plain text/xml
BrowserMatch ^Mozilla/4 gzip-only-text/html
BrowserMatch ^Mozilla/4\.0[678] no-gzip
BrowserMatch \bMSIE !no-gzip !gzip-only-text/html
</IfModule>

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

O mod_rewrite tem a função de reescrever URLs a partir de um conjunto de parâmetros especificado por você. O uso mais simples para ele é quando você muda o domínio de acesso do site e quer que todos os links sejam redirecionados para o novo endereço.

Imagine, por exemplo, que você migrou do http://dominio.provedor.com.br para http://www.dominio.com.br. Você poderia simplesmente criar um arquivo “index.php” no diretório raiz do antigo endereço com o seguinte conteúdo:

<?php
header(“HTTP/1.1 301 Moved Permanently”);
header(“location:http://www.dominio.com.br“);
exit;
?>

Este é um modelo simples de redirecionamento, que faz com que o servidor passe a encaminhar os acessos para o endereço especificado, usando o código 301, que indica que a página mudou permanentemente de endereço.

O problema é que fazendo isso o redirecionamento funcionaria apenas para os visitantes que acessassem a página principal do site. Um visitante que tentasse acessar o “http://dominio.provedor.com.br/produtos/index.php?id=312“, por exemplo, receberia um erro 404.

Usando o mod_rewrite, você poderia solucionar isso de forma muito simples. O primeiro passo é verificar se o módulo está carregado na configuração do Apache 2. No caso das distribuições derivadas do Debian, você pode ativá-lo usando o comando a2enmod:

# a2enmod rewrite

Muito provavelmente você receberá um “This module is already enabled!” como resposta, já que ele vem ativo por padrão na maioria das instalações. No caso do Fedora, CentOS e outras distribuições derivadas do Red Hat, verifique o arquivo “/etc/httpd/conf/httpd.conf” e, caso necessário, descomente as linhas:

LoadModule rewrite_module modules/mod_rewrite.so
AddModule mod_rewrite.c

Depois de checar a ativação do módulo, falta apenas a configuração, que é feita através do arquivo “.htaccess“, criado no diretório raiz do site antigo (ou seja, na pasta de arquivos do “http://dominio.provedor.com.br”). Embora o .htaccess seja geralmente associado com o uso de senhas, ele na verdade tem diversos outros usos, incluindo a configuração do mod_rewrite.

Para que o mod_rewrite passe a encaminhar todas as requisições automaticamente, o conteúdo do arquivo “.htaccess” seria:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule (.*) http://www.dominio.com.br/$1 [R=301,L]
</IfModule>

A linha “RewriteEngine On” é a responsável por encaminhar as requisições ao mod_rewrite, enquanto a linha “RewriteRule (.*) http://www.dominio.com.br/$1 [R=301,L]” explica o que deve ser feito.

Apesar de parecer estranha à primeira vista, ela segue na verdade uma lógica bastante simples. O “(.*)” cria uma regra de encaminhamento, que será aplicada a qualquer URL dentro do domínio. A página especificada pelo visitante ao acessar o site vira uma variável ($1), que é então usada no parâmetro seguinte, o “http://www.dominio.com.br/$1” onde é indicado o novo domínio do site.

Com isso, se o visitante tentar acessar o “http://dominio.provedor.com.br/produtos/index.php?id=312” do exemplo anterior, a variável “$1″ será carregada com o valor “produtos/index.php?id=312″ e ele será encaminhado ao “http://www.dominio.com.br/produtos/index.php?id=312“. O mesmo se aplica a qualquer outra URL que ele vier a tentar acessar.

Concluindo, o “[R=301,L]” é o código de retorno que será enviado ao cliente. No caso estamos usando o código 301, que é o código de redirecionamento permanente. Além de encaminhar os visitantes, ele faz com que o Google indexe a nova página e transfira o pagerank da página antiga para ela. Normalmente, a atualização do pagerank demora cerca de 3 meses, mas depois de feita a atualização o novo endereço deverá receber o mesmo pagerank do antigo.

Outro uso comum para o mod_rewrite é a simplificação dos links, transformando URLs de páginas dinâmicas, como, por exemplo, “http://www.dominio.com.br/produtos/index.php?id=312” em URLs mais simples, como “http://www.dominio.com.br/produtos/312/” ou “http://www.dominio.com.br/312.htm”

Nesse caso, criamos regras do rewrite que o orientam a detectar acessos à URL simplificada e encaminhar as requisições para a URL “real” de forma transparente, novamente através do uso de variáveis.

Para converter as URLs do formato “http://www.dominio.com.br/index.php?id=numero” para “http://www.dominio.com.br/numero/”, você usaria o seguinte modelo de arquivo .htaccess:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule (.*)/$ /index.php?id=$1
</IfModule>

Com isso, ao acessar o “http://www.dominio.com.br/512/“, por exemplo, o visitante veria a página “http://www.dominio.com.br/index.php?id=512“, o que mascara a complexidade da URL. Se você preferir que os links abreviados tenham a aparência de páginas com extensão .htm, em vez de pastas, o arquivo .htaccess ficaria:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule (.*)\.htm$ /index.php?id=$1
</IfModule>

A mesma regra pode ser aplicada também a pastas específicas. Se você quiser que ela se aplique apenas à pasta “produtos”, sem ser aplicada a outras pastas do servidor, por exemplo, você poderia usar uma regra como:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule /produtos/(.*)\.htm$ /produtos/index.php?id=$1
</IfModule>

É possível também usar diversos parâmetros simultaneamente, facilitando o acesso a URLs que incluam um grande volume de argumentos, como em “http://www.dominio.com.br/index.php?cat=produtos&cat=info&id=23“, desde que você consiga bolar um formato de URL que permita incluir todos os parâmetros necessários, como em:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteRule (.*)/(.*)/(.*)/$ /index.php?cat=$1&cat=$2&id=$3
</IfModule>

Com isso, os três parâmetros que precisam ser incluídos na URL são digitados pelo usuário na forma de uma sequência de subpastas, como em “http://www.dominio.com.br/produtos/info/23/” e o mod_rewrite converte automaticamente as URLs ao formato usado pelo servidor.

À primeira vista, pode parecer uma mera mudança cosmética, mas o uso das URLs amigáveis facilita bastante a navegação do visitante e pode ajudar até mesmo na indexação por parte dos mecanismos de busca.

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

1) Introdução

Muitos administradores de sistemas GNU/Linux irão, algum dia, se deparar com a situação de precisar automatizar uma tarefa – um backup, por exemplo. Nesta hora, surge a necessidade de se dominar bem a execução sequenciada de comandos. E mais! Encontrar um modo de colocar esta sequência de comandos em algum lugar para sua execução. É neste momento que entra o domínio, por parte do administrador, da criação de scripts!

Quando se fala de/sobre Shell Script, temos que ter em mente que, ao que for se aventurar nesta área, deve ter o domínio de comandos de Shell. Bem como, entender como funciona uma Shell. O usuário (administrdor) deve conhecer redirecionamentos e pipes (dutos). Conhecer comandos e suas opções e, principalmente, sua sintaxe correta.

O aprendiz deve conhecer, também, o processo de inicialização do sistema GNU/Linux e o funcionamento dos arquivos de configuração de muitos serviços e módulos do sistema. É bom que também tenha conhecimento de rede (endereçamento IP, MAC Address, etc) e do funcionamento dos serviços de rede (conceitos), tais como: DHCP, DNS, etc…

SHELL SCRIPT

Shell Script é uma sequência de comandos que serão interpretados pela SHELL sequencialmente, dentro de um arquivo (txt – ascii) que foi previamente pré-programado (editado).

Um script contém uma sequência de comandos que seriam executados na Shell interativa, permitindo que tarefas longas (e/ou repetitivas), ou que exijam cuidados, sejam executados de forma rápida e invariável.

A Shell do GNU/Linux permite (implementa) uma linguagem própria de programação.

- Sequência de comandos que serão interpretados pela SHELL sequencialmente, dentro de um arquivo pré-programado

- Um script contém uma sequência de comandos que seriam executados na shell interativa, permitindo que tarefas longas (e/ou repetitivas), ou que exijam cuidados, sejam executados de forma rápida e invariável

- Todo SHELL SCRIPT deve ter sua permissão de execução habilitada

- Necessidade de cuidados com comandos de usuários em processos de root

O que é SHELL?

Shell pode ser entendido como um programa (ou uma interface) em modo texto que interage com o usuário, permitindo este, passar comandos ao sistema operacional. Para quem usava DOS, como eu (que Deus o tenha! ), deve se lembar que a Shell que interagia com o usuário era o command.com.

No GNU/Linux, existe não somente uma, mas algumas Shells que o usuário poderá utilizar! A Shell padrão utilizada na maioria das distribuições é a BASH (Bourne Again Shell). Esta deriva da SH (Bourne Shell). Dentre outras Shells disponíveis para GNU/Linux, destacam-se: CSH (C Shell); TCSH (Tenex/Tops C Shell); KSH (Korn Shell) muito comum no Unix.

* Sempre que um Shell Script for necessário, deve-se, primeiro, criar um arquivo texto padrão ascii. Isto pode ser providenciado com o editor VI – você sabe usá-lo, não sabe!?

* Um Shell Script, por convensão, recebe um nome – este pode ser de sua preferência – e um sufixo ( o “.sh”), este, por causa da Shell. Um arquivo de script se chamaria, por exemplo, de script1.sh. Muitos administradores adotam um nome que indicam a funcionalidade do script. Por exemplo: backup.sh, alerta_intruso.sh, renomeia.sh, firewall.sh, etc. Não invente muito!

* A localização do script é outro fator que deve ser levado em conta. Por definição do padrão LSB (Linux Standard Base – Base de Padronização Linux), o diretório que contém arquivos de configuração e scripts é o /etc. Entretanto, scripts que têm função de comando (como o ldd, por exemplo), ficam no /usr/bin/ (aposto que muitos não sabiam disto!). A localização de seu script dependerá de sua funcionalidade – eu costumo colocar meus scripts no /etc/rc.d/ (quando uso Mandriva – ou semelhante), ou então, no /etc/init.d/ (quando uso Debian – ou semelhante). Seja coerente e, por favor, não fuja do padrão!

* Ao se criar um arquivo no GNU/Linux (seja na Shell com o comando touch, ou diretamente no editor vi), o arquivo terá as permissões 644 (ou 664) – permissão de leitura e sem o bit (permissão) de execução habilitado. Neste caso, você terá que, toda vez que criar o seu script, alterar(habilitar) a permissão de execução nele.

* Ao se colocar o script dentro do diretório /etc (ou abaixo deste), o caminho (PATH) não aponta para este diretório. Ou seja, se seu script for colocado neste diretório, terá que ser executado por alguém, ou chamado à partir de algum lugar: outro script, cron, rc.local (se sua distro tiver!), etc. Esteja ciente disto!* Um Shell Script é interpretado (executado) sequencialmente. Ou seja, um comando é executado dentro do script e, o próximo comando só é executado, quando do término do anteriror.

2) Estrutura de um SHELL SCRIPT

#!/bin/bash    <|=—————————–| Programa Interpretador (shell)
#
#
# Criado por Katan  <|=———————| Comentários iniciais
#
##############

VAR=valor <|=—————————-|
VAR2=valor2 <|=—————————-| Declaração de Variáveis
VAR3=`resultado_comando` <|=——-|

comando1 <|=——————————–|
comando2 <|=——————————-| Comandos do SHELL
comandoN <|=——————————-|

A primeira linha de um Shel Script deve conter, obrigatoriamente, o interpretador do script(!?). Viajou? Calma! Não se assuste!

A linguagem de Shell Script é interpretada. Diferentemente de um programa feito em C, Delphi, por exemplo, que necessita de ser compilado para ser executado, o Shell Script não tem esta necessidade. Entretanto, algum programa deverá interpretar o script e passá-lo ao kernel pra ser executado. Por se tratar de execução de comandos da Shell, na maioria das vezes, quem deverá interpretá-los é a própria Shell. A sintaxe para a definição deve ser o #! (hash e exclamação) seguido do interpretador (caminho completo), no caso da Shell, /bin/bash. Alguns scripts podem ser feitos em perl, por exemplo. Neste caso, o interpretdor seria #!/usr/bin/perl.

À partir da segunda linha, o script se inicia verdadeiramente. Mas, como de praxe em programação Shell, a sequência à seguir após o interpretador, é comum a adição da autoria do script (quem o fez), bem como sua versão, data de criação, etc.

Detalhe: Toda linha que começa com um “#” (hash) é tida como comentário (em script Shell). Ou seja, o interpretador /bin/bash irá ignorar sua existência – o hash (e o script) podem conviver com isto!

Após feitas as apresentações inciais no começo do script, é comum à partir deste ponto, a declaração (definição) de variáveis.

O uso de variáveis em script, facilita a progração, pois, pode conter (guardar) um valor que poderá ser utilizado quantas vezes for ncessário em todo o script.

Imagine a situação de um script de firewall onde, o IP de sua conexão de internet terá que ser utilizado dezenas de vezes. Quando este valor de IP for alterado, terá que modificado em todo o script! Quando utilizamos variáveis, basta alterar no valor da variável declarado no início so script, que o novo valor será aproveitado em todo script!

#!/bin/bash
#script 1
echo “Olá. Este é meu primeiro script!”
date
uname -a
echo
echo “Veja o calendário de Dezembro de 2012”
echo
cal 12 2012

Baixe AQUI

Executando o script
[user@localhost ~] $ bash script1.sh

OU

[user@localhost ~] $ chmod +x script1.sh
[user@localhost ~] $ ./script1.sh

#!/bin/bash
# Script 2
# Concatenação de comandos
clear
echo -n “O IP da placa de rede é:” ; /sbin/ifconfig eth0 | grep “inet end” | cut -d”:” -f2 | cut -d” ” -f2
echo
echo -n “Hoje é: ” ; date +%A
uname -a

Baixe AQUI

#!/bin/bash
# Script 3
# Trabalhando com variáveis
clear
# Definição das variáveis
A=1
B=”O valor de A é: $A”
echo $B

Baixe AQUI

Variáveis de Ambiente

HOME                   Diretório home do usuário
SHELL                  Shell do usuário
TERM                    Tipo de terminal que o usuário está usando
PATH                    Caminhos (diretórios) de pesquisa de comandos
USER                   Nome de login do usuário
LOGNAME            Nome de login do usuário – mesmo que USER
HISTSIZE             Tamanho do histórico de comandos
BASH                   Caminho da shell que está usando
BASH_VERSION   Versão da SHELL
OSTYPE                Tipo de sistema operacional
LANG                   Codificação de caracteres – idioma
HOSTNAME          Nome de host da máquina

Trabalhando com variáveis

set
Retorna todas as variáveis locais

env
Retorna todas as variáveis globais

Definindo uma variável:
LINUX=semvirus
export LINUX
echo $LINUX

Zerando uma variável:
unset LINUX

[user@localhost ~]$ LINUX=semviruses
[user@localhost ~]$ echo $LINUX
semviruses
[user@localhost ~]$ set | grep LINUX
LINUX=semviruses
[user@localhost ~]$ env | grep LINUX
[user@localhost ~]$ export LINUX
[user@localhost ~]$ env | grep LINUX
LINUX=semviruses
[user@localhost ~]$ unset LINUX
[user@localhost ~]$ env | grep LINUX
[user@localhost ~]$

Trabalhando com variáveis

VAR=”valor”
valor poderá assumir qualquer valor, inclusive outras variáveis
$, \ e `(crase) são interpretados com especiais – “\” anula “$”

VAR=’valor’
valor irá assumir exatamente valor. Apostrofo anula valor de variáveis
Nenhum caracter especial tem valor

VAR=`valor`   ou    VAR=$(valor)
valor será resultado de comando

Trabalhando com variáveis

VAR1=”valor1”
VAR2=”valor2 $VAR1”
VAR1 recebe valor1 e VAR2 recebe valor2 mais o resultado de VAR1

[user@localhost ~]$ VAR1=”valor1”
[user@localhost ~]$ VAR2=”valor2 e $VAR1”
[user@localhost ~]$ echo $VAR2
valor2 e valor1

##=-.__________
VAR1=”valor1”
VAR2=”valor2 ‘$VAR1′ ”
VAR1 recebe valor1 e VAR2 recebe valor2 mais o resultado de VAR1. Aspas anula efeito de apostrofo

[user@localhost ~]$ VAR1=”valor1”
[user@localhost ~]$ VAR2=”valor2 e ‘$VAR1′ ”
[user@localhost ~]$ echo $VAR2
valor2 e ‘valor1′

##=-.__________
VAR1=”valor1”
VAR2=”valor2 \$VAR1 ”
VAR1 recebe valor1 e VAR2 recebe valor2 mais $VAR1 (literal). Contra-barra anula efeito do $ (dólar)

[user@localhost ~]$ VAR1=”valor1”
[user@localhost ~]$ VAR2=”valor2 e \$VAR1”
[user@localhost ~]$ echo $VAR2
valor2 e $VAR1

##=-.__________
VAR1=”valor1”
VAR2=”valor2 $VAR1 e hoje é `date +%A`”
VAR1 recebe valor1. VAR2 recebe valor2 mais resultado de $VAR1 e mais o resultado do comando date +%A.

[user@localhost ~]$ VAR1=”valor1”
[user@localhost ~]$ VAR2=”valor2 $VAR1 e hoje é `date +%A`”
[user@localhost ~]$ echo $VAR2
valor2  valor1 e hoje é NNN

##=-.__________
Trabalhando com variáveis

VAR1=’valor1′
VAR2=’valor2 $VAR1′
VAR1 recebe valor1 e VAR2 recebe valor2 mais $VAR1. Apostrofo anula efeito do $ (dólar).

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 e $VAR1′
[user@localhost ~]$ echo $VAR2
valor2 e $VAR1

##=-.__________
VAR1=’valor1′
VAR2=’valor2 “$VAR1” ‘
VAR1 recebe valor1 e VAR2 recebe valor2 mais $VAR1. Apostrofo anula efeito da aspas e do $ (dólar).

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 e “$VAR1” ‘
[user@localhost ~]$ echo $VAR2
valor2 e “$VAR1”

##=-.__________
VAR1=’valor1′
VAR2=’valor2 ‘$VAR1′ ‘
VAR1 recebe valor1 e VAR2 recebe valor2 mais resultado de $VAR1. Apostrofo proteje efeito $ (dólar) – da variável.

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 e ‘$VAR1′ ‘
[user@localhost ~]$ echo $VAR2
valor2 e valor1

##=-.__________
VAR1=’valor1′
VAR2=’valor2 \$VAR1′
VAR1 recebe valor1 e VAR2 recebe valor2 mais $VAR1. Apostrofo anula efeito da \ (contra-barra).

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 e \$VAR1 ‘
[user@localhost ~]$ echo $VAR2
valor2 e \$VAR1

##=-.__________
VAR1=’valor1′
VAR2=’valor2 $VAR1 e hoje é `date +%A`’
VAR1 recebe valor1 e VAR2 recebe valor2 mais $VAR1. Apostrofo anula efeito da \ (contra-barra).

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 $VAR1 e hoje é `date _%A` ‘
[user@localhost ~]$ echo $VAR2
valor2 $VAR1 e hoje é `date +%A`

##=-.__________
VAR1=’valor1′
VAR2=’valor2 $VAR1 e hoje é ‘ `date +%A` ‘ ‘
VAR1 recebe valor1. VAR2 recebe valor2 mais $VAR1 (literal) e “e hoje é” mais o resultado do comando date. Segundo uso do apostrofo protege a execução do comando

[user@localhost ~]$ VAR1=’valor1′
[user@localhost ~]$ VAR2=’valor2 $VAR1 e hoje é `date +%A` ‘
[user@localhost ~]$ echo $VAR2
valor2 $VAR1 e hoje é NNN

##=-.__________
VAR=`valor`   ou    VAR=$(valor)
valor será resultado de comando

[user@localhost ~]$ VAR1=`ifconfig  eth0 | grep “inet end” | cut -d”:” -f2 | cut -d” ” -f2`
[user@localhost ~]$ echo $VAR1
192.168.0.2

[user@localhost ~]$ VAR1=$(ifconfig  eth0 | grep “inet end” | cut -d”:” -f2 | cut -d” ” -f2)

##=-.__________

#!/bin/bash
# Script 4
# Trabalhando com variáveis de ambiente
clear

echo “Você pode visualizar os últimos $HISTSIZE comandos digitados”

echo “Seu diretório HOME é: $HOME”

echo “O tipo de terminal que está usando é: $TERM”

echo “E a SHELL de trabalho é: $SHELL”

Baixe AQUI

#!/bin/bash
# Script 5
# Trabalhando com variáveis definidas pelo usuários
clear

# Definição das variáveis
IP_ETH0=`/sbin/ifconfig eth0 | grep “inet end” | cut -d”:” -f2 | cut -d” ” -f2 `
UID_ALUNO=$(grep aluno /etc/passwd | cut -d”:” -f3)

# Exibição dos valores das variáveis
echo “O IP da placa ETH0 é: $IP_ETH0″
echo
echo “O usuário ALUNO tem UID = $UID_ALUNO”

Baixe AQUI

#!/bin/bash
# Script 6
# Executando comandos dentro do echo
clear
echo “hoje é: `date`”
echo  “O usuário `who | cut -d” ” -f1 | sort -u` está logado agora”

Baixe AQUI

Variáveis de SHELL (pré-definidas)

$$        PID do shell em execução

$?        Código de retorno do último comando
0 = verdadeiro – executado com sucesso
1 = falso – executado com falha
2 = permissão negada / diretório inexistente
126 = Comando não executável (sem permissão)
127 = comando inexistente (NOT_FOUND)
128 = O parâmetro para o ‘exit’ não é um decimal
128+n = 128 + código do sinal que o matou.
130 = O programa interrompido com o Ctrl+C (128 + 2)
255 = Parâmetro para o ‘exit’ não está entre 0 e 255

$!                Código de retorno do último comando executado em segundo plano
$0               Nome do arquivo contendo o shell script em execução
$1, $2, …    Cada parâmetro passado ao script na linha de comando
$#              Número parâmetros passados ao script na linha de comando
“$*”           Mesmo que “$1 $2 $3 …”

“$@”          Mesmo que “$1” “$2” “$3” …

#!/bin/bash
# Script 7
# Trabalhando com variáveis de SHEL
clear

date

Baixe AQUI

#!/bin/bash
# Script 8
# Trabalhando com variáveis de SHEL
#
echo “O nome do script é $0”
echo “Foram recebidos $# argumentos”
echo “Argumento 1: $1”
echo “Argumento 2: $2”
echo “Argumento 3: $3”

Baixe AQUI

Execute:

[root@localhost ~]# ./script8.sh linux free opensource

#!/bin/bash
# Script 9
# Rotacionando variável
#
echo “$1” “$2”
# Rotacionando
shift
echo “$1” “$2”
# Rotacionando
shift
echo “$1” “$2”

Baixe AQUI

Execute:

[root@localhost ~]# ./script9.sh linux free opensource noviruses
linux  free
free  opensource
opensource  noviruses

#!/bin/bash
# Script 10
# Interagindo com o usuário
#
echo -n “Por favor, digite seu nome: “
read NOME
echo
echo “Seu nome é: $NOME”
date
#FIM

Baixe AQUI

#!/bin/bash
# Script 11
# Interagindo com o usuário – calculando tamanho da variável
#
echo -n “Por favor, digite seu nome: “
read NOME
echo
echo “Seu nome é: $NOME”
echo “Seu nome possui `expr length $NOME` letras”
#FIM

Baixe AQUI

#!/bin/bash
# Script 12
# Interagindo com o usuário – condicionando digitação
#
echo -n “Por favor, digite seu nome: “
read NOME
echo
echo -n “Digite sua senha: “
read -s SENHA
echo
echo -n “Digite uma letra: “
read -n 1 KEY
clear
echo “Seu nome é: $NOME”
echo “Sua senha é: $SENHA”
echo “A letra digitada foi: $KEY”

Baixe AQUI

#!/bin/bash
# Script 13
# Interagindo com o usuário – condicinando digitação
#
clear
echo -ne “Digite uma letra: [S] ou [N]: [ ]“ ‘\033[3D'
read -n 1 KEY
echo
clear
echo  “A letra digitada é: $KEY”

Baixe AQUI

Opções do echo:
-n        Não pula linha
-e        Interpreta após o “ (aspas)

Caracteres de “escape”: \033[XN
Onde:

\033[    Código hexadecimal para ESC
X          Código hexadecimal de cores e/ou casas de movimentação
N          Código de movimento (uma letra) ou m para cores

N para movimentação:
xA       x linhas para cima, na mesma coluna
xB       x linhas para baixo, na mesma coluna
xC       x colunas para direita, na mesma linha
xD       x colunas esquerda, na mesma linha
xE       x linhas para baixo, na mesma coluna
xF        x linhas para cima, na mesma coluna
xG       para a coluna x da coluna atual
x;yH    para a coluna y da linha x

X para cores:
Cor             Letra     Fundo       ##         Atributo     Valor     ##     Exemplos: ESC [ <N>;<N> m
preto          30         40             ##         reset          0         ESC[0m texto normal (desliga cores)
vermelho   31         41             ##         negrito        1         ESC[1m negrito
verde         32         42             ##         sublinhado  4         ESC[33;1m amarelo
amarelo     33         43             ##         piscando     5         ESC[44;37m fundo azul, letra cinza
azul            34         44             ##        reverso        7         ESC[31;5m vermelho piscando
rosa           35         45
ciano         36         46
branco       37         47

Na linha de comando:

[root@localhost ~]# echo -e ‘\033[33;1m amarelo \033[0m'
[root@localhost ~]# echo -e ‘\033[42;31;1m Seja livre. Use Linux \033[0m'
[root@localhost ~]# echo -e ‘\033[42;31;5m Seja livre. Use Linux \033[0m'

#!/bin/bash
# Script 14
# Interagindo com o usuário – formatando  exibição
#
clear
echo -ne “\033[42;31;1m Digite uma letra: [S] ou [N]: [ ]“’\033[2D''\033[0m'
read -n 1 KEY
echo
clear
echo  “A letra digitada é: $KEY”

Baixe AQUI

Expansão de variáveis

${var:-texto}     Se var não está definida, retorna 'texto'
${var:=texto}   Se var não está definida, defina-a com 'texto'
${var:?texto}    Se var não está definida, retorna o erro 'texto'
${var:+texto}   Se var está definida, retorna 'texto', senão retorna o vazio

#!/bin/bash
# Script 15
# Expandindo variáveis
#
clear
VAR1=Linux
echo “$VAR1 ${VAR1:-free}”
echo “$VAR1 ${VAR2:-free}”
echo “A variável \$VAR1  é: $VAR1”
echo “A variável \$VAR2  é: $VAR2”

VAR2=”Open Source”
echo “$VAR1 ${VAR2:-free}”
echo “A variável \$VAR1  é: $VAR1”
echo “A variável \$VAR2  é: $VAR2”

Baixe AQUI

Resultado do script 15

[root@localhost ~]# ./script15.sh
Linux Linux
Linux free
A variável $VAR1  é: Linux
A variável $VAR2  é:
Linux Open Source
A variável $VAR1  é: Linux
A variável $VAR2  é: Open Source

#!/bin/bash
# Script 16
# Expandindo variáveis
#
clear
VAR1=
VAR2=Linux
echo “A variável \$VAR1  é: $VAR1”
echo “A variável \$VAR2  é: $VAR2”
echo “$VAR1 ${VAR2:?free}”
echo “$VAR1 ${VAR1:?erro}”

Baixe AQUI

Resultado do script 16

[root@localhost ~]# ./script16.sh
A variável $VAR1  é:
A variável $VAR2  é: Linux
Linux
./script16.sh: line XX:  VAR1: erro

Trabalhando com variáveis – reduzindo variáveis

[user@hostname ~]$ VAR=”valor-nome”
[user@hostname ~]$ echo ${VAR%-nome}
valor
Exibe até %. Exclui à partir de %

[user@hostname ~]$ VAR=”http://marcio.katan.googlepages.com”
[user@hostname ~]$ echo ${VAR#http://}
marcio.katan.googlepages.com
Retira da variável a parte passada por #

#!/bin/bash
# Script 17
# Reduzindo variáveis
#
clear
echo -n “Digite seu email: “
read EMAIL
echo
echo “O nome de usuário do email é: ${EMAIL%@*}”
echo “O domínio do email é: ${EMAIL#*@}”
VAR=”valor-nome”
echo “Retirando o ‘-nome’ de valor-nome: ${VAR%-nome}”
echo “Retirando o ‘valor’ de valor-nome: ${VAR#valor-}”

Baixe AQUI

Blocos de agrupamento

{…}             Agrupa comandos em um bloco                             { ls ; clear ; }
$((…))        Retorna o resultado de uma operação aritmética          $((5+3))

Operadores Aritméticos

+               Adição
-               Subtração
*               Multiplicação
/               Divisão
**              Exponenciação

#!/bin/bash
# Script 19
# Blocos de comandos / Operação aritimética

{ clear ; ls /tmp ; }
echo
sleep 5
echo “Veja o somatório de 5 + 5 = $((5 + 5))”
sleep 5

Baixe AQUI

Operadores de Atribuição/Relacionais/de Bit

=       Atribui valor a uma variável
++      Incrementa em 1 o valor da variável
- -     Decrementa em 1 o valor da variável
==      Igual
!=      Diferente
>       Maior
<       Menor
>=      Maior ou igual
<=      Menor ou igual
&&      E lógico (AND)
||      OU lógico (OR)

#!/bin/bash
#
#  Script 20
#
# Operadores de Atribuição

((VAR2 > 6))
echo “O valor de VAR2 é maior que 6 – FALSO. Por isso, \$? deve ser 1: é $?”

Baixe AQUI

ARRAYs

Um array consiste em uma estrutura de dados correlacionados entre si (geralmente dentro de uma mesma variável). Um array pode ser declarado das seguintes maneiras:

ARRAY=(valor1  valor2  valor3  valorN …)
ou
ARRAY[0]=”valor1”
ARRAY[1]=”valor2”
ARRAY[2]=”valor3”
ARRAY[N]=”valorN”

Um ARRAY tem seus valores retornados da seguinte maneira:

${ARRAY[N]}           Retorna o valor N do array
${ARRAY[@]}          Retorna todos os valores do array
${#ARRAY[@]}       Retorna a quantidade de valores do array
${ARRAY[@]:2}       Retorna os valores do array à partir da posição 2 (3° valor)
${ARRAY[@]:1:2}    Retorna os valores do array da posição 1 até 2 (2° e 3° valores)

Veja um exemplo de script utilizando array:

#!/bin/bash
#
#  Script 21
#
# Trabalhando com ARRAYs
clear

SOMA_NOTAS=”$((${NOTA[0]} + ${NOTA[1]} + ${NOTA[2]} + ${NOTA[3]}))”
echo “As notas somaram: $SOMA_NOTAS”
echo “A média do aluno foi: $((${SOMA_NOTAS} / 4))”
echo “A média do aluno foi: `expr ${SOMA_NOTAS} / 4`”   <|=-##*Cuidado com a crase!
echo

Baixe AQUI

Trabalhando com Arrays com interação com o usuário:

#!/bin/bash
###
#
# Script 22
# Teste com ARRAYs
clear

echo -n “Calculando a média aluno: $((${SOMA_NOTAS} / 4))”
echo

Baixe AQUI

Teste Condicionais em scripts:

se [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
comando2
comandoN
senão
# se condição acima for falsa, executa comandos abaixo
comando1
coamndo2
comandoN
fim

if [ condição ] ; then
# se condição acima for verdadeira, executa comandos abaixo
comando1
comando2
comandoN
else
# se condição acima for falsa, executa comandos abaixo
comando1
coamndo2
comandoN
fi

Ou então, podemos realizar vários testes – ou poderemos ter várias opções para o teste:

se [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
comando2
comandoN
ou se [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
coamndo2
comandoN
ou se [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
coamndo2
ComandoN
fim

if [ condição ] ; then
# se condição acima for verdadeira, executa comandos abaixo
comando1
comando2
comandoN
elif [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
coamndo2
ComandoN
elif [ condição ] ; então
# se condição acima for verdadeira, executa comandos abaixo
comando1
coamndo2
comandoN
fi

condição – Teste em arquivo

-e        Se arquivo existe
-x        Se arquivo é executável (tem permissão de execução)
-w        Se arquivo tem permissão de escrita
-r        Se arquivo tem permissão de leitura
-u        Se bit SUID está ativado
-g        Se bit SGID está ativado
-d        Se é um diretório
-f        Se é um arquivo regular
-L        Se arquivo é um link simbólico
-b        Se arquivo é um dispositivo de bloco
-c        Se arquivo é um dispositivo de caractere
-S        Se arquivo é um SOCKET
-p        Se arquivo é um PIPE
-k        Se Stick bit está ativado
-s        O tamanho do arquivo e maior que zero ( > 0)

Condição – Teste em arquivo

-nt        Se arquivo é mais recente (Newer Than)
-ot        Se arquivo é mais antigo (Older Than)
-ef        Se arquivo é o mesmo

Condição – Comparação

-lt        Se é menor que (Less Than)
-gt        Se é maior que (Greater Than)
-le        Se é menor ou igual (Less Equal)
-ge        Se é maior ou igual (Greater Equal)
-eq        Se é igual (Equal)
-ne        Se é diferente (Not Equal)

condição – Teste aritiméticos (strings)

=        Se é igual
!=        Se é diferente
-n        Se não é nulo
-z        Se é nulo

Operadores Lógicos

!        Não Lógico (NOT)
-a        E Lógico (AND)
-o        OU Lógico (OR)

[ condição1 ] && [ condição2 ]
Testa condição2 se, e somente se, condição1 for satisfeita

[ condição1 ]  | |   [ condição2 ]
Testa condição1 . Executa teste de condição 2 se condição retorna erro

#!/bin/bash
#
#  Script 23
#
# Estruturas Condicionais – IF ; THEN / FI
clear
ARQ=arquivo_teste
if [ -e $HOME/$ARQ ] ; then
echo “Arquivo existente!”
echo “Olha ele aí!”
ls -l $HOME/$ARQ
else
echo “Arquivo não existe. Criando-ô!”
touch $HOME/$ARQ
fi

Baixe AQUI

Usando o comando test :

#!/bin/bash
#
#  Script 23B
#
# Estruturas Condicionais – IF ; THEN / FI
clear
ARQ=arquivo_teste
if test -e $HOME/$ARQ ; then
echo “Arquivo existente!”
echo “Olha ele aí!”
ls -l $HOME/$ARQ
else
echo “Arquivo não existe. Criando-ô!”
touch $HOME/$ARQ
fi

Baixe AQUI

#!/bin/bash
#
#  Script 23+1
#
# Estruturas Condicionais – IF ; THEN / FI
clear
echo -ne “Digite uma letra (S) ou (N): [ ]“ ‘\033[3D'
read -n 1 KEY
echo
if [ “$KEY” = “s” ] ; then
echo  “A letra digitada é $KEY”
elif [ “$KEY” = “n” ] ; then
echo “A letra digitada é $KEY”
else
echo “ Voce digitou $KEY. Não foi o que pedi”
fi

Baixe AQUI

#!/bin/bash
#
#  Script 25
#
# Estruturas Condicionais – IF ; THEN / FI
clear
echo -ne “Digite uma letra (S) ou (N): [ ]“ ‘\033[3D'
read -n 1 KEY
echo
if [ “$KEY” = “s” ] || [ “$KEY” = “S” ] ; then
echo  “A letra digitada é $KEY”
elif [ “$KEY” = “n” ] || [ “$KEY” = “N” ] ; then
echo “A letra digitada é $KEY”
else
echo “ Voce digitou $KEY. Não foi o que pedi”
fi

Baixe AQUI

#!/bin/bash
#
#  Script 26
# Estruturas Condicionais – IF ; THEN / FI
clear

if [ “$OPER” = “+” ] ; then
echo “O resultado da adição é: $(($NUM1 $OPER $NUM2))”
fi
if [ “$OPER” = “-” ] ; then
echo “O resultado da subtração é: $(($NUM1 $OPER $NUM2))”
fi

Baixe AQUI

#!/bin/bash
#
#  Script 27
# Estruturas Condicionais – IF ; THEN / FI
clear

if [ “$OPER” = “+” ] ; then                                   |  |
echo “O resultado da adição é: $(($NUM1 $OPER $NUM2))”
fi                                                            |  |
###
if [ “$OPER” = “-” ] ; then                                   |  |
echo “O resultado da subtração é: $(($NUM1 $OPER $NUM2))”
fi                                                            |  |

else <>=———————————————————| |

echo “Você digitou um número não autorizado”                     |

exit 0                                                           |
fi
else   <>=—————————————————————|
echo “Você digitou um número não autorizado”

exit 0
fi

Baixe AQUI

Usando o if para realizar execução com parâmetros passados pela linha de comando:

#!/bin/bash
#
#  Script 28
# Estruturas Condicionais – IF ; THEN / FI
#
HELP=”Este programa exibe a data local
Uso: ./script28.sh [opções]

-h    Exibe o help do script
-d    Exibe somente o dia da semana
-D    Exibe somente o dia do mês corrente
”
if [ "$1" = "-h" ] ; then
echo “$HELP”
exit 0
elif  [ "$1" = "-d" ] ; then
echo “Hoje é `date +%A`”
exit 0
elif [ "$1" = "-D" ] ; then
echo “Hoje é o dia `date +%d` do mês”
exit 0

else

echo “Opção $1 inválida. Execute $0 -h par ajuda”

exit 0
fi

echo “Hoje é `date +%A`, `date +%d` de `date +%B`  de  `date +%Y` ”

Baixe AQUI

#!/bin/bash
#
#  Script 29
# Estruturas Condicionais – IF ; THEN / FI
#Backup simples
clear

if [ `date +%a` = Dom ] ; then
echo “Hoje é dia de backup”
tar -czf /tmp/backup.tar.gz  /etc
else
echo “Hoje não é dia de Backup. Vá tomar umas cervejas”
fi

Baixe AQUI

Campos de Tempo do comando date

%H        hora (00..23);
%I        hora (01..12); i maiúsculo
%k        hora (0..23);
%l        hora (1..12); L minúsculo
%M        minuto (00..59);
%p        período local AM ou PM;
%r        tempo, 12-horas (hh:mm:ss[AP]M);
%s        segundos  desde  1970-01-01  00:00:00  UTC  (uma  extensão não padrão)
%S        segundo (00..60);
%T        tempo, 24-horas (hh:mm:ss);
%X        representação do tempo local (%H:%M:%S);
%Z        zona  de  tempo  (por  exemplo:  EDT  (Easterm Day Time) [horário diurno do leste, ou nada se nenhuma zona for determinada);

Campos de Data do comando date:

%a        nome do dia da semana local abreviado (Dom..Sab);
%A        nome do dia da semana local completo, tamanho variável (Domingo..Sábado);
%b        nome do mês local abreviado (Jan..Dez);
%B        nome  do  mês  local completo, tamanho variável (Janeiro..Dezembro);
%c        data e hora local (Sab Nov 04 12:02:33 EST 1989);
%d        dia do mês (01..31);
%D        data (mm/dd/yy);
%h        o mesmo que %b;
%j        dia do ano (001..366);
%m        mês (01..12);
%U        número da semana no ano com Domingo como o primeiro dia da  semana (00..53);
%w        dia da semana (0..6) com o 0 correspondendo ao Domingo;
%W        número da semana no ano com Segunda-feira como o primeiro dia da semana (00..53);
%x        representação da data local;
%y        últimos dois dígitos do ano (00..99);
%Y         ano (1970...).

enquanto [ condição_verdadeira ] ; faça
# enquanto condição acima for verdadeira, executa comandos abaixo
comando1
comandoN
finaliza

até_que [ condição_falsa ] ; faça
# enquanto condição acima for falsa, executa comandos abaixo
comando1
comandoN
finaliza

#########

while [ condição ] ; do
# enquanto condição acima for verdadeira, executa comandos abaixo
comando1
comandoN
done

until [ condição ] ; do
# enquanto condição acima for falsa, executa comandos abaixo
comando1
comandoN
done

#!/bin/bash
#
#  Script 30
# Estruturas Condicionais – while – LOOPs
#
clear
while true; do
echo “LOOP infinito!”
done

Baixe AQUI

#!/bin/bash
#
# Script 31
# Estruturas Condicionais – while – LOOPs
#
clear
X=1
until [ "$X" -gt "10" ]; do
echo “LOOP ate 10. Contando: $X ”
sleep 1
let X=X+1
done

Baixe AQUI

#!/bin/bash
#
# Script 32
# Estruturas Condicionais – while – LOOPs
#
clear
CONT=1
echo -ne “Quantas vezes devo executar o script? [ ]”’\033[2D'
read -n 1 VAL
clear
echo "Voce escolheu $VAL"
echo
sleep 2
clear
while [ "$CONT” -le “$VAL" ] ; do
echo “Executando pela $CONT vez!”
sleep 1
clear
CONT=$(expr $CONT + 1)
done

echo “TCHAU!!!”
sleep 2
clear

Baixe AQUI

#!/bin/bash
#
# Script 33
# Estruturas Condicionais – while – LOOPs
#
clear

while true ; do <|=————————————————|
echo -ne “Deseja sair do script? [S] [N]: [ ]“‘\033[2D'        |
read -n 1 KEY                                                  | Retorna para
echo                                                           | o início do
if [ "$KEY" = "n" ] || [ "$KEY" = "N" ] ; then                 | while
echo “OK! Vou continuar no script”                         |
sleep 2                                                    |
clear                                                      |
continue |>————————————————-
fi
if [ "$KEY" = "n" ] || [ "$KEY" = "N" ] ; then
echo “Saindo do script”
break |>———-|
fi                    | Sai do while
done <|——————-|

cal

Baixe AQUI

para <variável> assumir <valor(es)> ; faça
# Para cada  valor assumido pela variável, execute comandos abaixo
comando1
comando2
comandoN
finaliza

for <variável> in <valor(es)> ; do
# Para cada  valor assumido pela variável, execute comandos abaixo
comando1
comando2
comandoN
done

#!/bin/bash
#
# Script 34
# Estruturas Condicionais – Laços repetitivos
#
clear

for VAR in 1 2 3 4 5 6 7 8 9 10 ; do
echo “Executando pela $VAR vez”
sleep 1
clear
done

Baixe AQUI

#!/bin/bash
#
# Script 35
# Estruturas Condicionais – Laços repetitivos
#
clear

for VAR in `seq 1 10` ; do
echo “Executando pela $VAR vez”
sleep 1
clear
done

Baixe AQUI

#!/bin/bash
#
# Script 36
# Estruturas Condicionais – Laços repetitivos
#
clear

for ((X=1;X<=10;X++)); do
echo “Executando pela $X vez”
sleep 1
clear
done

Baixe AQUI

#!/bin/bash
#
# Script 37
# Estruturas Condicionais – Laços repetitivos
#
clear
for VAR in `seq 1 50` ; do
touch /tmp/script${VAR}.sh
echo “#!/bin/bash” > /tmp/script${VAR}.sh
echo “#            “ >> /tmp/script${VAR}.sh
echo “# Script $VAR” >> /tmp/script${VAR}.sh
echo “#            “ >> /tmp/script${VAR}.sh
echo “#            “ >> /tmp/script${VAR}.sh
chmod u+x /tmp/script${VAR}.sh
done

Baixe AQUI

#!/bin/bash
#
# Script 38
# Estruturas Condicionais – Laços repetitivos
#
clear
LS_DIR=$(ls /home)
echo “Fazendo Backup do diretório pessoal dos usuarios”
sleep 3
for VAR in `echo $LS_DIR` ; do
echo “Fazendo becape do diretório pessoal do usuario: $VAR”
tar -czf /tmp/backup-${VAR}-bkp.tar.gz /home/${VAR}
sleep 3
clear

ls -lh /tmp | grep ${VAR}

sleep 5

clear
done

Baixe AQUI

caso <variável> ser
valor1)
# Para valor1 assumido pela variável, execute comandos abaixo
comando1
;;
valor2)
# Para valor2 assumido pela variável, execute comandos abaixo
comando2
;;
valorN)
# Para valorN assumido pela variável, execute comandos abaixo
comando3
;;
finaliza

case <variável> in
valor1)
# Para valor1 assumido pela variável, execute comandos abaixo
comando1
;;
valor2)
# Para valor2 assumido pela variável, execute comandos abaixo
comando2
;;
valorN)
# Para valorN assumido pela variável, execute comandos abaixo
comando3
;;
esac

case <variável> in
valor1) comando1 ; comando1N ;;
valor2) comando2 ; comando2N ;;
valorN) comandoN ; comandoN ;;
esac

select <variável> in <valor1> <valor2> <valor3> <valorN> ; do
break
esac
comandos $variável

OU

select <variável> in <valor1> <valor2> <valor3> <valorN> ; do
case <$variável> in
valor1) comando1 ; comando1N ;;
valor2) comando2 ; comando2N ;;
valorN) comandoN ; comandoN ;;
esac

#!/bin/bash
#
# Script 39
# Estruturas Condicionais – SELETOR
#
clear
echo -ne “Pressione S ou N: [ ]“‘\033[2D'
read -n 1 KEY
echo
case $KEY in
s|S)
echo "Voce apertou $KEY"
;;
n|N)
echo "Voce apertou $KEY"
;;
*)
echo "Distraido. Eu mandei teclar S ou N. Abortando!"
;;
esac

Baixe AQUI

#!/bin/bash
#
# Script 40
# Estruturas Condicionais – SELETOR
#
clear
DATA=`date +%w`
case $DATA in
0) DIA="Hoje é Domingo" ;;
1) DIA="Hoje é Segunda" ;;
2) DIA="Hoje é Terça" ;;
3) DIA="Hoje é Quarta" ;;
4) DIA="Hoje é Quinta" ;;
5) DIA="Hoje é Sexta" ;;
6) DIA="Hoje é Sábado" ;;
esac
echo $DIA

Baixe AQUI

#!/bin/bash
#
# Script 41
# Estruturas Condicionais – SELETOR
#
clear
while true; do
echo -ne "\033[44;37;1m ##-._____________________________.-## \033[0m" '\n'
echo -ne "\033[44;37;1m #                                   # \033[0m" '\n'
echo -ne "\033[44;37;1m |       1) Pingar localhost         | \033[0m" '\n'
echo -ne "\033[44;37;1m |       2) Quem está logado         | \033[0m" '\n'
echo -ne "\033[44;37;1m |       3) IP da eth0               | \033[0m" '\n'
echo -ne "\033[44;37;1m |       4) Memoria                  | \033[0m" '\n'
echo -ne "\033[44;37;1m |       5) Espaço em disco          | \033[0m" '\n'
echo -ne "\033[44;37;1m |       x) Sair                     | \033[0m" '\n'
echo -ne "\033[44;37;1m #                                   | \033[0m" '\n'
echo -ne "\033[44;37;1m ##-._____________________________.-## \033[0m" '\n'
echo -ne "\033[44;37;1m                                       \033[0m" '\033[31D'
echo
echo -ne "\033[44;37;1m #       ( )Opção                    # \033[0m" '\033[31D'

case $RESP in
1) echo ; ping -c 5 localhost ;;
2) echo ; who ; sleep 5 ;;
3) echo ; ifconfig eth0 ; sleep 5 ;;
4) echo ; free -m ; sleep 5 ;;
5) echo ; df -h ; sleep 5 ;;
x) break ;;
*) echo ; echo “Opção invalida!” ; sleep 3 ;;
esac
done
echo

Baixe AQUI

#!/bin/bash
#
# Script 42
# Estruturas Condicionais – SELETOR
#
clear

echo "Qual sistema você prefere?"
select DATA in "Linux" "MacOS" "ruindozê XisPê" ; do
break
done
echo "Você prefere $DATA"

Baixe AQUI

<nome_função> () {
comando1
comando2
comando3
comandoN
}

nome_função

# Sempre que nome_função for invocado, execute a cadeia de comandos da função

<function_name> () {
comando1
comando2
comando3
comandoN
}

function_name

# Sempre que nome_função for invocado, execute a cadeia de comandos da função

#!/bin/bash
#
# Script 43
# Estruturas Condicionais – FUNÇÃO
#
clear
function1 () {
echo "Diretorio $DIRECT existente!"
}
function2 () {
echo "Diretorio $DIRECT não existe!"
}

echo -n "Digite um diretório: "
read DIRECT
echo
if [ -d $DIRECT ] ; then
function1
else
function2
fi

Baixe AQUI

#!/bin/bash
#
# Script 44
# Estruturas Condicionais – FUNÇÃO
#
clear
function1 () {
N=1
for VAR in $* ; do
echo “Parametro $N: $VAR”
let N=N+1
done
}
function1 Linux Free OpenSource NoViruses
function1 Ruindoze Nojenteoito XuxaPark VistadoInferno

Baixe AQUI

#!/bin/bash
###
#
# Script 45
#
# Estruturas condicionais – FUNÇÃO
clear

menu () {
clear
echo -ne “\033[44;37;1m ##=-._______________________.-=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-                         -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-      MENU PRINCIPAL     -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-                         -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  1) IP ETH0 / UID root  -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  2) NOME / SENHA / KEY  -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  3) Verifica Diretório  -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  4) Opções Avançadas    -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  5) Espaço em disco     -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-  x) sair                -=## \033[m"'\n'
echo -ne "\033[44;37;1m ##=-._______________________.-=## \033[m"'\n'
echo
echo -ne "\033[44;37;1m ##=-  [ ] Opção              -=## \033[m”‘\033[27D’
}

menu

###

Baixe AQUI

Autor: Marcio Katan

– Técnico de Suporte

– Consultor linux Micro & Pequena Empresa

– Instrutor Linux

Autor do livro: Linux no Computador Pessoal com Conectiva 10

Veja AQUI

Fonte: http://sites.google.com/site/marciokatan/

Integrando o Apache com o TOMCAT para que as páginas estáticas sejam executadas pelo Apache e as em JSP pelo contêiner TOMCAT, além do direcionamento das aplicações via APACHE, sendo o WebServer de acesso para as aplicações que estão no TOMCAT.

O sistema de autodetecção do Slax não é tão desenvolvido quanto o de distribuições como o Ubuntu, Knoppix ou Mandriva, mas ajuda bastante.

Você pode baixar a última versão no: http://slax.linux-live.org/.

Além do “Slax Standard Edition”, que é a versão principal, que abordo aqui, estão disponíveis algumas versões específicas, como o KillBill (que vem com o wine pré-instalado) e o PopCorn (uma versão reduzida, que pode ser instalado num pendrive de 128 MB).

O Slax configura o vídeo durante o boot, mas não abre o modo gráfico automaticamente. Na tela de login, você deve se logar como root, senha toor e rodar o comando “startx” para abrir o KDE. Você pode também usar a opção “slax gui” na tela de boot, para que ele abra o KDE automaticamente, como no Kurumin.

Embora seja raro, existem casos em que o sistema trava na hora do boot por causa de problemas com a detecção de algum periférico. Nestes casos, você pode experimentar as opções “slax noagp”, “slax nopcmcia”, “slax nodma” ou “slax acpi=off”.

Ao abrir o modo gráfico, você verá uma versão personalizada do KDE, com um visual simpático e um menu limpo, com poucos programas instalados por padrão. Devido à simplicidade, o tempo de boot também é perceptivelmente mais baixo.

Para configurar o som, use o comando “alsaconf”, e para configurar a rede, use o “netconfig” (o mesmo script usado no Slackware). Se você acessa via ADSL com autenticação (PPPoE), use o comando “adsl-setup” para configurar a conexão e depois o “adsl-start” para conectar. Estes dois comandos podem ser encontrados também no Mandriva, Fedora e em outras distribuições derivadas do Red Hat.

{mospagebreak}

O Slax não inclui suporte a nenhum softmodem, mas se por acaso você utilizar um hardmodem, pode conectar usando o Kppp, como em outras distribuições.

O suporte a placas wireless também não conta com todos os drivers disponíveis mas ele já vem com o Ndiswrapper pré-instalado, que permite configurar muitas placas usando os drivers do Windows. Você pode ver dicas de como configurar sua placa usando o Ndiswrapper no Guia Modems e placas wireless no Linux: http://www.guiadohardware.net/guias/05/

Em resumo, você primeiro carrega o arquivo .inf do driver do Windows XP, com o comando “ndiswrapper -i”, como em:

# ndiswrapper -i neti2220.inf

… e, em seguida, ativa o Ndiswrapper usando o comando:

# modprobe ndiswrapper

Com a placa ativa, você pode configurar os parâmetros da rede wireless e monitorar a conexão através do Kwifimanager, que está dentro do menu internet.

O Slax não oferece nenhuma opção de alterar o particionamento durante a instalação. Você precisa criar as partições previamente, usando o cfdisk e formatá-las através do comando “mkreiserfs”, como em “mkreiserfs /dev/hda2″. Outra opção, é particionar usando um CD do Kurumin, ou o CD de instalação do Mandriva e voltar ao Slax para instalar. Mesmo ao particionar a partir do próprio Slax, usando o cfdisk, é sempre necessário reiniciar, para que o instalador detecte as alterações.

O instalador está disponível no “Iniciar > System > Slax Installer”. Ele é provavelmente o instalador mais simples de todas as distribuições que já vi. Você precisa apenas indicar a partição onde o sistema será instalado e no MBR de qual drive o lilo será gravado (caso tenha mais de um). Não existe a opção de instalar o lilo na partição, caso você esteja instalando-o em dual boot com o Windows ou outra distribuição. Ele sempre se gravará na MBR e você precisará configurar o “/etc/lilo.conf” para que ele lhe dê a opção de inicializar os outros sistemas instalados.

{mospagebreak}

Existem duas formas de instalação. A opção “Live” simplesmente copia o conteúdo do CD para a partição, ocupando apenas 200 MB. Esta opção é mais uma opção para poder dar boot sem usar o CD-ROM do que uma instalação propriamente dita, algo similar a usar a opção “tohd” no Kurumin. A opção “Real” ocupa quase o triplo de espaço, pois nela os arquivos são realmente descompactados, criando uma instalação real do sistema, onde você pode instalar novos programas e fazer qualquer tipo de alteração.

Mesmo depois de instalado, o Slax continua usando o root como usuário padrão. Enquanto você estiver brincando e explorando o sistema isto é até interessante, pois permite que você mexa onde quiser, sem ser perturbado por problemas com as permissões. Se alguma coisa der errado, basta reinstalar e começar de novo.

Mas, a partir do momento em que você resolver navegar na web ou fazer qualquer trabalho mais sério, o uso do root torna-se um grave problema de segurança por dois motivos: como root você tem permissão para fazer tudo, então acaba sendo muito fácil destruir o sistema e, ao mesmo tempo, abrindo todos os programas como root, fica muito mais fácil explorar brechas de seguranças nos programas para obter acesso à sua máquina remotamente. Esta segunda possibilidade não é tão grande assim, mas vale a pena evitar.

{mospagebreak}

Você pode criar um novo usuário usando o comando adduser, como em:

# adduser tux

São feitas muitas perguntas, que permitem incluir informações diversas no cadastro do usuário (que seriam úteis numa grande rede), mas, no caso de um humilde desktop, as únicas que realmente interessam são o nome em si (login) e a senha.

Depois de instalado, o Slax nada mais é do que uma versão customizada do Slackware. O que você aprender a fazer no Slax pode ser feito também no Slackware e vice-versa.

Um dos grandes atrativos do Slax é ser um sistema bem simples e limpo, com poucos programas instalados por padrão. Isto é uma faca de dois gumes, pois também significa que ao usar o sistema por mais tempo, você acabará precisando investir mais tempo baixando e instalando programas adicionais.

O Slax é compatível com os pacotes da versão correspondente do Slackware. O Slax 5.06, por exemplo, usa os pacotes do Slackware 10.2. Normalmente, a última versão do Slax usa os pacotes da última versão do Slackware.

Você pode instalar programas adicionais a partir dos CDs de instalação (do Slackware) ou ir baixando individualmente os programas desejados a partir de um dos mirrors listados no http://www.slackware.com/getslack/.

Para instalar o suporte a português do Brasil no KDE, por exemplo, baixe o pacote kde-i18n-pt_BR, que está disponível na pasta “slackware/kdei/” do CD ou mirror. Os pacotes do Slackware usam a extensão “.tgz”. Junto com cada pacote, existe sempre um arquivo “.txt”, com uma descrição curta e um arquivo “.asc”, usado pelo instalador para verificar a integridade do pacote principal.

Para instalar o pacote baixado, use o comando “installpkg”, seguido pelo nome do pacote, como em:

# installpkg kde-i18n-pt_BR-3.4.2-noarch-1.tgz

Use a tecla TAB para completar o nome do arquivo depois de digitar as primeiras letras. O installpkg é uma ferramenta simples de instalação, que funciona de uma forma similar ao “dpkg -i” do Debian. Ele permite instalar pacotes que você já baixou, mas não é capaz de baixar os pacotes por si só, como o apt-get. O installpkg também não checa dependências ao instalar os pacotes: mesmo que exista algum problema, você só saberá depois de tentar abri-lo.

Esta forma simplificada de instalar programas é a principal característica do Slackware. A vantagem é que você literalmente pode fazer o que quiser, sem que ele te perturbe com mensagens de erro e dependências desencontradas. A desvantagem é que ele não faz nada sozinho; a única maneira de descobrir que o pacote x precisa do pacote y para funcionar é pesquisando.

Depois de instalado o pacote, acesse o Painel de Controle do KDE, Regional & Accessibility > Contry, Region & Language e, dentro dela marque a opção Add Language > Brazil Portuguese. Clique no “Apply” e reinicie o KDE para que os aplicativos passem a usar nossa língua.

{mospagebreak}

Para instalar o Gimp, baixe o pacote “gimp”, que está na pasta “slackware/xap”; para instalar o Firefox, baixe o pacote “mozilla-firefox” que está na mesma pasta; e assim por diante. O Slax já vem com o plugin do Flash pré-instalado; experimente instalar também o Java e Real Player, seguindo as instruções do capítulo 5 depois de instalar o Firefox.

Para instalar o OpenOffice 2.0, baixe o pacote para o Slackware, disponível no: http://www.openoffice.org.br/ e instale-o usando o comando:

# installpkg openoffice.org.br-2.0-i586-4.tgz

Depois de instalado, você pode completar a instalação do corretor ortográfico e usar as otimizações que vimos no capítulo 5.

O Slackware utiliza uma estrutura de scripts diferente da das outras distribuições. No Debian e na maioria das outras distribuições, você usaria o comando “/etc/init.d/ssh start” para inicializar o servidor SSH e permitir que sua máquina possa ser acessada a partir de outros micros da rede local. No Slackware, isso funciona de forma similar, mas os scripts mudam de lugar, vão na pasta “/etc/rc.d/”.

Para instalar o servidor SSH no Slax, por exemplo, instale o pacote “openssh-4.2p1-i486-1.tgz” que está dentro da pasta “slackware/n/” do CD ou mirror de instalação do Slackware. Ao instalar o pacote, será criado o arquivo “/etc/rc.d/rc.sshd”, o script que permite inicializá-lo. Para usá-lo, você precisa primeiro transformá-lo num executável, usando o comando:

# chmod +x /etc/rc.d/rc.sshd

E, em seguida, inicializar o servidor SSH, usando o comando:

# /etc/rc.d/rc.sshd

O fato de ser uma distribuição minimalista, com tamanho reduzido e rápida de instalar, faz com que o Slax seja uma forma muito prática de se familiarizar com o Slackware, já que você pode testar a instalação de vários programas, testar várias configurações e reinstalar o sistema rapidamente sempre que alguma coisa der errada.

Fonte: GuiadoHardware.net

Autor: Carlos E. Morimoto

Introdução

Neste tutorial eu irei ensinar como instalar um servidor de comunicação instatânea baseada no protocolo Jabber utilizando o mysql para autenticação, para ser usado dentro de empresas, grupos e etc.

A instalação é bem simples e se for bem seguida, você não terá problemas.

Então deixemos de conversa e vamos logo ao que interessa.

Sistema Operacional Utilizado

• Debian Linux Versão 3.1

Softwares necessários

• Jive Messenger versão 2.1.5 ou superior.
• Mysql 3.4 ou superior. Recomendado usar >= 4.1
• JRE 1.5 ou superior para linux. Pode ser adquirido no site da sun.

Instalação e Configuração

Mysql

Usando o apt-get ou através de mecanismos da sua distro faça o download e instalação do mysql. (Não irei ensinar a configurar e instalar o mysql, para isso existem vários tutoriais na net).

Crie um database chamado jabber.

Crie uma conta de usuário no mysql ou use a conta do root. Recomendado não usar o root. Esse usuário deverá ter permissões para se conectar de qualquer lugar, ou seja, “%”.

O motivo: durante a configuração do jabber o mesmo ira acusar erros caso o usuário que você especificar não estiver conforme eu descrevi.

Você pode tentar limitar o acesso desse usuário permitindo logon somente local após a instalação. Comigo não funcionou.

JRE 1.5

No site da Sun[1], baixe o arquivo .BIN do JRE-1.5 no diretório /usr/local. Aqui utilizei a jre-1_5_0_04-linux-i586.bin

Deixe o arquivo ser executavel.

# chmod +x jre-1_5_0_04-linux-i586.bin

Execute o arquivo digitando:

# ./jre-1_5_0_04-linux-i586.bin

Após concordar com os termos de licença, irá surgir uma pasta chamada jre1.5.0_04 no diretório corrente.

Servidor Jabber

Nesta instalação vamos usar o Jive versão 2.1.5.

Faça o download do jive no site http://www.jivemessenger.com

Descompacte-o arquivo no diretório /usr/local

# tar -zxvf jive_messenger_2_1_5.tar.gz

Feito isso é hora de criar uma variavel de ambiente utilizada pelo jive para identificar a localização da máquina virtual java.

# export INSTALL4J_JAVA_HOME=/usr/local/jre1.5.0_04/

Chegada a hora de iniciarmos o servidor. Digite:

# /usr/local/jive_messenger/bin/messenger start

Se tudo estiver correto o servidor estará funcional.

Abra um browser qualquer e aponte para o ip do servidor na porta 9090

Se tudo der certo você estará na área administrativa começando a configurar o servidor.

Preencha os campos que o sistema requer e vá avançando.

Após concluir a configuração, você deve alterar as permissões do usuário mysql que o jive usa, limitando elas.

A configuração do Jive é muito fácil e lembra os wizards do windows.

Após completar a configuração do servidor, é chegada a hora de baixar o client e testar. Recomendo o uso do Pandion e NeosMt (Meu preferido).

Instale o client do NeosMt[2]

Vá em criar nova conta. E onde ele pedir o servidor, você deverá colocar ip ou nome do servidor em que foi feita a instalação.

Criado a conta agora é só logar com o usuário@servidor e senha.

Conclusão

Pronto temos um servidor Jabber de comunicação Instantânea.

Até mais e abraços.

Autor

• ’1c3_m4n (iceman@underlinux.com.br)

Fonte: http://under-linux.org

Mais uma dica rápidinha para os que estão precisando realizar esta tarefa.

Conecte ao servidor com o usuário root e depois se transforme no usuário “postgres” como no exemplo abaixo:

root@pgsql1:~# su – postgres

Agora que está com o usuário postgres, execute o seguinte comando:

postgres@pgsql1:~$ psql template1

Logado no “cliente do postgres” digite o seguinte comando:

template1=# ALTER USER postgres WITH PASSWORD ‘SUA_NOVA_SENHA’;

Agora digite “\q” para sair, desconecte do servidor e tente conectar com a sua aplicação ou seu cliente PostgreSQL ao seu servidor com a nova senha.

Fonte: http://dotlinux.net