domingo, 3 de janeiro de 2010

Tutorial do CentOS

Autor:Carlos E. Morimoto

Fonte:http://www.guiadohardware.net/tutoriais/centos/

O CentOS é uma versão gratuita do Red Hat Enterprise, gerado a partir do código fonte disponibilizado pela Red Hat e mantido de forma bastante competente por um grupo de desenvolvedores, que combina representantes de diversas empresas que utilizam o sistema (sobretudo empresas de hospedagem) e voluntários.

Ele é, basicamente, uma versão gratuita do RHEL, que possui um excelente histórico de segurança e conta com uma boa estrutura de suporte comunitário e atualizações pontuais de segurança, qualidades que o tornam uma das distribuições Linux mais populares em servidores, sobretudo em servidores web.

Se você está interessado na estabilidade do Red Hat Enterprise, ou precisa rodar softwares como o Oracle, que são suportados apenas nele, mas não tem como pagar caro pelo sistema, o CentOS é a sua melhor opção.

Red Hat x RHEL x CentOS x Fedora: Para quem está chegando agora, o Red Hat Linux foi uma das primeiras distribuições Linux a conquistar um grande público. A primeira versão foi lançado em 1994 e o sistema conseguiu ganhar espaço tanto entre os desktops (devido à relativa facilidade de uso) quanto entre os servidores, devido à boa estabilidade do sistema. O Red Hat Linux foi descontinuado em 2004, dando lugar ao Fedora, que é desenvolvido de forma colaborativa e às diferentes versões do Red Hat Enterprise (também chamado de RHEL), a versão comercial do sistema, destinada a grandes empresas.

O Red Hat Enterprise possui um ciclo de desenvolvimento mais lento (que prioriza a estabilidade) e tem suas versões suportadas por um período de nada menos do que 7 anos após o lançamento. Para quem está acostumado com o rápido ritmo de desenvolvimento das distribuições Linux domésticas, um sistema que é suportado por 7 anos pode soar estranho, mas dentro do ramo corporativo este é um diferencial importante, já que atualizar os desktops e os servidores é sempre um processo arriscado e caro (devido à mão de obra necessária, necessidade de treinar os funcionários, etc.), de forma que ciclos de desenvolvimento mais lentos e previsíveis são preferidos. Veja o caso do Windows, por exemplo, muitas empresas ainda usam servidores com o 2000 Server, ou mesmo com o NT 4.

O RHEL é fornecido apenas em conjunto com um plano de suporte e não pode ser redistribuído em seu formato binário. Entretanto, todo o código fonte está disponível, de forma que alguém que pacientemente compile cada um dos pacotes disponibilizados pela Red Hat, acaba obtendo uma cópia completa do sistema, que pode ser usada para todos os fins.

O CentOS nada mais é do que um Red Hat Enterprise compilado a partir do código fonte disponibilizado pela Red Hat, com os logotipos as marcas registradas removidas. Isso garante que os dois sistemas sejam binariamente compatíveis (ou seja, um software compilado para rodar no Red Hat Enterprise roda também na versão correspondente do CentOS sem precisar de modificações) e todos os passos de instalação e configuração dos dois sistemas são idênticos, o que faz com que toda a documentação do Red Hat Enterprise se aplique também ao CentOS.

Ao aprender a trabalhar com o CentOS, você automaticamente aprende a trabalhar com o Red Hat Enterprise e vice-versa. A grosso modo, podemos dizer que o Fedora é uma versão comunitária de desenvolvimento do Red Hat Enterprise, enquanto o CentOS é uma cópia praticamente exata do sistema.

Com relação às versões, o Red Hat Enterprise 4 foi baseado no Fedora Core 3, enquanto o Red Hat Enterprise 5 foi baseado no Fedora Core 6 e o Red Hat Enterprise 6 será baseado no Fedora 9. As versões do CentOS seguem as versões do Red Hat Enterprise, de forma que o CentOS 5 corresponde ao Red Hat Enterprise 5 e assim por diante:

Fedora Core 3 > Red Hat Enterprise Linux 4 > CentOS 4
Fedora Core 6 > Red Hat Enterprise Linux 5 > CentOS 5
Fedora 9 > Red Hat Enterprise Linux 6 > CentOS 6

Novas versões do Red Hat Enterprise são disponibilizadas a cada 18 ou 24 meses, mas recebem um grande volume de atualizações e correções de segurança durante este período. Isso leva ao lançamento de sub-versões com as atualizações pré-instaladas, como o Red Hat Enterprise 4.6 e o Red Hat Enterprise 5.1, que são sempre seguidas pelas versões correspondentes do CentOS.

Assim como o sistema principal, as atualizações e correções de segurança são disponibilizados pela equipe do CentOS, novamente através de pacotes compilados a partir dos códigos fontes disponibilizados pela Red Hat. As atualizações do CentOS são tipicamente disponibilizadas entre 24 e 72 horas depois das do Red Hat Enterprise (o que é impressionante considerando que se trata de um projeto voluntário), mas muitas atualizações críticas são disponibilizadas muito mais rápido, em poucas horas. Assim como o Red Hat Enterprise, todos os releases do sistema são suportados recebem atualizações de segurança por um período de 7 anos. Com isso, o CentOS 4 será suportado até 2012 e o CentOS 5 será suportado até pelo menos 2013.

A grande diferença entre o CentOS e o Red Hat Enterprise é a questão do suporte, já que, embora caro, o suporte oferecido pela Red Hat é bastante personalizado e os profissionais passam por um exame de certificação exigente (o RHCE) que mistura testes teóricos e práticos. Em servidores de missão crítica, usar o Red Hat Enterprise e pagar pelo suporte é geralmente uma boa opção, já que além de ajuda na implementação, você tem uma equipe pronta para agir em caso de problemas inesperados. Para os demais casos, você pode perfeitamente utilizar o CentOS contando com o suporte comunitário oferecido através dos fóruns do projeto.

O CentOS é também bastante similar ao Fedora, mas nesse caso as diferenças são mais evidentes, já que versões recentes do Fedora são baseadas em pacotes mais atuais, o que invariavelmente leva a mudanças no sistema. De qualquer forma, os passos básicos de instalação e a configuração geral dos dois sistemas são praticamente iguais, de forma que as dicas desse tópico se aplicam também ao Fedora.

Comparar o CentOS e o Fedora para uso em servidores desperta argumentos similares aos de uma comparação entre o Ubuntu e o Debian. O CentOS segue as versões do Red Hat Enterprise, que possui um ciclo de desenvolvimento muito mais longo, onde a principal preocupação é a estabilidade do sistema. O Fedora, por sua vez, é desenvolvido em torno de ciclos muito mais curtos, com uma nova versão sendo disponibilizada a cada 6 meses.

Por um lado isso é bom, já que você tem acesso a versões mais atuais dos pacotes, mas por outro lado é ruim, pois o lançamento mais freqüente de novas versões aumenta sua carga de trabalho como administrador, já que o sistema precisa ser atualizado mais freqüentemente.

Além de serem mais espaçadas, as versões do CentOS recebem atualizações de segurança por um período muito mais longo, que torna a vida útil das instalações muito maior. Um servidor rodando a versão mais atual do CentOS poderia ser mantido em serviço por até 7 anos, recebendo apenas as atualizações de segurança, o que não seria possível no Fedora, onde o suporte às versões antigas é encerrado muito mais rapidamente.

Em resumo, se você não se importa de utilizar softwares ligeiramente antigos e quer um servidor que ofereça um baixo custo de manutenção e possa ser usado durante um longo período sem riscos, o CentOS é mais recomendável. Se, por outro lado, você precisa de versões recentes do Apache, Samba ou outros serviços, ou se tem alguma preferência pessoal em relação ao Fedora, também pode utilizá-lo sem medo.

Embora o Fedora seja em teoria menos estável que o CentOS, ambas as distribuições podem ser considerados bastante estáveis. Poderíamos dizer que o CentOS é "99% estável" enquanto o Fedora é "98% estável". Ou seja, existe diferença, mas ela é relativamente pequena.

Instalando

Voltando à instalação, você pode baixar as imagens do sistema no http://www.centos.org/

Na versão 5.1, o sistema é distribuída tem nada menos do que 6 CDs de instalação (7 CDs na versão de 64 bits), mas, assim como no caso do Debian, é possível fazer uma instalação minimalista usando apenas o primeiro CD. Se baixar 4 GB não for um problema, você pode ganhar tempo baixando a versão em DVD.

Está disponível também o NetInstall, uma imagem de boot com apenas 7 MB para instalação via rede, onde o instalador baixa os pacotes necessários via HTTP, FTP ou NFS durante a instalação. É perfeitamente possível usar o NetInstall para fazer uma instalação via web, baixando apenas os pacotes que serão realmente usados (em vez de baixar o DVD inteiro), mas a menos que você tenha uma conexão muito rápida, ou esteja fazendo uma instalação minimalista, isso não é muito recomendável.

O mais comum é que o NetInstall seja usado para instalar vários servidores (imagine o caso de uma empresa de hospedagem, por exemplo) a partir de um mirror local. Para configurar um, você precisa apenas copiar todos os arquivos do DVD de instalação para uma pasta e compartilhar o conteúdo usando um servidor web ou FTP, informando o endereço IP do servidor e o diretório onde estão os arquivos ao instalar o sistema nas demais máquinas.

É possível ainda automatizar a instalação através do kickstart, um recurso disponível também no Fedora, onde você gera um arquivo de configuração, contendo instruções para o instalador e indica a localização do arquivo usando um parâmetro de boot, como em:

linux ks=http://192.168.1.254/ks.cfg

Este exemplo faz com que o instalador configure a rede via DHCP e tente acessar o arquivo através de um servidor web interno. É possível carregar o arquivo via NFS, FTP, usando um disquete ou mesmo gerar um CD de instalação personalizado, incluindo o arquivo. Ele é uma boa opção para ambientes onde você precisa realizar um grande número de instalações em pouco tempo. Você pode ver mais detalhes sobre ele aqui:
http://www.redhat.com/docs/manuals/enterprise/RHEL-5-manual/pt-BR/Installation_Guide/ch-redhat-config-kickstart.html

O CentOS utiliza o Anaconda, que é o mesmo instalador gráfico usado no Fedora. Para usar o instalador gráfico é necessário ter 512 MB de memória, mas é possível instalar o sistema em máquinas antigas usando o instalador em modo texto, que pode ser acessado usando a opção "linux text" na tela de boot:

clip_image001

Assim como em outras distribuições, você pode incluir opções para o Kernel na linha de boot, de forma a solucionar problemas de compatibilidade, como a "acpi-off", "noapic", "all-generic-ide", "irqpoll" e "outras", como em:

linux noapic irqpoll

O instalador começa se oferecendo para realizar um teste da mídia de instalação e em seguida pergunta sobre a linguagem do sistema (o português do Brasil está disponível desde as primeiras versões do sistema) e o layout do teclado.

Durante a instalação, você pode ver o log de mensagens geradas pelo instalador pressionando Ctrl+Alt+F3 e ter acesso a um terminal que pode ser usado para solucionar problemas pressionando Ctrl+Alt+F2.

Em seguida temos o particionamento dos HDs, que começa com a clássica pergunta sobre utilizar o layout padrão, ou criar um layout personalizado:

clip_image002

O CentOS utiliza o LVM por padrão, criando um único volume lógico, englobando todo o espaço disponível do HD e criando partições dentro dele. É usada também uma partição /boot separada, que fica fora do volume LVM, já que o grub não é capaz de inicializar o sistema se o diretório /boot estiver dentro de um volume lógico:

clip_image003

O LVM (Logical Volume Manager) é um recurso incluído no Kernel Linux a partir da versão 2.4 que cria uma camada de abstração entre o sistema operacional e os HDs (ou outras unidades de armazenamento utilizadas). Ele adiciona alguns complicadores adicionais na configuração, mas, em compensação oferece um conjunto de vantagens bastante interessantes.

Imagine que no LVM o sistema não vê HDs e partições, mas sim um ou mais volumes lógicos. Cada volume se comporta como se fosse uma partição, que é formatada e montada da forma usual (um volume pode ser usado inclusive como partição swap). Estes volumes são agrupados em um grupo de volumes lógicos (logical volume group) que se comporta de forma similar a um HD.

O pulo do gato é que o grupo de volumes lógicos pode combinar o espaço de vários HDs e ser modificado conforme necessário, incorporando mais HDs. Os volumes lógicos dentro dele também podem ser redimensionados livremente conforme for necessário.

Se você precisa de mais espaço dentro do volume referente à pasta home, por exemplo, você poderia reduzir o tamanho de um dos outros volumes do sistema (que estivesse com espaço vago) e aumentar o tamanho do volume referente ao home, tudo isso com o servidor operante.

Outra possibilidade é ir adicionando novos HDs ao servidor conforme precisar de mais espaço. Ao instalar um novo HD, você começaria criando um volume físico, englobando todo o espaço do HD. Uma vez que o volume físico é criado, você pode expandir o grupo de volumes lógicos, de forma que ele incorpore o espaço referente ao novo HD. A partir daí, você pode expandir os volumes lógicos, usando o espaço livre.

Caso seja utilizada uma controladora SCSI ou SAS com suporte a hot-swaping, é possível até mesmo adicionar, remover ou substituir HDs, fazendo as alterações necessárias nos volumes lógicos, tudo sem interrupções.

É importante enfatizar que o LVM é apenas uma mudança na forma como o sistema acessa os discos, ele não é um substituto para o RAID. No LVM você pode agrupar vários HDs em um único grupo de volumes lógicos, mas se um dos HDs apresentar defeito, o servidor ficará inoperante e você perderá os dados armazenados no disco afetado, diferente do RAID, onde você pode sacrificar parte do espaço para ter uma camada de redundância.

O grupo de volumes lógicos criado pelo instalador é visto pelo sistema como "/dev/VolGroup00" e os volumes lógicos dentro dele são vistos como "/dev/VolGroup00/LogVol00", "/dev/VolGroup00/LogVol01", etc. Estes nomes usados por default não são muito descritivos, mas é possível alterá-los usando o próprio particionador. Naturalmente, é possível também deixar de usar o LVM, voltando ao sistema normal de particionamento. Nesse caso você só precisa deletar os volumes e o grupo de volumes lógicos e criar a partições desejadas usando o espaço disponível.

Para o particionamento do HD, valem as regras que vimos no meu tutorial anterior sobre instalação de servidores Linux, ou seja, usar volumes separados para os diretórios "/tmp", "/var" e "/home", de acordo com a aplicação do servidor.

Em seguida temos a tela de configuração do gerenciador de boot. Diferente de um desktop, onde muitas vezes precisamos configurar o gerenciador para inicializar vários sistemas operacionais, em um servidor utilizamos sempre um único sistema, o que simplifica as coisas. Você pode rodar outros sistemas operacionais simultaneamente usando VMware Server ou o Xen, utilizando máquinas virtuais.

clip_image004

A opção "Utilizar uma senha no gerenciador de inicialização" define uma senha de boot, que é solicitada pelo grub no início do boot. Esta senha é raramente usada em servidores, pois impede que o servidor seja reiniciado sem que alguém esteja presente no local para digitar a senha no boot seguinte. Ela também não é eficiente como uma proteção contra acesso local do servidor, pois é facilmente burlável.

Em seguida temos a configuração da rede. Tanto ao configurar um servidor para a Internet quanto ao configurar um servidor de rede local, é muito provável que você configure também um domínio. Na Internet a função do domínio é obvia, já que é através dele que os visitantes acessarão os sites hospedados, mas um domínio pode ser útil também em uma rede local, facilitando o acesso às máquinas e viabilizando o uso de diversos serviços adicionais. Mesmo o Active Directory (utilizado em redes Microsoft) é fortemente baseado no uso de domínios.

Gerenciar nomes de domínio é tarefa para o Bind. Por enquanto, você pode se limitar a configurar o "fully qualified domain name" do servidor, ou seja, seu nome completo, incluindo o nome da máquina e o domínio que será utilizado, como em "centos.gdhn.com.br":

clip_image005

Depois de ajustar o fuso-horário e definir as senhas do sistema, chegamos à seleção dos pacotes que serão instalados. Todas as categorias disponíveis são opcionais, de forma que se você simplesmente desmarcar todas, fará uma instalação minimalista do sistema, em modo texto.

As categorias importantes no nosso caso são a "Server" (a seleção padrão de pacotes, incluindo o Samba, Apache, FTP, etc.) e, opcionalmente, a "Server-GUI", que instala o ambiente gráfico e as ferramentas gráficas de administração. É interessante ativar também o "Packages from CentOS Extras", que torna disponível um conjunto de pacotes adicionais, disponibilizados pela equipe do CentOS.

clip_image006

Marcando a opção "Personalizar agora" você tem acesso ao menu de seleção de pacotes. Se você marcou a categoria "Server-GUI" ou uma das categorias desktop, você notará que os pacotes referentes ao X, além do Gnome ou KDE e um conjunto de aplicativos gráficos estarão marcados.

Assim como o Fedora, o CentOS inclui um conjunto de aplicativos gráficos para configuração do sistema que podem ser úteis em muitas situações, de forma que muitos administradores preferem manter o ambiente gráfico instalado, mesmo em servidores que serão apenas acessados remotamente. Você pode perfeitamente manter os pacotes relacionados ao ambiente gráfico instalados, mas manter o ambiente gráfico inativo enquanto não o estiver usando (de forma a não consumir recursos do servidor).

Nas primeiras instalações, recomendo que desmarque os pacotes dentro da categoria "Servidores" e instale cada serviço manualmente, assim você pode estudar melhor o processo de configuração de cada um:

clip_image007

Diferentemente do Red Hat Enterprise, que possui versões distintas para servidores (Red Hat Enterprise Linux), servidores de missão crítica (Red Hat Enterprise Linux Advanced Platform) e para estações de trabalho (Red Hat Enterprise Linux Desktop), cada uma contendo uma coleção de pacotes específicos para as tarefas a que são destinadas, o CentOS é uma distribuição unificada, que simplesmente inclui todos os pacotes disponíveis nos repositórios.

Isso significa que, além de ser usado como servidor, que é o que estudaremos aqui, o CentOS também pode ser usado como sistema desktop, já que inclui o Gnome, KDE e um conjunto bastante completo de aplicativos que podem ser marcados durante a instalação.

Depois de concluída a cópia dos arquivos, é aberto um agente de configuração (que no RHEL é chamado de Red Hat Setup Agent), que conclui a configuração do sistema. Duas opções importantes são a configuração do firewall e do SELinux.

O configurador do firewall é na verdade um wizard, que permite que você selecione as portas referentes aos serviços que ficarão ativos no servidor (as portas selecionadas são abertas e todas as demais fechadas) e, a partir das respostas, gera as regras correspondentes para o IPtables, que é o firewall propriamente dito. Além das portas dos serviços padrão, você pode adicionar manualmente qualquer porta que precisar manter aberta. No exemplo estou abrindo a porta 901, usada pelo swat:

clip_image008

Você pode ajustar a configuração do firewall após a instalação através do utilitário "system-config-securitylevel" (disponível no Sistema > Administração > Nível de Segurança e Firewall). Existe também uma versão em modo texto do aplicativo, o "system-config-securitylevel-tui", que pode ser acessada via terminal (e inclusive remotamente, via SSH).

É possível também desativar a configuração do firewall e configurar as regras do IPtables manualmente, como veremos a seguir. Escrever um script de firewall é mais simples do que pode parecer à primeira vista.

Enquanto estiver estudando, recomendo que faça justamente isso; desativando o firewall na configuração e configurando o IPtables manualmente. Isso evita que você se depare com problemas inesperados introduzidos por portas fechadas no firewall. Depois que você entender a configuração manual do IPtables, pode voltar a configurar o firewall através do wizard caso prefira.

Continuando, temos o SELinux (Secure Linux), um sistema que visa reforçar a segurança do sistema, aplicando um conjunto de diretivas rígidas de segurança. O grande problema é que o SELinux interfere no funcionamento de um grande volume de serviços e de softwares adicionais, o que torna necessário criar exceções para cada caso.

Isso faz com que o modo "Enforcing" (Forçando) do SELinux seja aconselhável apenas em situações onde a segurança realmente seja um fator crítico e onde o administrador possua profundos conhecimentos do sistema, de forma a diagnosticar problemas causados pelas políticas de segurança e criar as exceções necessárias. Um meio termo é o nível "Permissive" (permissivo), onde o SELinux é aplicado apenas a alguns serviços específicos (o Apache e o Bind, por exemplo) e age apenas em relação a eles.

Mesmo sem o SELinux, o CentOS é uma distribuição bastante segura. Enquanto você estiver estudando sobre o sistema e utilizando-o em servidores de rede local, é interessante desativar o sistema. Com isso, você evita situações onde determinados serviços não estão funcionando (apesar da configuração estar correta) por causa das restrições do SELinux.

clip_image009

Para desativá-lo depois da instalação, edite o arquivo "/etc/selinux/config" e substitua a linha "SELINUX=enforcing" ou "SELINUX=permissive" por:

SELINUX=disabled

É necessário reiniciar o micro para que a alteração entre em vigor. O reboot demora alguns minutos, pois o sistema precisa realizar um conjunto de modificações nos arquivos.

A menos que você tenha manualmente desmarcado o pacotes "openssh-server" durante a instalação, o servidor SSH será instalado e ficará ativo por padrão, o que permite que você faça o restante da configuração do servidor remotamente:

$ ssh root@servidor

O arquivo de configuração do SSH no CentOS é o "/etc/ssh/sshd_config", o mesmo usado no Debian e no Ubuntu. O nome do pacote também é o mesmo, "openssh-server". A única diferença é que o script usado para controlar o serviço é o "/etc/init.d/sshd" e não "/etc/init.d/ssh".

Usando o yum

O yum (Yellow dog Update, Modified) é o gerenciador de pacotes usado por padrão no CentOS, no Fedora e no Red Hat Enterprise. O yum foi originalmente desenvolvido pela equipe do Yellow Dog (uma distribuição baseada no Red Hat, destinada a computadores com chip PowerPC) e foi sistematicamente aperfeiçoado pela equipe da Red Hat, até finalmente assumir o posto atual.

O yum trabalha de forma bem similar ao apt-get, baixando os pacotes a partir dos repositórios especificados nos arquivos de configuração, junto com as dependências necessárias. Assim como o apt-get, ele é capaz de solucionar conflitos automaticamente e pode ser também usado para atualizar o sistema. Essencialmente, o yum e o apt-get solucionaram o antigo problema das dependências (um pacote precisa de outro, que por sua vez precisa de um terceiro) que atormentava os usuários de distribuições mais antigas.

Existem muitas diferenças entre o CentOS e o Debian, uma delas é o formato dos pacotes utilizados: o CentOS utiliza pacotes .rpm, enquanto o debian utiliza pacotes .deb. Ambos também utilizam repositórios separados, com pacotes construídos especificamente para cada uma das duas distribuições, de forma que existem algumas diferenças nos nomes dos pacotes e arquivos de configuração usados.

Diferente do apt-get, onde você precisa rodar o "apt-get update" antes de cada instalação para atualizar a lista de pacotes, o yum faz a atualização automaticamente cada vez que uma instalação é solicitada, checando os repositórios, baixando os headers do pacotes e calculando as dependências antes de confirmar a instalação, como nesse exemplo:

clip_image011

Isso faz com que a instalação de pacotes usando o yum seja um pouco mais demorada que usando o apt-get. Ou seja, ganha-se de um lado mas perde-se do outro. :)

Para instalar um pacote, use o comando "yum install", como em:

# yum install mysql-server

Para removê-lo posteriormente, use:

# yum remove mysql-server

O yum possui também um recurso de busca, que é bastante útil quando você está procurando por um pacote, mas não sabe o nome exato, ou em casos de pacotes que possuem nomes diferentes em relação a outras distribuições. Use o comando "yum search", seguido por alguma palavra ou expressão, que faça parte do nome do pacote ou descrição, como em:

# yum search samba

Ele retorna um relatório contendo todos os pacotes relacionados, incluindo o texto de descrição de cada um. Isso resulta geralmente em uma lista relativamente longa. Para fazer uma busca mais restrita, procurando apenas nos nomes dos pacotes, use o parâmetro "list", como em:

# yum list httpd

Ele é bem menos falador, retornando apenas os pacotes que possuem "httpd" no nome, sem pesquisar nas descrições.

Uma terceira opção é a "provides" que mostra pacotes que incluem um determinado arquivo, pesquisando não no nome ou na descrição, mas sim no conteúdo dos pacotes. Ele é bastante útil em casos em que você precisa de alguma ferramenta ou biblioteca que faz parte de outro pacote maior, como em:

# yum provides mcedit

Em caso de dúvida, você pode verificar se um determinado pacote está instalado e qual é a versão usando o comando "rpm -q", como em:

# rpm -q samba

samba-3.0.25b-0.el5.4 

Para atualizar um pacote já instalado, use o comando "yum update", como em:

# yum update samba

O comando "yum install" também pode ser usado para atualizar pacotes. A diferença entre o "install" e o "update" é que o "update" se limita a atualizar pacotes já instalados. Ao perceber que o pacote solicitado não está instalado, ele exibe um aviso e aborta a instalação, como no exemplo abaixo. Isso reduz a possibilidade de você acabar instalando um novo serviço por engano:

# yum update mysql-server

Loading "installonlyn" plugin
Setting up Update Process
Setting up repositories
Reading repository metadata in from local files
Could not find update match for mysql-server

Outra observação é que, depois de atualizar um serviço, é necessário recarregar o serviço (como em "service smb restart") para que a nova versão passe a ser usada. Esta é mais uma pequena diferença com relação às distribuições derivadas do Debian, onde os serviços são reiniciados de forma automática depois de atualizados.

Para atualizar todo o sistema, comece usando o parâmetro "check-update", que lista as atualizações disponíveis:

# yum check-update

Se usado sem especificar um pacote, o "update" vai atualizar de uma vez só todos os pacotes do sistema, de forma similar ao "apt-get upgrade" do Debian:

# yum update

Existe ainda o comando "yum upgrade", que é um pouco mais incisivo, incluindo também pacotes marcados como obsoletos (que não existem mais na versão atual). Ele é útil em casos em que é necessário atualizar uma versão antiga do sistema:

# yum upgrade

É possível também fazer com que o yum atualize o sistema automaticamente todas as madrugadas. Para isso, basta ativar o serviço "yum" e configurá-lo para ser ativado durante o boot:

# chkconfig yum on
# service yum start

Isso faz com que a atualização seja agendada através do cron e seja (por padrão) executada todos os dias às 4:02 da manhã, como especificado no arquivo "/etc/crontab".

Repositórios adicionais

A lista de repositórios usados pelo yum é dividida em diversos arquivos, organizados na pasta "/etc/yum.repos.d/". No CentOS, a parta inclui por padrão apenas dois arquivos: "CentOS-Base.repo" e "CentOS-Media.repo". O primeiro inclui os repositórios oficiais da distribuição, enquanto o segundo permite que você instale pacotes contidos nos CDs (ou no DVD) de instalação.

O arquivo "CentOS-Base.repo" contém diversas entradas como a abaixo, uma para cada repositório:

#released updates
[updates]
name=CentOS-$releasever - Updates
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates
#baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/
gpgcheck=1
gpgkey=http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5

Ao adicionar repositórios adicionais, você criaria novos arquivos dentro da pasta "/etc/yum.repos.d/", um para cada repositório adicional.O yum verifica os arquivos dentro da pasta cada vez que é executado, fazendo com que o novo repositório passe a ser usado automaticamente.

Normalmente, os responsáveis pelos repositórios disponibilizam arquivos de configuração prontos, que precisam ser apenas copiados para dentro da pasta "/etc/yum.repos.d". Para adicionar o repositório kbs-centos-extras, por exemplo, você baixaria o arquivo "kbsing-CentOS-Extras.repo", disponível no http://centos.karan.org/.

Assim como o apt-get, o yum utiliza chaves GPG para checar a autenticidade dos pacotes antes de fazer a instalação. Cada pacote é assinado digitalmente pelo desenvolvedor, o que atesta que o pacote foi realmente gerado por ele. Mesmo que alguém tentasse adulterar o pacote (incluindo um rootkit ou um script malicioso, por exemplo), não teria como falsificar também a assinatura, o que levaria o yum a reportar o problema e abortar a instalação.

Ao adicionar um novo repositório, é necessário adicionar também a chave pública do desenvolvedor, usando o comando "rpm --import", como em:

# rpm --import http://centos.karan.org/RPM-GPG-KEY-karan.org.txt

Normalmente, a URL com a chave pública GPG fica em destaque dentro da página com instruções de como adicionar o repositório.

Da mesma forma, para remover um repositório posteriormente, você removeria o arquivo da pasta, de forma que o yum deixe de usá-lo. É interessante também limpar o cache do yum, usando os comandos:

# yum clean headers
# yum clean packages

Plugins

O yum oferece também suporte a plugins, que permitem expandir as funcionalidades do gerenciador. Dois plugins bastante populares são o fastestmirror e o protectbase.

O fastestmirror faz com que o yum cheque a velocidade dos mirrors a cada instalação e baixe sempre os pacotes a partir do mirror mais rápido (evitando os problemas de lentidão que atingem muitos usuários), enquanto o protectbase faz com que o yum dê prioridade para os pacotes dos repositórios oficiais, evitando que eles sejam substituídos por pacotes de outros repositórios adicionados manualmente.

Para ativar o fastestmirror, basta instalar o pacote "yum-fastestmirror", como em:

# yum install yum-fastestmirror

Isso faz com que ele passe a ser usado automaticamente. Você notará que o yum passará a exibir duas mensagens adicionais durante cada operação:

Loading "fastestmirror" plugin
Loading mirror speeds from cached hostfile

Naturalmente, para que o fastestmirror possa escolher o repositório mais rápido a utilizar, é necessário que seja especificada uma lista de mirrors dentro da configuração de cada repositório na pasta "/etc/yum.repos.d". Você notará que as entradas referentes aos mirrors oficiais incluem uma linha "mirrorlist", que indica a localização de um arquivo com a lista dos mirrors disponíveis, como em:

[extras]
name=CentOS-$releasever - Extras
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=extras

Ao adicionar novos repositórios manualmente, não se esqueça de pesquisar sobre a localização do arquivo com a lista dos mirrors, de forma a especificá-lo na configuração.

Para ativar o protectbase, instale o pacote yum-protectbase:

# yum install yum-protectbase

Para que ele se usado, é necessário adicionar a linha "protect=1" ou "protect=0" na configuração de cada um dos repositórios incluídos na pasta "/etc/yum.repos.d". Os repositórios com o "protect=1" serão protegidos pelo protectbase, evitando que os pacotes sejam substituídos por pacotes de versões mais recentes incluídos nos repositórios adicionais. Com isso, os repositórios adicionais passam a realmente ser usados apenas para instalar pacotes que não fazem parte dos repositórios principais, reduzindo bastante a possibilidade de problemas ao usar repositórios não-oficiais.

É importante proteger pelo menos os repositórios "base" e "updates", dentro do arquivo "/etc/yum.repos.d/CentOS-Base.repo", como em:

[base]
name=CentOS-$releasever - Base
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=os
#baseurl=http://mirror.centos.org/centos/$releasever/os/$basearch/
gpgcheck=1
gpgkey=http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5
protect=1

[updates]
name=CentOS-$releasever - Updates
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates
#baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/
gpgcheck=1
gpgkey=http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5
protect=1

As demais entradas devem receber a opção "protect=0", como em:

[rpmforge]
name = Red Hat Enterprise $releasever - RPMforge.net - dag
#baseurl = http://apt.sw.be/redhat/el5/en/$basearch/dag
mirrorlist = http://apt.sw.be/redhat/el5/en/mirrors-rpmforge
gpgkey = file:///etc/pki/rpm-gpg/RPM-GPG-KEY-rpmforge-dag
gpgcheck = 1
protect = 0

quinta-feira, 31 de dezembro de 2009

Instalando o PHP 5.2 no CentOS pelo YUM

Passei ultimamente por um problema meio chato onde tive que instalar o phpmyadmin no CentOS
Linux. O problema não foi nem instalar o phpmyadmin, mas sim o PHP 5.2, pois quando eu o instalei pelo yum, a versão instalada foi a 5.1 (e essa versão não funciona com o phpmyadmin 3.2.4).

Então, seguem os passos para se instalar o PHP 5.2 no CentOS via yum.

1 - Você terá que importar a chave RPM-GPG-KEY do repositório utterramblings digitando o seguinte comando:

# rpm --import http://www.jasonlitka.com/media/RPM-GPG-KEY-jlitka


2 - Adicione o seguinte repositório no seu arquivo CentOS-Base.repo:

# vi /etc/yum.repos.d/CentOS-Base.repo

[utterramblings]
name=Jason's Utter Ramblings Repo
baseurl=http://www.jasonlitka.com/media/EL$releasever/$basearch/
enabled=1
gpgcheck=1
gpgkey=http://www.jasonlitka.com/media/RPM-GPG-KEY-jlitka


3 - Depois, digite os seguintes comandos:

# yum clean all
# yum check-update



Aparecerá uma lista de pacotes que já estão instalados no seu PC e que devem ser atualizados para a nova versão (se você já tiver instalado o PHP pelo yum com a versão 5.1 irá aparecer na lista a 5.2).

4 - Em seguida, para atualizar os pacotes instalados do PHP, digite:

# yum update php php-devel php-gd php-imap php-ldap php-mysql php-odbc php-pear php- xml php-xmlrpc curl curl-devel perl-libwww-perl ImageMagick libxml2 libxml2-devel php-mcrypt -y


5 - Pronto! Agora é só instalar o phpmyadmin e tentar abrí-lo a partir de um browser...

Programando em shell-script

- Devin - http://www.devin.com.br -

Posted By Hugo Cisneiros (Eitch) On 9 de agosto de 2004 @ 9:00 am In Programação, Tutoriais

Uma vez fui convidado à escrever para a Revista do Linux, e fiz alguns tutoriais que ensinam o básico para quem está começando a criar shell-scripts. Disponibilizo eles aqui.


 Primeira parte, uma introdução

Quem usa Linux conhece bem o prompt de comando sh, ou variações como o bash. O ue muita gente não sabe é que o sh ou o bash têm uma "poderosa" linguagem de script embutido nelas mesmas. Diversas pessoas utilizam-se desta linguagem para facilitar a realização de inúmeras tarefas administrativas no Linux, ou até mesmo criar seus próprios programinhas. Patrick Volkerding, criador da distribuição Slackware, utiliza esta linguagem para toda a instalação e configuração de sua distribuição. Você poderá criar scripts para automar as tarefas diárias de um servidor, para efetuar backup automático regularmente, procurar textos, criar formatações, e muito mais. Para você ver como esta linguagem pode ser útil, vamos ver alguns passos introdutórios sobre ela.

Interpretadores de comandos são programas feitos para intermediar o usuário e seu sistema. Através destes interpretadores, o usuário manda um comando, e o interpretador o executa no sistema. Eles são a "Shell" do sistema Linux. Usaremos o interpretador de comandos bash, por ser mais "extenso" que o sh, e para que haja uma melhor compreensão das informações obtidas aqui, é bom ter uma base sobre o conceito de lógica de programação.

Uma das vantagens destes shell scripts é que eles não precisam ser compilados, ou seja, basta apenas criar um arquivo texto qualquer, e inserir comandos à ele. Para dar à este arquivo a definição de "shell script", teremos que incluir uma linha no começo do arquivo (#!/bin/bash) e torná-lo "executável", utilizando o comando chmod. Vamos seguir com um pequeno exemplo de um shell script que mostre na tela: "Nossa! Estou vivo!":

#!/bin/bash

echo 'Nossa! Estou vivo!'

Fácil, hein? A primeira linha indica que todas as outras linhas abaixo deverão ser executadas pelo bash (que se localiza em /bin/bash), e a segunda linha imprimirá na tela a frase "Nossa! Estou vivo!", utilizando o comando echo, que serve justamente para isto. Como você pôde ver, todos os comandos que você digita diretamente na linha de comando, você poderá incluir no seu shell script, criando uma série de comandos, e é essa combinação de comandos que forma o chamado shell script. Tente também dar o comando 'file arquivo' e veja que a definição dele é de Bourne-Again Shell Script (Bash Script).

Contudo, para o arquivo poder se executável, você tem de atribuir o comando de executável para ele. E como citamos anteriormente, o comando chmod se encarrega disto:

$ chmod +x arquivo

Pronto, o arquivo poderá ser executado com um simples "./arquivo".

Conceito de Variáveis em shell script

Variáveis são caracteres que armazenam dados, uma espécie de atalho. O bash reconhece uma variável quando ela começa com $, ou seja, a diferença entre 'palavra' e '$palavra' é que a primeira é uma palavra qualquer, e a outra uma variável. Para definir uma variável, utilizamos a seguinte sintaxe:

variavel="valor"

O 'valor' será atribuído a 'variável '. Valor pode ser uma frase, números, e até outras variáveis e comandos. O valor pode ser expressado entre as aspas (""), apóstrofos (") ou crases ("). As aspas vão interpretar as variáveis que estiverem dentro do valor, os apóstrofos lerão o valor literalmente, sem interpretar nada, e as crases vão interpretar um comando e retornar a sua saída para a variável.

Vejamos exemplos:

$ variavel="Eu estou logado como usuário $user"

$ echo $variavel

Eu estou logado como usuário cla


 

$ variavel='Eu estou logado como usuário $user'

$ echo $variavel

Eu estou logado como usuário $user

$ variavel="Meu diretório atual é o `pwd`"

$ echo $variavel

Meu diretório atual é o /home/cla

Se você quiser criar um script em que o usuário deve interagir com ele, é possível que você queira que o próprio usuário defina uma variável, e para isso usamos o comando read, que dará uma pausa no script e ficarará esperando o usuário digitar algum valor e teclar enter. Exemplo:

echo "Entre com o valor para a variável: " ; read variavel

(O usuário digita e tecla enter, vamos supor que ele digitou 'eu sou um frutinha')

echo $variavel

eu sou um frutinha

Controle de fluxo com o if

Controle de fluxo são comandos que vão testando algumas alternativas, e de acordo com essas alternativas, vão executando comandos. Um dos comandos de controle de fluxo mais usados é certamente o if, que é baseado na lógica "se acontecer isso, irei fazer isso, se não, irei fazer aquilo".

Vamos dar um exemplo:

if [ -e $linux ]

then

echo 'A variável $linux existe.'

else

echo 'A variável $linux não existe.'

fi

O que este pedaço de código faz? O if testa a seguinte expressão: Se a variável $linux existir, então (then) ele diz que que existe com o echo, se não (else), ele diz que não existe. O operador -e que usei é pré-definido, e você pode encontrar a listagem dos operadores na tabela:

-eq

Igual

-ne

Diferente

-gt

Maior

-lt

Menor

-o

Ou

-d

Se for um diretório

-e

Se existir

-z

Se estiver vazio

-f

Se conter texto

-o

Se o usuário for o dono

-r

Se o arquivo pode ser lido

-w

Se o arquivo pode ser alterado

-x

Se o arquivo pode ser executado

Outras alternativas

Existem inúmeros comandos no Linux, e para explicar todos, teríamos de publicar um verdadeiro livro. Mas existem outras possibilidades de aprendizado desta língua, que também é usado em todas as programações. Primeiro de tudo você pode dar uma olhada na manpage do bash (comando man bash), que disponibilizará os comandos embutidos no interpretador de comandos. Uma das coisas essencias para o aprendizado é sair coletando exemplos de outros scripts e ir estudando-os minuciosamente. Procure sempre comandos e expressões novas em outros scripts e em manpages dos comandos. E por último, mas não o menos importante, praticar bastante!

Na tabela a seguir, você pode encontrar uma listagem de comandos para usar em sua shell script:

echo

Imprime texto na tela

read

Captura dados do usuário e coloca numa variável

exit

Finaliza o script

sleep

Dá uma pausa em segundos no script

clear

Limpa a tela

stty

Configura o terminal temporariamente

tput

Altera o modo de exibição

if

Controle de fluxo que testa uma ou mais expressões

case

Controle de fluxo que testa várias expressões ao mesmo tempo

for

Controle de fluxo que testa uma ou mais expressões

while

Controle de fluxo que testa uma ou mais expressões

E assim seja, crie seus próprios scripts e facilite de uma vez só parte de sua vida no Linux!

Segunda parte, se aprofundando mais!

Falamos sobre o conceito da programação em Shell Script, e demos o primeiro passo para construir nossos próprios scripts. Agora vamos nos aprofundar nos comandos mais complicados, aprendendo a fazer programas ainda mais úteis. Nestes comandos estão inclusos o case e os laços for, while e until. Além disso, vamos falar de funções e, por último, teremos um programa em shell script.

Case

O case é para controle de fluxo, tal como é o if. Mas enquanto o if testa expressões não exatas, o case vai agir de acordo com os resultados exatos. Vejamos um exemplo:

case $1 in

parametro1) comando1 ; comando2 ;;

parametro2) comando3 ; comando4 ;;

*) echo "Você tem de entrar com um parâmetro válido" ;;

esac

Aqui aconteceu o seguinte: o case leu a variável $1 (que é o primeiro parâmetro passado para o programa), e comparou com valores exatos. Se a variável $1 for igual à "parametro1″, então o programa executará o comando1 e o comando2; se for igual à "parametro2″, executará o comando3 e o comando4, e assim em diante. A última opção (*), é uma opção padrão do case, ou seja, se o parâmetro passado não for igual a nenhuma das outras opções anteriores, esse comando será executado automaticamente.

Você pode ver que, com o case fica muito mais fácil criar uma espécie de "menu" para o shell script do que com o if. Vamos demonstrar a mesma função anterior, mas agora usando o if:

if [ -z $1 ]; then

echo "Você tem de entrar com um parâmetro válido"

exit

elif [ $1 = "parametro1" ]; then

comando1

comando2

elif [ $1 = "parametro2" ]; then

comando3

comando4

else

echo "Você tem de entrar com um parâmetro válido"

fi

Veja a diferença. É muito mais prático usar o case! A vantagem do if é que ele pode testar várias expressões que o case não pode. O case é mais prático, mas o if pode substituí-lo e ainda abrange mais funções. Note que, no exemplo com o if, citamos um "comando" não visto antes: o elif – que é uma combinação de else e if. Ao invés de fechar o if para criar outro, usamos o elif para testar uma expressão no mesmo comando if.

For

O laço for vai substituindo uma variável por um valor, e vai executando os comandos pedidos. Veja o exemplo:

for i in *

do

cp $i $i.backup

mv $i.backup /usr/backup

done

Primeiramente o laço for atribuiu o valor de retorno do comando "*" (que é equivalente a um ls sem nenhum parâmetro) para a variável $i, depois executou o bloco de comandos. Em seguida ele atribui outro valor do comando "*" para a variável $1 e reexecutou os comandos. Isso se repete até que não sobrem valores de retorno do comando "*". Outro exemplo:

for original in *; do

resultado=`echo $original |

tr '[:upper:]' '[:lower:]'`

if [ ! -e $resultado ]; then

mv $original $resultado

fi

done

Aqui, o que ocorre é a transformação de letras maiúsculas para minúsculas. Para cada arquivo que o laço lê, uma variável chamada $resultado irá conter o arquivo em letras minúsculas. Para transformar em letras minúsculas, usei o comando tr. Caso não exista um arquivo igual e com letras minúsculas, o arquivo é renomeado para o valor da variável $resultado, de mesmo nome, mas com letras minúsculas.

Como os exemplos ilustram, o laço for pode ser bem útil no tratamento de múltiplos arquivos. Você pode deixá-los todos com letras minúsculas ou maiúsculas sem precisar renomear cada um manualmente, pode organizar dados, fazer backup, entre outras coisas.

While

O while testa continuamente uma expressão, até que ela se torne falsa. Exemplo:

variavel="valor"

while [ $variavel = "valor" ]; do

comando1

comando2

done

O que acontece aqui é o seguinte: enquanto a "$variavel" for igual a "valor", o while ficará executando os comandos 1 e 2, até que a "$variavel" não seja mais igual a "valor". Se no bloco dos comandos a "$variavel" mudasse, o while iria parar de executar os comandos quando chegasse em done, pois agora a expressão $variavel = "valor" não seria mais verdadeira.

Until

Tem as mesmas características do while, a única diferença é que ele faz o contrário. Veja o exemplo abaixo:

variavel="naovalor"

until [ $variavel = "valor" ]; do

comando1

comando2

done

Ao invés de executar o bloco de comandos (comando1 e comando2) até que a expressão se torne falsa, o until testa a expressão e executa o bloco de comandos até que a expressão se torne verdadeira. No exemplo, o bloco de comandos será executado desde que a expressão $variavel = "valor" não seja verdadeira. Se no bloco de comandos a variável for definida como "valor", o until pára de executar os comandos quando chega ao done.

Vejamos um exemplo para o until que, sintaticamente invertido, serve para o while também:

var=1

count=0

until [ $var = "0" ]; do

comando1

comando2

if [ $count = 9 ]; then

var=0

fi

count=`expr $count + 1`

done

Primeiro, atribuímos à variável "$var" o valor "1″. A variável "$count" será uma contagem para quantas vezes quisermos executar o bloco de comandos. O until executa os comandos 1 e 2, enquanto a variável "$var" for igual a "0″. Então usamos um if para atribuir o valor 0 para a variável "$var", se a variável "$count" for igual a 9. Se a variável "$count" não for igual a 0, soma-se 1 a ela. Isso cria um laço que executa o comando 10 vezes, porque cada vez que o comando do bloco de comandos é executado, soma-se 1 à variável "$count", e quando chega em 9, a variável "$var" é igualada a zero, quebrando assim o laço until.

Usando vários scripts em um só

Pode-se precisar criar vários scripts shell que fazem funções diferentes, mas, e se você precisar executar em um script shell um outro script externo para que este faça alguma função e não precisar reescrever todo o código? É simples, você só precisa incluir o seguinte comando no seu script shell:

. bashscript2

Isso executará o script shell "bashscript2″ durante a execução do seu script shell. Neste caso ele será executado na mesma script shell em que está sendo usado o comando. Para utilizar outra shell, você simplesmente substitui o "." pelo executável da shell, assim:

sh script2

tcsh script3

Nessas linhas o script2 será executado com a shell sh, e o script3 com a shell tcsh.

Variáveis especiais

$0

Nome do script que está sendo executado

$1-$9

Parâmetros passados à linha de comando

$#

Número de parâmetros passados

$?

Valor de retorno do último comando ou de todo o shell script. (o comando "exit 1″ retorna o valor 1)

$$

Número do PID (Process ID)

Você também encontra muitas variáveis, já predefinidas, na página de manual do bash (comando "man bash", seção Shell Variables).

Funções

Funções são blocos de comandos que podem ser definidos para uso posterior em qualquer parte do código. Praticamente todas as linguagens usam funções que ajudam a organizar o código. Vejamos a sintaxe de uma função:

funcao() {

comando1

comando2

...

}

Fácil de entender, não? A função funcionará como um simples comando próprio. Você executa a função em qualquer lugar do script shell, e os comandos 1, 2 e outros serão executados. A flexibilidade das funções permite facilitar a vida do programador, como no exemplo final.

Exemplo Final

Agora vamos dar um exemplo de um programa que utilize o que aprendemos com os artigos.

#!/bin/bash

# Exemplo Final de Script Shell

Principal() {

echo "Exemplo Final sobre o uso de scripts shell"

echo "------------------------------------------"

echo "Opções:"

echo

echo "1. Trasformar nomes de arquivos"

echo "2. Adicionar um usuário no sistema"

echo "3. Deletar um usuário no sistema"

echo "4. Fazer backup dos arquivos do /etc"

echo "5. Sair do exemplo"

echo

echo -n "Qual a opção desejada? "

read opcao

case $opcao in

1) Transformar ;;

2) Adicionar ;;

3) Deletar ;;

4) Backup ;;

5) exit ;;

*) "Opção desconhecida." ; echo ; Principal ;;

esac

}

Transformar() {

echo -n "Para Maiúsculo ou minúsculo? [M/m] "

read var

if [ $var = "M" ]; then

echo -n "Que diretório? "

read dir

for x in `/bin/ls` $dir; do

y=`echo $x | tr '[:lower:]' '[:upper:]'`

if [ ! -e $y ]; then

mv $x $y

fi

done

elif [ $var = "m" ]; then

echo -n "Que diretório? "

read dir

for x in `/bin/ls` $dir; do

y=`echo $x | tr '[:upper:]' '[:lower:]'`

if [ ! -e $y ]; then

mv $x $y

fi

done

fi

}

Adicionar() {

clear

echo -n "Qual o nome do usuário a se adicionar? "

read nome

adduser nome

Principal

}

Deletar() {

clear

echo -n "Qual o nome do usuário a deletar? "

read nome

userdel nome

Principal

}

Backup() {

for x in `/bin/ls` /etc; do

cp -R /etc/$x /etc/$x.bck

mv /etc/$x.bck /usr/backup

done

}

Principal

Terceira parte, janelas graficas

Nos dois topicos anteriores, vimos algumas coisas básicas e lógicas de programação em shell no Linux. Agora para completar, darei aqui dicas de como usar janelas gráficas em seus shell-scripts. Isso mesmo, janelas que rodam no ambiente gráfico, utilizadas facilmente em seu shell-script. Com esse recurso, vai ser possível deixar o seu programa bem amigável.

Não vai ser preciso saber muita coisa de programação em shell, pois é muito simples. Através do programa Xdialog, você poderá criar os mais variados tipos de janelas para o programa: caixas de texto, seleçÕes, radios, etc. O Xdialog é uma idéia que vem do dialog/cdialog, um programa para console que gera "janelas" no console (aquelas da instalação do Slackware) usando a biblioteca ncurses. O Xdialog ao invés de usar a biblioteca ncurses, usa a Xlib para criar as janelas no ambiente gráfico.

Primeiro de tudo será necessário você obter o Xdialog no seu sistema. Não é comum o Xdialog estar incluso nas distribuições, então você terá de pegar e compilar o programa. Obtenha o programa no CD da Revista ou visite o endereço oficial do Xdialog, que é http://xdialog.free.fr. Aqui eu peguei o arquivo Xdialog-1.4.5.tar.bz2, e agora vamos aos passos básicos para instalar ele. Primeiro descompacte-o com o comando bunzip2 Xdialog-1.4.5.tar.bz2, e logo em seguida tar xpvf Xdialog-1.4.5.tar. Um diretório chamado Xdialog-1.4.5 será criado, e entrando nele você estará pronto para compilá-lo e instalá-lo. Para fazer isso use os comandos ./configure, depois make e por último make install. No passo do make install, o binário do Xdialog será colocado em /usr/local/bin. Pronto, agora você já poderá utilizar o Xdialog através de qualquer shell-script.

E agora vamos à ação! Como aprendemos nos artigos anteriores, em shell-script é só colocar o comando dentro do arquivo que ele já vai ser executado quando o script for executado. Então só o que temos de aprender aqui é como usar o Xdialog. Vamos ver um primeiro exemplo:

#!/bin/bash

 
 

Xdialog --title "Exemplo número 1!" --center --stdout --yesno \

"Isto é legal?" \

0 0

 
 

echo $?

Como você pôde ver, o programa Xdialog gerou uma janela com título "Exemplo número 1!", perguntando "Isto é legal?" e com opções de Sim e Não. Note que a \ (barra) serve para indicar à shell para continuar o comando da linha seguinte, então estas três linhas são que nem uma só. Como último comando do exemplo dado, temos o echo $?, que eu coloquei apenas para indicar qual foi o retorno da pergunta. Caso o usuário apertou em Sim, o retorno vai ser 0, e se apertou em Não, vai ser 1. Podemos usar este retorno para controlar o que o usuário escolher. Vejamos um exemplo:

Xdialog --title "Exemplo número 2!" --center --stdout --yesno \

"Neste exemplo, vamos ver o que você quer fazer. Você deseja continuar com o programa?" \

0 0

 
 

if [ $? = "0" ]; then

echo "Que bom! Você continuou o programa! Parabéns!"

elif [ $? = "1" ]; then

echo "Você saiu do programa..."

fi

Viu como funciona? Agora vamos ver outros recursos que o Xdialog pode oferecer. Eu vou dar vários exemplos aqui e sair comentando cada opção. Você precisará praticar bastante e conhecer as várias opções. Primeiro vamos gerar uma simples mensagem pro usuário ver:

Xdialog --title "Aviso" --center --stdout --msgbox \

"Este programa é apenas um exemplo para você ver como o Xdialog \

\nfunciona. Apropósito, se você praticar bastante pode criar \

\nprogra mas incríveis e facilmente, que daria muito mais \

\ntrabalho fazendo em outras linguagens." \

0 0

O usuário aperta Ok e o shell-script continua normalmente. No primeiro exemplo eu usei a opção –yesno que gerava o sim e não. Agora usei o –msgbox. Mas e se você quiser que o usuário digite algo e isto seja gravado em um arquivo por exemplo? Vamos ver este exemplo:

Xdialog --title "Que Anime que você mais gosta?" --center --inputbox \

"Se você sabe o que é Anime, e gosta, qual o seu preferido?\n \

Sua resposta será gravada no arquivo resposta." \

0 0 2> resposta

Depois que o usuário preenche o campo e dá Ok, a resposta que este usuário digitou será gravada no arquvio resposta. Isto ocorreu pelo fato de eu ter colocado o direcionador 2> para o arquivo resposta. Se eu colocasse a opção –stdout na linha de comando do Xdialog, a resposta do usuário apareceria na tela. Tente você.

Vamos ver agora seleção de itens, que é uma das coisas mais importantes num programa. Desta vez usaremos a opção –menubox para gerar um menu com os itens a serem selecionados. Mais uma vez, vamos ao exemplo:

Xdialog --title "Exemplo de Menu" --center --stdout --menubox \

"Qual sua distribuição Linux favorita?" \

20 50 0 \

1 "Slackware" \

2 "Debian" \

3 "Red Hat" \

4 "Conectiva Linux" \

5 "Eu tenho minha própria distribuição"

Viu como é fácil? O que o usuário escolher vai aparecer como resultado no console (por causa da opção –stdout). Se eu colocasse o redirecionador 2>, poderia ir para um arquivo como no exemplo anterior. Vamos esclarecer uma coisa aqui também… Depois do texto "Qual sua distribuição Linux favorita?", há 2 números. Estes dois números correspondem à altura e comprimento da janela. Nos exemplos anteriores eu coloquei "0 0″ pois aí o Xdialog dimensiona automaticamente o tamanho da janela. Então já sabe, se quiser mudar o tamanho da janela, é só mudar estes dois números.

Agora como último exemplo, vamos criar uma janela em que o usuário poderá escolher uma ou mais opções. Isto é chamado de checklist, e pode ser visto no exemplo a seguir:

Xdialog --title "Último exemplo - checklist" --center --checklist \

"Como se pronuncia Linux?" \

0 0 0 \

"Opção 1" "Láinucs" off \

"Opção 2" "Lenocs" off \

"Opção 3" "Linúcs" off \

"Opçào 4" "Línucs" on \

"Opção 5" "GNUUU/Linux" off

Veja agora a diferença entre esta checklist e o menu do exemplo anterior. Verifique que depois de cada opção há o on e o off. O on indica que esta opção deverá já estar marcada, e o off que não deverá estar marcada. Se o usuário escolher 3 opções, as mesmas serão o resultado.

Bem fácil criar uma interface amigável para suas shell-scripts. Se você pensa que isto é tudo, ainda tem muito mais por trás do Xdialog. Para não ter que ficar comentando cada opção, vou dar uma lista de parâmetros e a descrição de suas funções. O que você deverá fazer é sair testando todas as opções e se impressionar :)

–yesno

Uma janela com opções de "Sim" ou "Não"

–msgbox

Apenas mostra um texto informativo

–infobox

Mesmo que –msgbox, só que desaparece automaticamente em um determinado tempo

–inputbox

O usuário preenche um campo

–rangebox

Escolhe um número entre X e Y, com uma barra de rolagem

–textbox

Mostra o conteúdo de um arquivo numa caixa de texto

–editbox

Edita o conteúdo de um arquivo numa caixa de texto

–menubox

Cria um Menu de opções, onde se seleciona um item

–checklist

Mesmo que –menubox, só que pode-se selecionar vários itens

–radiolist

Mesmo que –menubox, mas agora em outro estilo

–treeview

Opções organizadas em forma de "árvore" (interessante)

–gauge

Um indicador de processo

–tailbox

Mostra o conteúdo de um arquivo

–fselect

Abre uma janela de seleção de um arquivo

–dselect

Abre uma janela de seleção de um diretório

–calendar

Mostra um calendário para escolher uma data

–timebox

Mostra uma janela para edição de horário

Você também pode encontrar alguns exemplos no diretório samples que vem junto com o código-fonte do programa. Se você fizer algum programa legal em shell-script, sinta-se a vontade para me mandar um e-mail. Outra coisa, como o Xdialog é uma idéia tirada do dialog/cdialog (existe também o whiptail que é parecido), você pode usar a mesma sintaxe para criar estas "janelas" no modo console. Espero que estas informações foram úteis a você e até a próxima :)

 
 

Article printed from Devin: http://www.devin.com.br

URL to article: http://www.devin.com.br/shell_script/

URLs in this post:

[1] Image: http://www.novatec.com.br/livros/shellscript/?idA=100