Matéria



Ferramentas para acelerar programas Python


Por Ankur Kumar Sharma
Publicado em 12/05/2014

Este artigo foi visualizado 2257 vezes.

Versão para impressão Enviar por email



Python é uma das melhores linguagens de programação já criadas. É maravilhosamente fácil de usar, com grande suporte de bibliotecas. E também oferece excelente produtividade do programador e flexibilidade, mas, infelizmente, perde frente ao desempenho. O Python é uma linguagem de programação interpretada e dinâmica baseada em bytecode que é executada através da máquina virtual, o que significa que os programas em Python são mais lentos que as linguagens de programação compiladas nativamente como C e C++. Outro problema com o Python é a falta de suporte para processadores multicore, agora padrão. Esses fatores de amortecimento de velocidade no Python são frustrantes para os desenvolvedores, que muitas vezes precisam alternar na escrita de pedaços de código complicados em C ou C++ para equilibrar as desvantagens de desempenho do Python. Felizmente, a comunidade FLOSS fornece algumas ferramentas que ajudarão o usuário a turbinar seus programas em Python.


Porque o Python é lento


 Se o usuário quiser saber por que seus programas em Python são mais lentos do que os programas criados em linguagens como C e C++, a resposta está nas camadas e transformações pelas quais um programa Python sofre antes de executar. Quando compilamos e linkamos um programa em linguagens como C e C++, o programa inteiro é convertido em instruções executáveis ​​nativas que o mecanismo de execução de hardware interpreta.

Em contraste, a execução de um programa em Python é um processo de duas etapas. Em primeiro lugar, um programa Python é convertido em uma representação intermediária independente de plataforma conhecida como bytecodes. Esta compilação bytecode dispara automaticamente quando executamos programas em Python, seja incluindo o caminho do interpretador Python no topo dos arquivos de origem ou através do python filename.py. As instruções de bytecode são então interpretadas através de um aplicativo da plataforma nativa conhecido como máquina virtual Python. A referência oficial – e a implementação mais popular da máquina virtual Python - é CPython, e isso deveria ser óbvio pelo próprio nome da linguagem de programação C. Cada instrução bytecode invoca uma rotina C que compreende uma instrução nativa múltipla para realizar a tarefa codificada pelo bytecode. Este processo inicia os atrasos de execução.

Python é uma linguagem de programação dinâmica, na qual cada tipo de dado é um objeto, mesmo que se pareça com um tipo de dado nativo. Se digitarmos i = 7; f = 3.14 na linha de comando interativa do Python e então dir(i); dir(f), veremos uma lista de vários métodos e atributos associados a i e f. Como apenas os valores possuem uma correspondência em Python, e não os objetos, atribuimos diretamente os valores para vários objetos em um programa Python sem declarar seus tipos, o oposto de linguagens estáticas como C e C++, em que primeiro temos que declarar os tipos dos objetos nativos ou abstratos antes de manipulá-los. Além disso, podemos ligar diferentes tipos de valores para objetos em Python no tempo de execução. Assim, o tempo de execução em Python também tem que deduzir os tipos de objetos e converter esses objetos para os tipos de dados nativos para formar as instruções nativas a serem executadas na CPU. Este tipo de dedução e tradução é outra fonte de sobrecarga para o Python.

Os vários objetos em Python são alocados e desalocados através de um subsistema para o gerenciamento automático de memória conhecido como gc (garbage collector). A atividade gc executa atrás de um certo número de alocações de objetos para gerenciar e liberar a memória de objetos inacessíveis. Durante os ciclos do gc, as outras atividades param, por isso, se os ciclos gc forem longos, introduzirão atrasos na execução do código Python.

A máquina virtual Python lida com muitos objetos globais e módulos de código nativo externos sem threads seguras. Assim, o interpretador Python garante que apenas uma única thread em execução modifica os objetos globais e garante a segurança da thread, garantindo um bloqueio de exclusão mútuo para a thread programada conhecida como GIL (Global Interpreter Lock) [1]. O design do interpretador Python torna-se mais simples e mais fácil de manter, mas introduz outro efeito colateral de amortecimento de velocidade. Por conta do GIL, os programas em Python não podem tirar proveito dos processadores multicore modernos que são capazes de executar múltiplas threads de instruções em paralelo. Isto significa que mesmo se o usuário escrever seus programas em Python, sob threads múltiplas, o interpretador Python só irá executar uma thread por vez em um core da CPU, e os cores restantes não são utilizados pelo interpretador Python.



Figura 1: Baixe o Psyco pelo site do projeto.


Psyco


A opção mais fácil para acelerar seus aplicativos Python sem alterações no código é usar o Psyco [2]. O Psyco é um módulo Python carregável, então o usuário deve apenas importar o módulo Psyco e adicionar uma ou duas linhas para acelerar o código existente. O Psyco é um trabalho maduro que que existe há muitos anos, mas atualmente encontra-se em modo de manutenção e só está disponível para distribuições Python de 32 bits em arquitetura de processador x86. De acordo com o autor do Psyco, o trabalho atual e futuro relacionado a ele é direcionado a uma nova implementação Python conhecida como PyPy. O Psyco tem por objetivo fornecer acelerações na faixa de duas a 100 vezes, geralmente em torno de quatro vezes, mais rápido do que a fonte Python não modificada e o interpretador padrão. Ele está disponível para várias plataformas de sistemas operacionais, incluindo GNU/Linux, BSD, Mac OS X e Windows.


O Pysco funciona um pouco como os compiladores JIT (Just in Time) em outras linguagens de programação baseadas em máquinas virtuais, como o Java. Na verdade, o Psyco é como um compilador JIT que compila pedaços de bytecodes Python em instruções nativas da máquina em tempo de execução, mas faz mais que um compilador JIT. Ele cria várias versões do código nativo compilado para diferentes tipos de objetos, correspondendo a um único pedaço de bytecode Python. O Psyco cria um programa Python em tempo de execução e marca algumas partes do programa como zonas quentes, para as quais emite as instruções de máquina nativa. Ele continua usando as várias versões dos pedaços nativos de código de máquina gerados para os vários tipos de objetos usados ​​nas zonas quentes. Dessa forma, o Psyco tenta adivinhar as partes dos programas Python orientados para o desempenho e os compila em pedaços de código nativo para fornecer o equivalente em desempenho a linguagens nativas compiladas como C e C++. Também realiza várias otimizações de tempo de execução para emitir as instruções de código nativo melhor otimizadas.

O Psyco é escrito em C, então precisamos de ferramentas de compilação padrão para compilá-lo. Também precisamos dos cabeçalhos Python padrão para instalar o programa a partir do pacote de código. Para completar as dependências, digite o seguinte comando em um console de texto em um computador Ubuntu de 32-bits:


sudo apt-get install build-essential &&
sudo apt-get install python-dev


Agora siga para a página do projeto Psyco (figura 1), baixe a última fonte tarball, e entre com o seguinte código no console de texto:


tar zxvf psyco-version-src.tar.gz && cd psyco-version



Finalmente, insira o comando com sudo ou direitos de su


python setup.py install 


para uma instalação completa do Psyco.

Se tudo correr bem, digitar python -c 'import psyco' no console de texto deve dar certo, o que significa que agora estamos prontos para brincar com o Psyco. Se o usuário se sentir pronto para colocar o Psyco em seu aplicativo Python sem ler mais sobre ele, acrescente em seguida as seguintes linhas:

try:


import psyco


psyco.full()


except ImportError:


pass


 


Um lugar recomendado para colocar essas linhas é o início do caso if '__main__' == __name__ em seu aplicativo Python. A função psyco.full() instrui o Psyco a invadir todo o código Python e compilar nativamente o máximo possível. Os aumentos de desempenho exatos do Psyco são difíceis de adivinhar por conta do intrincado mecanismo que o sistema usa para gerar versões compiladas nativamente dos programas em Python, mas existem algumas regras de ouro para extrair os maior aumento de desempenho.


O Psyco é útil principalmente para programas em Python que estão vinculados à CPU (por exemplo, com looping, cálculos matemáticos, walking lists, strings e operações com números). O Psyco pode não ser útil para código Python que é limitado ao I/O (por exemplo, à espera de eventos de rede, leitura e escrita de disco, operações de bloqueio) porque o desempenho nesses casos é dificultado pelo Global Interpreter Lock (GIL) e o Psyco tem não tem controle sobre isso. Como o Psyco gera várias versões de pedaços de código nativo otimizado para diferentes tipos de objetos, ele precisa de uma grande quantidade de memória adicional. Isso degrada o desempenho do programa, se o usuário tentar fazer o Psyco trabalhar em programas Python inteiros que não sejam adequados para ele. Por esta razão, o usuário só deve usar psyco.full() para casos em que os programas são curtos ou nos quais tenha a certeza de que a CPU é a origem dos problemas de desempenho.


Use psyco.profile() no lugar de psyco.full() se quiser instruir o Psyco a não invadir todo o programa Python, mas primeiro descrever e, em seguida, compilar nativamente apenas as partes críticas nessa desscrição. A função profile() é recomendada no caso de grandes programas. Além disso, o usuário pode passar um valor de marca d'água entre 0.0 e 1.0 que indica a proporção de funções compiladas nativamente. O valor de marca d'água padrão é 0.09, se o usuário não passar qualquer valor para o profile(). As funções psyco full() e profile() possuem outro argumento memória que especifica o limite de kilobyte de onde as funções são compiladas. O Psyco também fornece uma função log() para habilitar o log. O código Psyco a seguir habilita o log e a descrição da compilação das funções que somam pelo menos 7% do tempo e menos de 200KB por função:



Figura 2: Google é o host do Unladen Swallow, projeto dedicado à construção de aplicativo Python otimizado.


psyco.log()


psyco.profile(0.07, memory=200)


 


Com psyco.bind() e psyco.proxy(), podemos controlar a seleção das funções que o Psyco compila. Ambas as funções Psyco levam o nome da função individual para compilar, mas proxy() apenas compila a instância particular da função que toma como argumento, não todas as instâncias da função chamada no programa Python. O bind() compila a função original passada a ele, assim como as funções chamadas no nome do argumento de função que ele carrega. No seguinte exemplo de código, todas as instâncias do function1 e as funções internas que ele chama são compiladas nativamente, mas apenas a instância g do function2 é compilada nativamente:



psyco.bind(function1)


g = psyco.proxy(function2)


g(args)


function2(args)


 


Assim, podemos melhorar o desempenho em tempo de execução através do Psyco com apenas algumas linhas adicionais e um pouco de entendimento sobre a natureza dos programas em Python. Com um pouco de tentativa e erro, é possível escolher os melhores modos de acelerar o Psyco em programas Python. O Psyco vem com muitos programas de teste em Python no subdiretório teste do diretório de fontes. Para mais informações, consulte a documentação fornecida na página do projeto Psyco.


Unladen Swallow


O fundador do Python, Guido van Rossum, trabalha para o Google, e o Python é uma das três linguagens de programação oficiais utilizadas lá - juntamente com C++ e Java. Um dos resultados das melhorias do Python no Google é o Unladen Swallow [3], um ramo de otimização da base de código padrão do Python (figura 2). O principal objetivo do Unladen Swallow é manter compatibilidade total com o CPython e suas bibliotecas e ainda proporcionar um aumento de cinco vezes no desempenho. O Unladen Swallow é baseado em Python 2.6.1 e apenas muda o tempo de execução do Python. Atualmente, o YouTube faz uso maciço do programa.

O projeto Unladen Swallow implementou a compilação JIT para melhorar o desempenho de tempo de execução dos programas em Python. A implementação atual do tempo de execução do Unladen Swallow converte os bytecodes Python de todas as funções quentes para LLVM (Low-Level Virtual Machine) IR (Intermediate Representation), e este resultado intermediário é então compilado para o código de máquina nativo. Os planos de longo prazo do projeto são para mudar a máquina virtual baseada na pilha CPython para a máquina virtual baseada em registradores com base no código LLVM para extrair mais aceleração. O projeto também adicionou muitas melhorias ao garbage collector do CPython para executar menos ciclos de coleta e diminuir os atrasos causados ​​pelo garbage collection.

O Unladen Swallow é um projeto em andamento, então o usuário deve compilá-lo a partir do código fonte, depois de fazer o fetch do código do tronco do projeto SVN. Os pré-requisitos para compilá-lo são llvm e clang. (O usuário vai precisar das ferramentas de compilação padrão utilizadas anteriormente com Psyco para compilar llvm e clang). A página do projeto Unladen Swallow fornece informações detalhadas sobre a instalação. A página do projeto fornece também a suite de teste Python para o benchmark do Unladen Swallow contra o CPython.


Shed Skin


Shed Skin [4] eleva o desempenho do código Python fazendo uso de uma abordagem diferente. Ele toma os programas escritos em Python em um subconjunto estático da linguagem Python padrão e gera o código C++ otimizado correspondente. O código C++ gerado pode ser compilado como um aplicativo nativo ou o módulo de extensão a ser importado em programas Python maiores. Desta forma, o Shed Skin pode impulsionar os programas que fazem uso intensivo da CPU com uma velocidade adicional. Atualmente, o Shed Skin está em fase experimental e suporta apenas cerca de 20 módulos da biblioteca padrão, mas parece um projeto muito promissor.

O usuário pode encontrar pacotes .deb e pacotes .rpm para o Shed Skin na página do projeto, além do pacote de código. Para instalar o Shed Skin do código, os pré-requisitos são g++, o garbage collector Boehm [5], e a biblioteca PCRE [6]. Para instalar esses componentes, digite o seguinte comando em um console de texto em uma máquina Ubuntu:


sudo apt-get install g++ libgc-dev libpcre3-dev


Para compilar gc e libpcre para plataformas em que pacotes pré-compilados não estão disponíveis, baixe os tarballs e siga as instruções de compilação. Uma vez que os pré-requisitos estiverem instalados, baixe a última tarball do Shed Skin na página do projeto e execute o seguinte comando em um console de texto:

tar zxvf shedskin-version.tgz && cd shedskin-version


Finalmente, execute o seguinte comando com privilégios sudo ou su no console de texto para uma instalação completa do Shed Skin:



python setup.py install


 


O Shed Skin traduz os tipos Python implícitos para tipos explícitos C++. Ele usa técnicas de inferência de tipos para determinar os tipos usados ​​nos programas Python, e faz análise iterativa dos programas em Python para checar quais valores são atribuídos a diferentes objetos e deduzir seus tipos estáticos. O programa então permite que o usuário combine diferentes tipos atribuídos à variável. E também o obriga a usar somente tipos similares aos elementos de várias coleções Python (tuple, list, set etc).


O uso básico do Shed Skin é:


 


shedskin file.py


O Shed Skin cria o file.hpp, file.cpp e Makefile no diretório de trabalho atual. Ele também oferece algumas opções para controlar a forma como os arquivos de saída são gerados (por exemplo, um arquivo Python adicional é gerado com -a). Finalmente, invoque o makefile gerado para criar o executável compilado correspondente à fonte Python. Muitos programas de teste são fornecidos como um arquivo tar na página do projeto Shed Skin. A página menciona a velocidade de duas a 200 vezes sobre o CPython para os programas de teste. Para obter os programas de teste de exemplo, baixe shedskin-examples-version.tgz e execute o seguinte comando em um console de texto:

tar zxvf shedskin-examples-version.tgz &&


cd shedskin-examples-version


 


Para testar um programa Python JPEG-para-BMP, digite o seguinte comando no console de texto para compilar o executável nativo:


shedskin -m jpg2bmp.mk TonyJpegDecoder.py && make -f jpg2bmp.mk



Figura 3: A página inicial do projeto descreve os benefícios do Wirbel - e também destaca algumas limitações.


Para comparar o desempenho da versão Python e a versão compilada do programa, digite os comandos time python TonyJpeg Decoder.py e time ./TonyJpegDecoder. A versão compilada do exemplo TonyJpegDecoder forneceu velocidade de aceleração sobre a versão Python de 1.5 na nossa máquina Ubuntu. Também tentamos alguns outros programas de teste; a versão compilada do chess.py proporcionou uma aceleração de 12 vezes e sudoku1.py uma aceleração de 31 vezes sobre as versões do Python.


Wirbel: linguagem compilada do tipo Python


O Wirbel [7] é outro projeto experimental interessante para quem objetiva melhorar o desempenho de programas em Python. De acordo com a introdução na página inicial do Wirbel (figura 3), o “Wirbel é uma nova linguagem de programação. Possui uma sintaxe e semântica semelhante ao Python... mas, - ao contrário do Python – o Wirbel é uma linguagem de compilador que compila em código nativo de máquina”.

O Wirbel é como o Shed Skin em relação à utilização de tipos de dados estáticos, e ele também usa a inferência de tipos para deduzir informações sobre os tipos de dados e produzir código executável nativo. O Wirbel é um novo projeto com suporte limitado de biblioteca, por isso atualmente não suporta os amplos recursos do Python, mas pode ser útil para pequenos programas em sintaxes do tipo Python. Para instalar o Wirbel, baixe o pacote de código mais recente do site do projeto e digite o seguinte comando em um console de texto:


tar zxvf wirbel-version.tar.gz && cd wirbel-version


Agora digite ./configure && make para compilar Wirbel, e se a compilação for concluída sem erro, digite make install com sudo ou direitos su no console de texto para instalar tudo. Nas máquinas Puppy de 32 bit e Ubuntu de 64 bits, tínhamos algumas falhas de compilação por conta da remoção de alguns cabeçalhos nas versões mais recentes do g++. Para resolver isso, basta adicionar os cabeçalhos #include<cstdio> tanto em src/Type.cc como src/Location.cc e #include<stdint.h> em baustones/httpd/HTTPRequest.h, respectivamente.


Esses subdiretórios estão no diretório de nível superior de origem. Enviamos a correção para o autor do Wirbel, e esperamos que seja incluído na próxima versão do projeto. Agora devemos ter mais dois comandos no console de texto. Estes são o compilador Wirbel, wic, e um utilitário Wirbel que compila e linka o código .w e executa o código nativo. Podemos adicionar o caminho absoluto do Wirbel com uma hash bang (!#) nos arquivos .w para executá-los como scripts. O compilador Wirbel possui muitos switches, que podemos explorar com o comando man wic.



O Wirbel possui mais algumas diferenças em relação ao Python, além da natureza estática dos tipos de dados. Em primeiro lugar, a extensão para fontes Wirbel é .w e não .py, e se tentarmos compilar os arquivos .py através do compilador Wirbel, obteremos uma mensagem de erro. Outra diferença é que não precisamos importar nada na fonte Wirbel, porque ela não compreende a declaração de importação. O Wirbel encontra tudo o que precisa. E também suporta sobrecarga de função, um recurso não suportado pelo Python. A função de impressão no Wirbel usa parênteses como o Python 3.0. O Wirbel vem com muitos exemplos e testes. Para vê-lo em ação e medir o aumento de desempenho em comparação com programas Python semelhantes, o usuário pode ir além dos exemplos.



Conclusão


Se o usuário está cansado de esperar que seus programas Python executem rapidamente, tente estas ferramentas de otimização inovadoras. O Psyco aumenta o desempenho de forma muito significativa com apenas algumas linhas adicionais. O Unladen Swallow é o novo tempo de execução turbo para Python que otimiza o CPython sem quebrar a compatibilidade com versões anteriores. Finalmente, o Shed Skin e o Wirbel são projetos experimentais que direcionam o subconjunto estático de código Python para proporcionar um desempenho nativo compilado.


 


Mais informações


 


[1] Python GIL: http://blip.tv/file/2232410


[2] Página do projeto Psyco: http://psyco.sourceforge.net/


[3] Página do projeto Unladen Swallow: http://code.google.com/p/unladen-swallow/


[4] Página do projeto Shed Skin: http://code.google.com/p/shedskin/


[5] Home do garbage collector Boehm: http://www.hpl.hp.com/personal/Hans_Boehm/gc/


[6] Home da biblioteca PCRE: http://www.pcre.org/


[7] Home do Wirbel: http://mathias-kettner.de/wirbel_index.html



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Como funcionará o disputado mercado de antivírus para PCs?


Por Felipe Falleti
Publicado em 27/02/2014

Este artigo foi visualizado 3306 vezes.

Versão para impressão Enviar por email



Cuidados com a segurança de seu computador pessoal são tão antigos quanto a invenção destas máquinas. Mesmo na época em que os PCs não se conectavam à web, no início dos anos 90, já havia riscos de, por exemplo, um vírus infectar sua máquina via disquete.


As ameaças se tornaram progressivamente mais perigosas à medida em que se tornou imprescindível manter-se conectado o tempo todo. Uma legião de crackers, em todo o mundo, especializou-se em descobrir brechas e atacar desde computadores pessoais até redes ultraprotegidas, como as da NASA ou de centros militares.

Para os fabricantes de software, como a Microsoft, dona do Windows e do Office, e milhares de desenvolvedores autônomos evitar brechas de segurança tornou-se uma alta prioridade, uma meta tão importante quanto difícil de atingir.

Já para os desenvolvedores de soluções de segurança, o crescimento vertiginoso das ameaças representou uma grande oportunidade de negócio. No fim dos anos 90, por exemplo, marcas como Norton, Kaspersky e McAfee lutavam arduamente para conquistar o PC dos usuários, vendendo licenças de seguranças tão caras quando imprescindíveis para os consumidores. Afinal, quem poderia trabalhar e navegar em paz sem um antivírus?

Nos últimos sete anos, no entanto, desenvolvedores como AVG e Avast transformaram esse mercado e, não à toa, tornaram-se os serviços mais populares do Brasil no segmento de segurança no PC. O motivo desta rápida ascensão foi, sem dúvidas, o fato de oferecerem alternativas gratuitas para os usuários.


Este modelo, chamado de freemium, apesar de transformador, embute um método de negócios que não é, de fato, totalmente gratuito. Uma boa parte das funções de segurança é oferecida gratuitamente e alguns recursos sofisticados, como o internet security, que identifica sites maliciosos, é um recurso premium, pelo qual se paga uma licença anual. O acordo parece, até o momento, vantajoso para o usuário que obtém um certo nível de segurança sem precisar pagar.


Uma próxima etapa do desenvolvimento deste mercado poderá ser o surgimento de soluções totalmente gratuitas, em que o único pagamento que o usuário oferece é sua preferência e o aprendizado que gera para o fabricante da solução, que encontrará outras formas de monetizar sua base de usuários, que não oferecer assinatura ou publicidade invasiva.


Entre as práticas que mais causam desconforto ao usuário, no entanto, estão a instalação forçada de antivírus, que muitas vezes vêm disfarçada em sites de downloads ou atualizações de outros softwares. O recurso de oferta “em par” de software, em si, não é um desrespeito ao usuário se este tiver a fundamental opção de selecionar se quer ou não o novo programa. Quando a instalação é feita sem a autorização do usuário, de forma impositiva, sem dúvidas, configura-se um comportamento reprovável.


Outra prática controversa é a oferta “gratuita” de antivírus seguida pela exibição, não autorizada, de publicidade no desktop do usuário, um modelo de negócios ruim para o usuário.

Um exemplo disso, documentado em fórums e blogs, é praticado pela empresa PSafe. Controlada pelo Quihoo, uma companhia de internet que já enfrentou uma dezena de processos judiciais pelo mundo, a PSafe explora, no Brasil, um modelo que visa conquistar usuários que instalam seu software sem perceber.


A substituição de diferentes modelos de negócio e de plataformas ao longo dos últimos anos deve ser uma constante também ao longo dos próximos anos, com o acirramento da competição entre alternativas gratuitas, freemium, pagas ou monetizadas por publicidade.

Ao mesmo tempo em que o mercado de PCs declina frente ao avanço do comércio de dispositivos móveis, a indústria de segurança para PCs ainda terá que lidar com a preferência do usuário por soluções verdadeiramente gratuitas, eficazes e que não desrespeitem seu uso natural do computador. Um desafio para antigos e novos players deste mercado.


Felipe Falleti é jornalista especializado em tecnologia.


Foto: Wikimedia Commons



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Open. Aberto.


Por Alessandro Jannuzzi
Publicado em 19/02/2014

Este artigo foi visualizado 4710 vezes.

Versão para impressão Enviar por email



É curioso e fascinante notar a diversidade de sentidos que as palavras podem transportar. O poder de mapear coisas em pensamentos faz da Linguagem a mais poderosa ferramenta computacional em uso ininterrupto pela nossa espécie nos últimos 100 mil anos. “Open”, em Inglês e sua tradução para o português, “aberto”, são referências a uma vasta gama de significados.


“Podem entrar, estamos abertos!” – diz o dono de um estabelecimento para seus clientes. Ou então: “Open your mind!” – diz o professor para um aluno relutante em desfazer-se de velhos paradigmas. Ou ainda: “Este é um assunto que foi deixado em aberto.” – diz o pesquisador que busca novas perguntas. Mesmo sendo palavras que podem apontar para diversos significados, algo em comum é compartilhado nesse universo semântico: elas implicam em alguma coisa na qual se pode literalmente entrar e sobre a qual podemos construir algo, pois não foi colocado nenhum ponto final nessa ideia.


Pensando no contexto de gestão de Tecnologia da Informação, o que realmente significa ser uma empresa aberta?


E mais: o que significa, na prática, ter soluções abertas e oferecer espaço para a interoperabilidade?


Open Standards


Com o objetivo de responder essas questões, convido os leitores a me acompanhar em uma breve viagem na história recente da tecnologia para, juntos, refletirmos sobre as várias conotações que o termo “Open” possui na nossa área. No início da década de 70, as recém introduzidas redes de computadores precisavam de algum mecanismo que permitisse que redes construídas em determinada arquitetura de tecnologia pudessem trocar informações com outras, desenvolvidas sobre diferentes componentes. Naquele momento, um protocolo utilizado há alguns anos pela agência de pesquisa do departamento de defesa dos EUA (DARPA) foi adaptado de modo a permitir a comunicação entre redes heterogêneas de algumas universidades americanas e, posteriormente, ampliado para outras instituições acadêmicas no Reino Unido e na Noruega. O TCP/IP foi o primeiro protocolo que permitiu a interoperabilidade entre diferentes arquiteturas de redes físicas em larga escala. Dessa ação de interoperabilidade resultou um backbone batizado de internet e realmente nada mais precisa ser dito sobre esse assunto. O que eu gostaria de ressaltar aqui é que o TCP/IP é um protocolo baseado em padrões abertos. Qualquer desenvolvedor de software pode seguir sua especificação muito bem definida pelo IETF (Internet Engeneering Task Force) nas RFCs 768 (UDP), 791 (IP) e 793 (TCP). O TCP/IP é um caso de extremo sucesso de open standards. Todos os sistemas operacionais utilizados hoje em dia, sejam para PCs, dispositivos móveis, celulares, geladeiras, carros ou máquinas de café utilizam o TCP/IP e baseiam-se nas suas especificações. Este é um primeiro uso do termo “Open” que eu gostaria de ressaltar. E, nesse contexto, “Open” não implica necessariamente em abrir o código fonte, mas em apenas seguir especificações abertas, públicas e consensuadas. Chamo atenção aqui para o consenso. A adoção desse protocolo por todos os fabricantes de software deveu-se essencialmente ao sucesso da sua implementação. Todos os desenvolvedores de sistemas operacionais utilizam os padrões abertos do TCP/IP para criar seu stack de protocolos.


Open Source


Outra onda de uso do termo “Open” ocorreu em meados da década de 80, onde o downsizing era a palavra de ordem nas organizações. A arquitetura de computadores de grande porte (mainframes) da IBM deu lugar à descentralização dos sistemas na plataforma cliente-servidor baseada em PCs. A prioridade à época era deixar a plataforma fechada dos mainframes e partir para a plataforma “Open” do PC em rede. Nesse contexto, o termo referia-se a arquitetura de hardware que poderia ser replicada na produção de componentes por diversos fabricantes. A onda de descentralizar entrou com força total no mercado, impulsionada fortemente por um novo software que tomou conta de todos os PCs: o sistema operacional MS-DOS, de uma pequena empresa de Redmond, nos EUA, recém fundada, chamada Microsoft. Mais ou menos nessa mesma época, no Massachussetts Institute of Technology - MIT, um desenvolvedor de softwares descontente com drivers de impressão da Xerox decidiu enveredar por um caminho ousado: reescrever o sistema operacional UNIX, utilizado em computadores de arquitetura proprietária e sob a patente da AT&T, baseando-se apenas nos parâmetros de entrada e nos resultados gerados pelas system calls de seu kernel. Um duro trabalho de engenharia reversa, diga-se de passagem. O desenvolvedor era Richard Stallman e este trabalho deu origem ao projeto GNU. O diferencial fundamental que Stallman introduziu foi deixar os códigos fontes desses programas abertos. “Open sourced”, embora o termo não fosse usado na época. No início da década de 90, a maior parte das funções de mais alto nível que chamariam as system calls para os serviços prestados pelo kernel já haviam sido reescritas por Stallman e seus companheiros, além de vários utilitários e softwares básicos. A biblioteca de funções, por exemplo, foi chamada de glibc, com um carinhoso “g” de GNU anexado à tradicional libc do UNIX. Nesse momento, faltava apenas um kernel, o núcleo básico de funções do sistema operacional, como gerenciamento de processos, um subsistema de IO e outras funções elementares. Foi aí que um estudante finlandês trouxe a peça final desse quebra-cabeça. Linus Torvalds escreveu o kernel faltante, atribuindo a ele o nome de Linux e usou a glibc para possibilitar que os serviços prestados fossem invocados pelos processos. Em 1998, o termo “Open Source”, referindo-se a disponibilização do código fonte dos programas foi oficialmente cunhado por Erick Raymond e Bruce Perens, que fundaram a Open Source Initiative.



Microsoft OpenTech


Durante todo esse período, a Microsoft sempre utilizou Open Standards em seus produtos, mas nunca havia realmente abraçado a comunidade Open Source. Até então, era uma empresa que baseava sua estratégia em softwares que seguiam padrões abertos, porém com um modelo de desenvolvimento proprietário. A partir dos anos 2000, a Microsoft mudou radicalmente essa visão. Além de continuar primariamente desenvolvendo softwares proprietários baseados em padrões abertos, a empresa passou a abraçar a comunidade Open Source de uma maneira muito singular: por meio de uma iniciativa batizada com o nome de Microsoft Openness, a Microsoft criou um núcleo de desenvolvimento de softwares Open Source (Open Source Technology Center) e recentemente, em 2012, abriu uma nova subsidiária chamada Microsoft Open Technologies, Inc. com o único objetivo de produzir códigos Open Source e participar ativamente da comunidade de desenvolvedores de forma colaborativa. A empresa criou também duas licenças Open Source, a Microsoft Public License e a Microsoft Reciprocal License, além de um site na Internet para servir como repositório de projetos Open Source, chamado CodePlex.


Dentre os projetos desenvolvidos pela Microsoft Open Tech, posso citar:


- Apache Cordova: Cordova é um projeto Open Source, desenvolvido sob a tutela da Apache Software Foundation, que possibilita aos desenvolvedores de aplicações para dispositivos móveis construir seus códigos usando HTML5 para a maior parte dos aparelhos disponíveis no mercado. O projeto implementou uma série de ferramentas e um framework para encapsular os códigos web em aplicativos nativos, que podem ser disponibilizados em lojas de software online de diferentes fabricantes. Através da Microsoft Open Tech, a Microsoft contribui ativamente para o projeto Cordova, ajudando na portabilidade para os dispositivos Windows.


- Pointer Events: Esse é um novo padrão produzido pelo W3C para definir um modelo unificado de input para dispositivos (mouse, canetas e touch) usando diversos navegadores. A Microsoft Open Tech contribui ativamente com correções de erros (patches) para as engines Mozilla e Blink, e está ampliando seu uso criando um protótipo de utilização para o WebKit, uma engine Open Source utilizada por diversos navegadores.


- Dash.js: O DASH Industry Forum tem como objetivo neste projeto criar uma API JavaScript que seja independente de CODECs e navegadores para disponibilizar streaming de vídeo em navegadores com a melhor experiência possível, que se adapte dinamicamente às variações da qualidade do link de comunicações utilizado. A Microsoft Open Tech é membro atuante deste projeto Open Source com várias contribuições.


Para conhecer todos os projetos Open Source com participação ativa da Microsoft Open Tech, visite http://msopentech.com.


No Brasil, existem diversas universidades que participam do Núcleo de Desenvolvimento Open Source e Interoperabilidade – NDOS, patrocinado pela Microsoft Brasil com investimentos e apoio tecnológico, como a Universidade Estadual de Campinas e a Universidade Federal do Rio Grande do Sul, dentre outras. No NDOS, são reunidas ideias, pessoas e projetos voltados à disseminação da cultura do software de código aberto e livre, independentemente de plataformas operacionais. Dentre outras coisas, esse projeto visa a criação de handbooks e white papers sobre interoperabilidade e coexistência de plataformas. Esse projeto também procura incentivar outras iniciativas onde o código aberto e a interoperabilidade sejam o foco. Para mais informações, visite http://www.codeplex.com/ndos.


Cloud


Nos dias atuais, vivemos outro momento de ruptura dos modelos vigentes na história da computação: a migração das soluções baseadas em softwares e hardwares utilizados on-premise para a arquitetura de cloud. Esse momento, assim como os demais períodos citados anteriormente, trará novos significados sobre o que é ser “Open”.


A Microsoft acredita que uma plataforma de Cloud Computing verdadeiramente aberta deve implementar algumas características básicas para possibilitar a migração em larga escala dos sistemas atuais para serviços em nuvem, a saber:


- Suporte a diversos tipos de sistemas operacionais:


O Windows Azure suporta sistemas operacionais LINUX e todo o tipo de aplicativo instalado em suas máquinas virtuais. Isso é válido para a nuvem pública ou privada, incluindo a migração das máquinas virtuais entre essas plataformas.


- Open Standards em cloud:


Como em todos os momentos da sua história, a Microsoft defende fortemente a criação de padrões abertos para serviços de computação em nuvem, de modo que os usuários desses serviços tenham a opção de usar diferentes tecnologias ou fornecedores e que a interoperabilidade e a migração entre diferentes provedores sejam possíveis. O Brasil, através da ABNT, é participante do subcomitê internacional de normas técnicas de computação em nuvem e mantém uma comissão ativa de discussões das normas em desenvolvimento, que conta com a participação da Microsoft.


- Migração fácil e automatizada entre nuvens públicas e privadas:


A possibilidade de mover máquinas virtuais entre nuvens públicas e privadas deve ser algo a ser oferecido como recurso natural para os usuários de cloud. Dessa forma, cabe aos clientes decidir em que momento um servidor deverá estar hospedado em suas próprias instalações e quando essa máquina deve ser transferida para um provedor de serviços. Esse recurso pode ser extremamente útil em situações onde a sazonalidade de picos de processamento exerce grande influência.


- Transparência sobre armazenamento e propriedade dos dados:


O provedor de serviços de computação em nuvem deve deixar claro para seus clientes onde seus dados podem ser armazenados e que a propriedade e direito sobre esses dados é plenamente dos usuários.


Nessa história que estamos construindo juntos, é muito importante ressaltar também a ampliação do conceito de abertura dos códigos fontes para os dados em si. Essa inclusão dos dados impacta diretamente na sociedade, com os conceitos de Open Data e Open Government.


Open Data refere-se a uma especificação simples para tornar públicos dados relevantes para a sociedade, como informações sobre orçamentos de esferas governamentais, dados de engenharia de trânsito, oscilações de marés, estatísticas de criminalidade, senso populacional e qualquer outro tipo de informação que os governos ou entidades possam gerar que sirvam como base para a construção de serviços de extrema relevância para as pessoas.


Para que as iniciativas de conversão de dados internos a uma organização para Open Data sejam efetivas, é necessário um catálogo que indique onde os dados estão sendo disponibilizados.


O projeto “Open Government Data Initiative – OGDI”, desenvolvido pela Microsoft em parceria com a comunidade Open Source, baseado na plataforma Drupal e disponibilizado no repositório do Codeplex, provê uma maneira efetiva e de baixo custo para organizações que buscam oferecer aos cidadãos acesso a dados governamentais, além de dar aos desenvolvedores de softwares a capacidade de buscar esses mesmos dados através de APIs baseadas em padrões abertos. O catálogo permite ainda que sistemas governamentais ou funcionários públicos possam facilmente publicar dados de interesse da população. Os custos da esfera pública para manter este catálogo (que exige grande capacidade de processamento) podem ainda ser reduzidos, movendo sua estrutura para a nuvem, caso isso seja de interesse dessas instituições.


Dentre as regiões que já implementam o OGDI como repositório para seus dados públicos (Open Data), destacam-se:


- Colômbia, com seu portal nacional de Open Data baseado em Windows Azure;


- Portugal, com uma versão customizada do OGDI para catalogar seus dados abertos;


- Cidade de Regina, no Canadá, com um portal Open Data usando OGDI em Azure;


- Ministério da Saúde na Itália, com OGDI DataLab v5 em Azure;


- além da região de Provence e as cidades de Versailles, Saône et Loire na França dentre outras iniciativas similares em outras regiões no mundo.


Para ser capaz de processar essa magnitude de dados, a Microsoft portou para sua plataforma de nuvem uma série de recursos que possibilitam a manipulação de “Big Data”, como as tradicionais versões de SQL Server em clusters computacionais e ainda as mais recentes implementações Open Source de serviços como o HDInsight, o qual permite trabalhar com Hadoop tanto na Nuvem Pública da Microsoft, o Windows Azure, quanto em sua plataforma Windows Server, além de ambientes computacionais de intensa capacidade baseados em bancos de dados MySQL.


Esses serviços podem ser utilizados como Platform as a Service – PaaS no Windows Azure, evidenciando mais uma vez a maneira como a Microsoft abraçou as iniciativas Open Source. Aliás, qualquer solução on-premise baseada em softwares Open Source pode facilmente ser disponibilizada no Windows Azure como infraestrutura ou plataforma de serviços.


Esse é um passo histórico na interoperabilidade entre arquiteturas proprietárias e Open Source, pois na nuvem, a oferta de serviços torna quase transparente essa dualidade para o usuário final.


Ainda na linha de ofertas de serviços de alta relevância para a sociedade baseados em padrões abertos e interoperáveis, a Microsoft recentemente lançou uma iniciativa global para gestão de serviços urbanos chamada CityNext, onde as pessoas e os governos podem trabalhar de forma integrada e criar uma nova maneira de lidar com questões urgentes a todo grande centro. Visite o site do CityNext para maiores detalhes:


http://www.microsoft.com/government/ww/public-services/city-next/Pages/about.aspx


Conclusão


Muito mais ainda pode ser explorado sobre este tema, de modo que possamos nos perguntar o que significa ser aberto de uma maneira mais ampla e profunda, tocando em questões como ética, cidadania e comprometimento com a verdade. Como empresa, a Microsoft orgulha-se de pautar-se por uma relação clara e sólida com seus parceiros e clientes, seguindo a legislação dos países onde atua da mesma forma como qualquer outra empresa nacional, fornecendo mais do que tecnologia; soluções únicas para que as pessoas e organizações possam desenvolver todo o seu potencial. Essa é a missão da empresa, que fica ainda mais fortalecida pela sua constante capacidade de se reinventar. O mundo real é misto e heterogêneo e a interoperabilidade é fator crítico de sucesso para que as pessoas possam usar os softwares como aceleradores de crescimento. A Microsoft enxerga isso claramente, colocando a coexistência entre tecnologias distintas como um de seus carros-chefes na sua estratégia corporativa.


Foi por isso que escolhi a Microsoft como empresa para trabalhar. Para poder fazer a diferença em grande escala e tentar ajudar a levar ao mercado e à sociedade a mensagem de que precisamos erguer (ou seria desenvolver?) mais pontes entre as plataformas computacionais. E quem sabe no futuro, por essas pontes virtuais possam passar aqueles que ainda insistem em viver em suas ilhas.


Esperamos vocês chegarem ou nos convidarem a ir até o outro lado.


Estamos abertos.


Alessandro JannuzziSobre o autor


Alessandro Jannuzzi é Gerente de Estratégias de Plataforma na Microsoft. Possui 17 anos de atuação na área de TI, com grande experiência em administração de sistemas operacionais Linux e UNIX para aplicações de missão crítica. Antes de entrar na Microsoft, participou e liderou diversos projetos de implementação de soluções Open Source em ambientes corporativos em áreas como Segurança da Informação, gestão de servidores e storages, alta disponibilidade e integração de dados. Na sua última atuação fora da empresa, Jannuzzi era responsável pela equipe de DBAs que administra os bancos de dados do grupo CSN – Companhia Siderúrgica Nacional.


Artigos e notícias similares


» Convivência harmoniosa — Entrevista com Djalma Andrade


» Microsoft Brasil abre o jogo — Entrevista com Roberto Prado


» Interoperabilidade e colaboração — Entrevista com Roberto Prado


» Para facilitar a interoperabilidade — Entrevista com Roberto Prado


» Propriedade intelectual e Linux — Entrevista com Roberto Prado


» Conforme o mercado — Entrevista com Roberto Prado


» Microsoft anuncia capacitação gratuita para profissionais que atuam com Linux


» Na Microsoft, código aberto leva outro nome: interoperabilidade



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Combate aos novos malwares exige proteção 360º


Por Marcos Tabajara
Publicado em 29/05/2013

Este artigo foi visualizado 6546 vezes.

Versão para impressão Enviar por email



Hoje em dia todos os carros estão equipados com espelhos retrovisores por um bom motivo. Imagine os problemas de segurança que os motoristas teriam devido à falta de visibilidade. Como você saberia que há um pedestre passando atrás do seu carro enquanto você o manobra? Ou até mesmo, se há um carro de polícia, ambulância ou bombeiros pedindo passagem? Isso é o famoso ponto cego.


Mas nem sempre foi assim. Durante os primeiros 30 anos, carros movidos a gás operavam sem espelhos. Esse acessório não era nem mesmo considerado. Sem congestionamentos e pouca velocidade, os motoristas podiam focar na estrada a sua frente, evitar perigos óbvios e permanecer razoavelmente seguros. Mas quando os carros se tornaram populares e poderosos, novos perigos surgiram e a falta de visibilidade tornou-se um desafio. Os espelhos retrovisores foram criados e logo se tornaram artigos imprescindíveis.


Estamos em um momento similar em relação à segurança da informação. Quando o primeiro vírus de computador apareceu, há aproximadamente 25 anos, a proteção contra ele acontecia por meio de detecção e bloqueio de arquivos a fim de evitar a entrada do vírus na rede. Entretanto, as ameaças evoluíram e estão mais inteligentes e nocivas do que nunca – são capazes de se disfarçar, passar pelos sistemas de proteção, continuar sem serem detectadas e, mais tarde, apresentarem um comportamento malicioso. Focar somente no que está à nossa frente, como, por exemplo, fazer a varredura (scan) de arquivos apenas no ponto inicial, não é mais o suficiente. Depois que arquivos entram na rede, os profissionais de segurança não têm mais como olhar para trás. Sem “retrovisores” eles não podem manter um monitoramento contínuo dos arquivos.


Marcos Tabajara, Country Manager da Sourcefire no BrasilEntão, como é possível ganhar visibilidade e controle depois que um arquivo desconhecido ou suspeito entra na rede? A segurança retrospectiva funciona como os espelhos retrovisores, permitindo um novo nível de eficiência na segurança, combinando detecção retrospectiva e solução do problema em tempo real. Com essa nova abordagem, profissionais de TI na área de segurança podem monitorar, analisar e ficar alerta em relação a arquivos que anteriormente eram classificados como seguros. Com isso, quando necessário, os arquivos são colocados em quarentena e eliminados, possibilitando a criação de mecanismos de proteção para prevenir futuros ataques.


As tecnologias avançaram a fim de proporcionar uma segurança retrospectiva. A primeira delas é análise de big data, termo usado para caracterizar uma quantidade enorme de dados, armazenados em terabytes e até petabytes. A segurança retrospectiva transforma esses dados em informações para ações automatizadas, assim como proporciona inteligência precisa às equipes de segurança da informação no momento da tomada de decisões.


Computação em nuvem é outra ferramenta poderosa que permite a segurança retrospectiva. Aproveitando o ambiente virtual ilimitado, o baixo custo de armazenamento e a capacidade de processamento da nuvem, a segurança retrospectiva usa o big data para manter registros e armazenar arquivos. Com isso, é possível analisar como eles se comportam em relação às últimas informações de ameaças armazenadas na nuvem.


Munidos de conhecimento, os profissionais de segurança da informação podem rapidamente identificar um arquivo suspeito, conter a ameaça, eliminá-la e trazer a operação ao normal. Eles também podem melhorar as ferramentas de proteção e atualizar processos dentro do perímetro de segurança, bloqueando ameaças similares que possam surgir em redes internas e terminais.


Novas perspectivas em segurança surgem juntamente com novas ameaças e tecnologias. Assim como os espelhos retrovisores foram agregados aos carros no momento certo, agora é o momento da área de TI incluir a segurança retrospectiva em seus processos. 



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Gnome 2 recarregado: Maté e Cinnamon


Por Tim Schürmann
Publicado em 11/09/2012

Este artigo foi visualizado 234 vezes.

Versão para impressão Enviar por email




Este conteúdo é exclusivo para assinantes da Linux New Media.


Se você ainda não é assinante, aproveite e assine agora!

Se já é assinante, clique aqui para ser redirecionado até a área de conteúdo exclusivo.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Como projetar e imprimir etiquetas e cartões de visitas com o gLabels


Por Mario Blättermann
Publicado em 24/08/2012

Este artigo foi visualizado 1942 vezes.

Versão para impressão Enviar por email




Este conteúdo é exclusivo para assinantes da Linux New Media.


Se você ainda não é assinante, aproveite e assine agora!

Se já é assinante, clique aqui para ser redirecionado até a área de conteúdo exclusivo.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Como usar a verificação ortográfica na linha de comando


Por Bruce Byfield
Publicado em 17/07/2012

Este artigo foi visualizado 1785 vezes.

Versão para impressão Enviar por email




Este conteúdo é exclusivo para assinantes da Linux New Media.


Se você ainda não é assinante, aproveite e assine agora!

Se já é assinante, clique aqui para ser redirecionado até a área de conteúdo exclusivo.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Shells para todo mundo


Por Bruce Byfield
Publicado em 12/07/2012

Este artigo foi visualizado 2637 vezes.

Versão para impressão Enviar por email




Este conteúdo é exclusivo para assinantes da Linux New Media.


Se você ainda não é assinante, aproveite e assine agora!

Se já é assinante, clique aqui para ser redirecionado até a área de conteúdo exclusivo.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Gnome 3 em fallback mode, você sabe como utilizar?


Por Mario Blättermann
Publicado em 04/07/2012

Este artigo foi visualizado 1702 vezes.

Versão para impressão Enviar por email




Este conteúdo é exclusivo para assinantes da Linux New Media.


Se você ainda não é assinante, aproveite e assine agora!

Se já é assinante, clique aqui para ser redirecionado até a área de conteúdo exclusivo.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Estratégias para Big Data – você tem uma?


Por Antonio Carlos Navarro
Publicado em 03/05/2012

Este artigo foi visualizado 9998 vezes.

Versão para impressão Enviar por email



Inegavelmente estamos vivenciando um verdadeiro tsunami de dados. Provenientes das mais diferentes fontes, eles invadem nossas vidas e alteram a maneira como as empresas comunicam-se com o mercado. Só para citarmos algumas: sensores climáticos, SMS, emails, mídia sociais, fotos, videos digitais, registros em compras online, SACs virtuais, celulares, GPS, e muitas outras. Todos os dias, criamos mais de 2,5 quintilhões de bytes de dados, sendo que 90% destes dados foram gerados nos últimos dois anos. Isto é o que chamamos de Big Data.



Atualmente, as empresas necessitam aproveitar-se desta explosão de dados disponíveis, criando vantagens competitivas para seus negócios. As empresas acumularam na casa dos petabytes de informação durante os últimos anos, e vêem nisto uma grande oportunidade para obterem novas visões sobre seus clientes e o mercado onde atuam. Não por acaso, a pesquisa IBM CIO Study 2011, realizada com 3018 CIOs em 71 países, apontou que 83% dos CIOS entrevistados possuem planos visionários que incluem Business Inteligence and Analytics, buscando aumentar a competitividade de suas empresas.



Um varejista, por exemplo, pode descobrir mais facilmente como a demanda está aumentando para produtos específicos em locais e momentos específicos, e desta forma, podem atender adequadamente este mercado, graças a uma previsão mais precisa e melhor gerenciamento de estoques. Prestadores de serviços da Internet e shoppings virtuais, podem descobrir padrões ocultos na forma sobre como as pessoas usam seus serviços e também as redes sociais, e a partir daí desenvolver novos recursos que auxiliarão as empresas a chegarem mais próximos da necessidade e desejo das pessoas. Outro exemplo é o Instituto de Tecnologia da Universidade de Ontario, que realiza uma vasta análise de dados para obter novos conhecimentos e gerar melhor atendimento ao paciente médico.



Mas como as empresas podem otimizar a utilidade de todos os dados que recebe, transformando-os em informações que poderão lhe trazer alguma vantagem competitiva?



Esta é uma pergunta difícil de responder, em particular no caso das empresas confrontadas por um tsunami de dados. De acordo com recentes pesquisas, de fato, o crescimento de dados da empresa nos próximos cinco anos é estimado em mais de 650%. Pior ainda, cerca de 80% destes dados serão sob forma não estruturada* tornando-os significativamente mais difíceis de serem avaliados e utilizados.
Além do grande volume, existem outros desafios para esta análise, como a variedade (dados são disponibilizados sob vários tipos e formatos, como videos, emails, blogs etc.) e velocidade (dados em tempo real devem ser analisados ​​com velocidade extraordinária para permitir-se criar um valor máximo sobre seu conteúdo).



Que tal se você obtivesse uma maneira de tranformar todos esses dados em informação útil, analisá-los sob infinitas maneiras e formas, descobrindo tendências, rastreando problemas emergentes e estabelecendo com mais precisão o que seus funcionários, parceiros comerciais e clientes realmente precisam e querem?
Aproveitar-se deste grande volume de dados de forma a impulsionar a inovação e obter um melhor resultado para os negócios – esta é exatamente a proposição de valor do conceito Big Data: o poder de orientar as organizações na tomada de decisões de vários tipos e permitir-lhes prosseguir com confiança.



Neste cenário surge o framework open source Apache Hadoop que permite o processamento de grandes volumes de dados através de um cluster de servidores. Sua arquitetura permite a escalonabilidade horizontal de um a centenas de servidores em cluster. Tem se tornado a ferramenta principal para análise de dados estruturados e não estruturados gerados na Internet. Suas características de solução open source, trazem a este cenário o Linux como um sistema operacional já maduro e pronto para soluções que visam capturar, gerenciar e analisar informações sob diversos aspectos e perspectivas.
A IBM mostrou recentemente que seus laborátorios de pesquisas e desenvolvimento tem trabalhado arduamente neste desafio. O IBM Watson que disputou e venceu o programa de perguntas e respostas da TV americana Jeopardy!, mostrou ao mundo uma solução baseada em cluster de servidores RISC Midrange, com sistema operacional Suse, banco de dados DB2 e sua exclusiva tecnologia DeepQA fundada sob o Apache Hadoop e que permitiu ao computador lidar com linguagem natural humana e vencer os principais campeões do programa. Para o desasfio do programa, foram utilizadas mais de 100 técnicas diferentes para analisar-se a linguagem natural, identificar fontes, descobrir e gerar hipóteses sobre um imenso banco de dados, e pontuar as respostas, tornando possível ao Watson identificar a resposta mais precisa e com bom nível de confiança, e tudo em menos de três segundos.



Por sua capacidade de entendimento da linguagem natural e de processar 80 trilhões de operações (teraflops por segundo), o Watson rapidamente tornou-se um sucesso de mídia, mas sua utilização no mundo real apenas começou. A IBM anunciou em Abril de 2012 uma nova solução de servidores otimizados para profunda analise de dados: o novo PowerLinux Big Data Analytcs [1], composto por um cluster de servidores RISC de baixo custo, com até 32 threads simultênos por soquete, Linux RedHat ou Suse e soluções de software fundadas no Apache Hadoop como o InfoSphere BigIngights, direcionado a análise massiva de dados estáticos, e o InfoSphere Stream, com foco na análise de fluxo de dados.
O aplicativo InfoSphere BigInsights traz todo o poder do Hadoop e do MapReduce para a análise massiva de dados armazenados. Permite que empresas de todos os portes possam gerenciar dados em larga escala transformando dados em conhecimento de forma simples e amigável.



O aplicativo InfoSphere Streams realiza complexas análises em tempo real, sobre os dados in-motion, ou seja, enquanto fluem dentro da organização. Ao extrair uma visão a partir de dados fluindo na organização, as empresas podem reagir a eventos enquanto ainda estão acontecendo e mudar rumos e resultados. Por exemplo, instituições financeiras podem inspecionar em tempo real o uso do cartão de crédito para detectar e prevenir transações fraudulentas. Ambos tiram proveito da capacidade dos processadores POWER7 para massivo processamento com até 32 threads simultâneos por core, e sua maior capacidade de cache L3 e largura de banda de memória e I/O, superiores à arquitetura x86 de última geração, e que tornam esta tecnologia RISC ideal para o processamento de dados em larga escala.



Se a analise de Big Data é fundamental para o sucesso das empresas, aí está uma solução que pode ajudar a fazer a diferença!
[1] PowerLinux Bog Data Analytics: http://www-03.ibm.com/systems/power/software/linux/index.html



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

O CIO do futuro: maestro, e não um mestre


Por Felipe Sentelhas
Publicado em 02/05/2012

Este artigo foi visualizado 9967 vezes.

Versão para impressão Enviar por email



Servidores na nuvemO ritmo de mudanças na indústria de tecnologia da informação está mais rápido do que nunca e sua aceleração se mantêm constante. Estamos agora passando por uma das transformações mais significativas da tecnologia empresarial, movida principalmente pela computação em nuvem. Essa nova realidade está excluindo dos CIOs seu tradicional poder de tomada de decisão, uma vez que a nuvem retira da empresa grande parte do processamento e trabalhos de TI de uma empresa. CIOs que abraçam essas novas tecnologias devem almejar tornarem-se conselheiros e mudar todo o papel da tecnologia da informação em suas empresas.


Maestro, ao invés de um mestre


Orçamentos cada vez menores para a área de TI e serviços inovadores de nuvem tornaram possível o financiamento de projetos de cloud computing pelas próprias empresas. Contudo, sem o envolvimento inicial do setor de TI nesses investimentos, esses mesmos serviços não serão facilmente escalonáveis. CIOs devem se envolver o quanto antes nesses projetos para se tornarem os especialistas locais sobre o tema. Com isso o executivo será o orientador de diferentes unidades de negócios, e terá autoridade para influenciar o design de todos os serviços hospedados na nuvem, garantindo que eles interajam entre si e com os sistemas legados. CIOs devem possuir credibilidade para implementar controles distribuídos, orquestrar uma variedade de serviços e manter um panorama coeso do que está acontecendo com todo o negócio. Essa tendência já foi destacada em um artigo de Daryl Plummer, Chief of Cloud Research da Gartner.


Foco nos resultados dos negócios


O novo CIO deve reconhecer que o valor do negócio está em controlar os resultados sem se preocupar com quem os alcança. As medidas tradicionais de sucesso, como a redução de empregados para realizar um serviço ou de custos fixos, não são mais vistos pelos negócios como um grande acréscimo de valor. CIOs que desejam causar um grande impacto em suas empresas são aqueles que podem dirigir discussões sobre transformações de processos de negócios e orquestrar um sistemas de TI que pode acompanhar a velocidade de mudanças em seus negócios. Em uma organização tradicional de TI, todos os esforços de tecnologia da informação estão focados no planejamento de capacidade para lidar com os aplicativos e com pouco tempo para se pensar sobre os resultados do negócio. Ao usar uma solução de computação em nuvem para liberar suas equipes do eterno esforço de manter tudo funcionando, o CIO transformará o setor de TI da empresa, que deixará de ser um custo para a empresa, em especialistas de processos de negócios capazes de oferecer resultados e ganhos maiores para a empresa.


Sirva os clientes internos e externos


Verdadeiros resultados de negócios acontecem quando os CIOs preparam suas equipes para se comunicar e atender a todos os usuários, o que inclui os usuários internos das unidades de negócios das empresas e também os usuários finais. Fazer isso envolve agregar múltiplos aplicativos internos (de vendas, suporte, serviços etc.) e também externos (Twitter, LinkedIn, Facebook, Google+ etc.) e criar soluções que tragam a informação certa para o usuário no momento certo. A mudança está no pensamento, ir além da pessoa que usará a solução dentro da empresa e considerar o usuário final que está sendo atendido. O CIO do futuro divide sua atenção igualmente entre os clientes da empresa e os usuários internos, decidindo como interagir da melhor forma com esses dois perfis através da tecnologia.


Expandindo sua equipe com crowdsourcing


A nuvem mudou a forma como serviços de tecnologia da informações são entregues para as empresas. Agora qualquer empresa com um navegador e conexão na internet pode acessar poder de computação, armazenamento e os aplicativos que precisar. Contudo, quando se considera o desenvolvimento para empresas, mesmo o desenvolvimento para nuvens, as empresas ainda estão usando modelos tradicionais de recursos. A padronização e APIs públicas que as plataformas em nuvem fornecem tornam possível uma forma diferente de trabalho. Como estão todos trabalhando com as mesmas APIs nas mesmas plataformas, é possível que qualquer um crie um aplicativo e o envie para uma reserva global de desenvolvedores para atender à demandas de terceiros. Comunidades de desenvolvedores permitem que os CIOs reajam rapidamente às mudanças no negócio e testar novas ideias sem precisar construir uma equipe para cada necessidade em potencial.


Finalmente, o CIO do futuro tem sua mente voltada para usuários, clientes e resultados do negócio, ao invés de ficar preso no antigo modelo de manter todas as coisas funcionando. Um promotor de mudanças, ao invés de um mantenedor do status quo. Isso é o que departamentos de TI sempre aspiraram a ser, mas agora, tecnologia e comunidade estão unidas para permitir isso.


Baseado no artigo: http://blog.appirio.com/2012/04/cio-of-future-conductor-not-controller.html



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Poupe tempo em tarefas de rotina


Por Dmitri Popov
Publicado em 15/02/2012

Este artigo foi visualizado 11210 vezes.

Versão para impressão Enviar por email



Se você deseja aumentar a eficiência do seu trabalho diário, feito no computador, a sua prioridade número 1 deve ser automatizar as tarefas rotineiras. O utilitário AutoKey é perfeito para realizar este trabalho.


À primeira vista, este utilitário se parece mais com um expansor de textos. Mas ao conhecê-lo melhor, vai ser possível ver que ele tem muitos talentos. Com este aplicativo, é possível automatizar virtualmente qualquer tarefa em seu ambiente gráfico. Desde a expansão de abreviações a operações complexas de formatação de texto. Isto te parece interessante? Continue lendo, então.


Começando a usar o AutoKey


O software aqui é escrito em Python e seu código-fonte é distribuído em um pacote que pode ser facilmente construído nas distribuições baseadas no Debian.


Se você estiver usando o Ubuntu ou um de seus derivados, instalar o AutoKey é fácil através da sua PPA que contém os binários. Neste caso, é fácil instalar o programa de dentro de um terminal, com três comandos simples:


$ sudo add‐apt‐repository ppa:cdekter/ppa
$ sudo apt‐get update
$ sudo install autokey‐gtk


Se você estiver usando alguma variante do Ubuntu baseada no KDE, então o ideal é instalar o pacote autokey-qt, em vez do autokey-gtk.


Tal como qualquer nova instalação de um software, é bom fazer alguns ajustes antes de partir para o uso prático. Para tanto, execute o AutoKey e, no menu, selecione Edit / Preferences. Uma série de opções úteis está dentro da seção General. Muitas delas são autoexplicativas, de forma que você pode facilmente descobrir quais vai querer habilitar ou não.


Figura 1


Na seção Special Hotkeys, você pode mudar os atalhos-padrão de teclado, tais como o que habilita a monitoração, o que mostra a janela principal do AutoKey e o que mostra um menu com a lista de abreviações.


O AutoKey pode lidar com scripts Python (e vamos falar disto mais tarde) e, se você quiser usar módulos Python em seus scripts, pode especificar o diretório em que estes se encontram na seção Script Engine. Qualquer módulo Python que você puser neste diretório ficará disponível para importação em seus scripts.


Por fim, a seção Interface permite selecionar o método a partir do qual o AutoKey irá receber as entradas do teclado e mouse. Na maioria dos casos o método padrão, X Record, funciona muito bem. Mas, se os atalhos de teclado (hotkeys) e as abreviações não estiverem respondendo bem, você pode experimentar outros métodos.


Uma vez ajustado o AutoKey, de acordo com as suas necessidades, você pode começar a povoá-lo com frases e scripts. Vamos começar com uma abreviação que se expande para uma assinatura.


Para manter as coisas organizadas, o AutoKey permite agrupar as entradas em pastas. Portanto, é uma boa ideia criar uma pasta separada para as suas frases. Para isto, selecione File / Create / New Top-Level Folder e dê um nome pra pasta. Ao selecionar a pasta, você pode ajustar sua configuração no painel Folder Settings. Habilite a opção Show in tray menu, por exemplo, para ter acesso a este item a partir do ícone do AutoKey. Se você atribuir uma hotkey à pasta, estas opções ficarão mais facilmente disponíveis.


O próximo passo é adicionar uma frase. Clique com o botão direito do mouse sobre a pasta recém-criada, selecione o item New Phrase no menu de contexto e dê um nome à nova entrada. No painel à direita, digite toda a sua assinatura.


Figura 2


Agora, você deve especificar as configurações da frase. Habilite a opção Show in tray menu, se desejar acessar a frase a partir do ícone de menu na bandeja do sistema. Habilite a opção Always prompt before pasting this phrase, caso queira confirmar sempre antes de inserir a frase. É possível especificar a maneira como o AutoKey insere a frase, usando a lista de opções Paste using.


Agora você vai precisar especificar o método que vai disparar a frase. O mais comum é atribuir uma abreviação à frase. Assim, toda vez em que a abreviação for detectada, o AutoKey automaticamente a expande pra frase apropriada. Para fazer isto, pressione o botão Set, ao lado da coluna Abbreviation e forneça a string abreviada no campo Abbreviation (ass, por exemplo).


Na caixa de diálogo Set Abbreviation, você pode ativar outras opções bastante úteis. Por exemplo, caso você use um caractere de espaço como gatilho pra disparar a abreviação, você vai querer ativar a opção Omit trigger character, que vai remover automaticamente o espaço em branco. E, para disparar a abreviação sem usar nenhum caractere de gatilho especial, habilite a opção Trigger immediately.


Figura 3


Uma outra possibilidade é usar uma combinação de teclas, como gatilho, para disparar a sua abreviação. Para atribuir uma combinação a esta ação, pressione o botão Set na coluna Hotkey e especifique a combinação de teclas desejada.


Por padrão, a frase pode ser disparada em qualquer janela que estiver ativa no momento. Mas o Autokey também permite especificar um, assim chamado, filtro de janela que vai acionar o gatilho apenas se o nome da janela ativa corresponder ao padrão especificado. Por exemplo, se você quiser que o gatilho do AutoKey seja acionado apenas dentro do editor Gedit, especifique o filtro .*gedit. Tal como pode ser visto, os filtros de janelas se baseiam em expressões regulares.


Figura 4


Uma vez feitos todos os ajustes, pressione o botão Save, no canto inferior, e teste as frases criadas.


Usando scripts Python no AutoKey


Além da habilidade de inserir texto pré-definido e expandir abreviações, o AutoKey pode lidar com os scripts Python, que abrem um mundo novo às possibilidades de automação no desktop.


Ainda que você não seja um expert em programação Python, você pode facilmente criar scripts que são verdadeiros poupadores de tempo. Por exemplo, você pode criar um script de uma linha em Python que lança um dos seus aplicativos mais usados. Para isto, crie uma nova pasta no AutoKey para usar com seus scripts e selecione File / Create / New Script e digite a seguinte linha:


system.exec_command("digikam", False)


Atribua uma combinação de teclas ao script criado e, daqui pra frente, você poderá lançar o aplicativo digiKam, fazendo uso do atalho de teclado que você mesmo especificou.


Figura 5


De modo similar, você pode criar scripts para outros aplicativos. Indo mais longe, você pode criar um lançador de aplicativos. Para isto, crie um novo script e digite o código abaixo:


items = ["chromium‐browser", "gnome‐terminal", "digikam"]
retCode, choice = dialog.list_menu(items)
if retCode == 0:
system.exec_command(choice, False)


A primeira linha do código especifica os itens selecionáveis e você pode adicionar quantos mais itens necessitar. A segunda linha ordena a exibição de uma lista de itens selecionáveis.


Quando o usuário seleciona um item da lista e pressiona OK, o item selecionado é, então, passado para o script, que executa o aplicativo selecionado.


Você pode fazer algumas outras coisas legais, fazendo uso dos scripts no AutoKey. Que tal um que permita pesquisar uma palavra usando o serviço Google Define? Você pode fazê-lo no AutoKey, com o seguinte código:


import webbrowser
word = clipboard.get_selection()
webbrowser.open("http://google.com/search?q=define:"+word)


O script usa a rotina clipboard.get_selection para obter a seleção da área de transferência, que é repassada como parte de uma URL à função webbrowser.open. Este mesmo script pode ser adaptado a outros serviços, com uma simples substituição da URL. Por exemplo, você pode usar a URL aqui para procurar palavras na WordNet:


webbrowser.open( "http://wordnetweb.princeton.edu/perl/webwn?s="+word)


O script em questão permite pesquisar palavras selecionadas, mas você o pode modificar para que ele peça a palavra a ser pesquisada, usando a rotina dialog.input_dialog:


import webbrowser
retCode, word = dialog.input_dialog("Enter word", "Enter the word you want to look up")
webbrowser.open("http://google.com/search?q=define:”+word)


E aqui vai outro script simples que cola o texto selecionado em um documento, já aberto, do LibreOffice:


text = clipboard.get_selection()
#window.activate(“LibreOffice” )
#keyboard.send_keys(text+”<enter>” )
if window.wait_for_focus(“.*LibreOffice.*” ):
keyboard.send_keys(“<ctrl>+n” )
keyboard.send_keys(text+”<enter>” )


Você precisa substituir certos caracteres em um determinado fragmento de texto?


Aqui vai um script que faz o serviço:


def specialchar(rstr):
    rstr=rstr.replace("\'", "&#8217;" )
    rstr=rstr.replace("»", "&#187;" )
    rstr=rstr.replace("‐‐", "&#151;" )
    return rstr
text = clipboard.get_selection()
rtext = specialchar(text)
keyboard.send_keys(rtext)


Figura 6


Este script substitui os caracteres especiais por seus códigos em HTML, mas você pode, facilmente, adaptá-lo para executar outras tarefas.


Finalmente, a listagem 1 mostra um script mais complexo, que eu tirei do Grupo de Usuários do AutoKey do Google. Tal como você já deve ter deduzido, se analisou o código, o script encurta certa URL usando o serviço de encurtamento is.dg.


O AutoKey também permite gravar macros, o que provê uma forma de criar scripts através da gravação das teclas pressionadas no teclado e das ações do mouse. Simplesmente crie uma nova entrada de script, clique no botão Record e o AutoKey irá gravar suas ações.


Figura 7


Uma vez povoado o AutoKey com scripts e frases, você vai querer fazer uma cópia de segurança de todas as entradas. O AutoKey guarda seus dados no arquivo  ~/.config/autokey/autotokey.json. Ao fazer backup deste arquivo, os seus dados estarão a salvo.


Conclusão


O AutoKey é uma ferramenta necessária a qualquer um que queira automatizar as tarefas tediosas do dia a dia no uso do computador. Para obter o máximo deste utilitário, você precisa ter um maior conhecimento de Python. Mas, ainda que programação não seja o seu lado forte, o AutoKey é útil em uma série de situações. Dê-lhe uma chance e você, provavelmente, irá acabar por incorporá-lo ao seu arsenal de ferramentas de produtividade.


 


Listagem 1


 



1  import urllib, urllib2, urlparse, httplib
2  def query(url):
3  shortener = 'is.gd'
4  service = '/api.php?longurl='
5  c = httplib.HTTPConnection(shortener)
6  c.request(“GET”, service + urllib.quote(url))
7  r = c.getresponse()
8  shorturl = r.read().strip()
9  if ("Error" not in shorturl) and (“http://" + urlparse.urlparse(shortener) [1] in shorturl):
10  return shorturl
11  else:
12  raise IOError
13  long = clipboard.get_selection()
14  short = query(long)
15  keyboard.send_keys(short)



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Avaliação do Ubuntu 11.04 “Natty Narwhal”


Por Kemel Zaidan
Publicado em 10/05/2011

Este artigo foi visualizado 11298 vezes.

Versão para impressão Enviar por email



Por Kemel Zaidan


Pontualmente, como de costume, o Ubuntu chega com sua mais nova versão: o Ubuntu 11.04, codinome "Natty Narwhal". Ao contrário de outras distribuições, o Ubuntu consegue cumprir seu cronograma, anunciado com meses de antecedência, com pontualidade britânica, fazendo jús à origem da distribuição, que ao contrário do que muitos pensam, não é sul-africana.


Apesar disso, nenhuma dos lançamentos da distribuição até hoje, desde 2004 quando ela apareceu pela primeira vez, foi tão aguardado como este. O início da polêmica em torno do 11.04 começou durante o último UDS (Ubuntu Developers Summit), o encontro semestral dos desenvolvedores Ubuntu, que ocorreu em novembro de 2010 na Flórida. Nesta ocasião Mark Shuttleworth, fundador da Canonical, empresa que patrocina o desenvolvimento do sistema operacional, declarou que a distribuição iria utilizar o Unity como sua interface padrão para a versão desktop.


Na época, blogs e sites de notícia de todo o mundo do software livre começaram a ecoar a novidade e boatos mundo à fora. Alguns deles a fizeram como na velha brincadeira - analógica - do "telefone-sem-fio": acrecentando um ponto a cada conto. As maiores barbaridades que foram ouvidas diziam respeito a um suposto fork do Gnome por parte do Ubuntu, o que por sua vez denota total desconhecimento do conceito do que é, de fato, um fork. Outros (não sei dizer o que é pior) chegaram a declarar que o Ubuntu estaria abandonando o Gnome, como seu ambiente desktop padrão.


Contudo, parece que a maior parte dos que cometeram essas gafes haviam se esquecido de que o Unity já estava em plena utilização como interface padrão do Ubuntu 10.10 "Maverick Meerkat", só que na versão para netbooks, entitulada Ubuntu Netbook Remix (UNR). Foi a primeira aparição da tão comentada interface, que viera substituir a interface para netbooks lançada na versão 9.10 "Karmic Koala".


Mudança inevitável


Gostando-se ou não da mudança, é melhor ir se acostumando, pois nada será como antes no universo Linux, uma vez que um vento de mudança anda soprando a terra dos ambientes desktop e interfaces de usuário. Pode-se dizer que o olho do furacão (e também da discórdia) encontra-se no Gnome, ambiente desktop utilizado não só pelo Ubuntu, mas também por muitas das mais populares distribuições GNU/Linux mundo a fora. A interface de sua mais recente versão, já lançada no último dia 6 de abril, o Gnome-Shell, altera radicalmente a forma como interagimos com o desktop padrão.


O Unity, por sua vez, acompanha as mudanças propostas por este, mas ao invés disso, implementa-as ao seu próprio modo. Qualquer um que tenha utilizado o Gnome-shell perceberá a semelhança entre ambos: barras laterais no estilo dock, ícones grandes na "área de trabalho", possibilidade de iniciar e pesquisar aplicativos através do teclado, novas formas de interagir com o gerenciamento de áreas de trabalho. É possível inclusive dizer que há mais semelhanças do que diferenças entre os dois. Porém, se os dois são tão semelhantes, porque o Ubuntu não utiliza o Gnome-shell ao invés de perder tempo e trabalho criando sua própria interface? A resposta pode ser encontrada nos últimos acontecimentos entre Canonical e Red Hat, esta última a principal patrocinadora de muitos desenvolvedores do Gnome.


Recentemente, a Canonical foi criticada por funcionários da Red Hat por contribuir pouco com o Gnome. A Canonical, por sua vez, rebateu a crítica afirmando que muitas das inovações propostas por ela não eram aceitas dentro do projeto Gnome e que alguns funcionários da Red Hat estariam "boicotando" código enviado por ela. Com possibilidades reduzidas de exercer alguma influencia dentro de um projeto chave como o do Gnome-shell, a empresa teria decidido ela mesma criar sua própria implementação de um "shell para o Gnome", ao mesmo tempo que mostraria para a Gnome Foundation quem é que precisa de quem. Mas boa parte dessas explicações não passam de expeculações, motivadas por fatos, é verdade, mas ainda assim com uma boa dose de boato.


Fique tranquilo, pois caso você não goste do Unity, poderá continuar fazendo uso da insterface tradicional, bastando para isso escolher a opção durante a tela de login do sistema. Agora, o que é importante mesmo é ter consciência de que cedo ou tarde, o Gnome 3 e - com ele seu Gnome Shell - passarão a fazer parte de todas as distribuições que o utilizam como padrão. Apesar de ainda ser possível utilizar a interface clássica, do Gnome, é bem possível que um dia ela seja abandonada (o que não deve acontecer até que as pessoas acostumem-se definitivamente com as novas interfaces). Sendo assim, o Ubuntu apenas antecipou-se a todo esse movimento de mudanças, colhendo com isso os louros e as agruras de seu pioneirismo.


Instalação


Sem dúvida nenhuma o Ubuntu tem o melhor instalador da atualidade. O Ubiquity é simples, intuitivo, fácil de usar e principalmente rápido. Fica difícil encontrar instalador melhor. Após decidir as partições que serão utilizadas pelo sistema, ele já dá início ao processo de transferência dos arquivos do sistema para o disco em segundo plano. Enquanto o usuário termina o processo de instalação respondendo à perguntas como nome das contas, hora, local etc, seu sistema já está sendo instalado. Quando você termina de responder a elas, o processo todo já está quase no fim, dando ao usuário a sensação de que a instalação "passou voando".


Contudo, ainda sinto a falta de algumas funcionalidades, como a possibilidade de escolher um mirror (repositório que "espelha" o conteúdo de um repositório principal) local para baixar as atualizações, que podem ser aplicadas durante a instalação, caso o usuário opte por essa opção. Apesar de ser possível aplicar as atualizações logo depois que a instalação já tiver sido concluída, já passei pela situação de escolher essa opção e ver meu tempo de instalação ser acrescido de longos minutos por conta de lentidão no repositório principal.


Outro pequeno problema que ocorreu durante nossos testes foi a impossibilidade de redimensionar a janela do instalador ao tentar utilizá-lo em um Asus EEE PC 700, de primeira geração. Dessa forma, os botões não couberam dentro das diminutas dimensões da tela de 7 polegadas do EEE. É verdade que este modelo específico tem uma resolução de tela pouco ortodoxa, mas esse problema poderia ser facilmente resolvido se a tal janela pudesse ser redimensionada.


Aplicativos


Outro ponto que chama a atenção é que o sistema vem por padrão com o BrOffice instalado, caso você escolha o idioma português do Brasil durante a instalação, ao invés do OpenOffice.org. Apesar de não haver diferenças nas instalações padrão de ambos, é uma pena que essa novidade não tenha chegado antes, pois agora o BrOffice.org decidiu mudar seu nome para LibreOffice e acompanhar a mudança que foi feita no projeto original, motivada por uma migração maciça de desenvolvedores e usuários do OpenOffice, para seu fork (esse sim) comunitário, o LibreOffice. Seria uma oportunidade do público brasileiro conhecer melhor o projeto de internacionalização do programa para o idioma nacional. Apesar de entender os motivos, pessoalmente, acho que está foi uma decisão precipitada do projeto, uma vez que o nome BrOffice já estava bem estabelecido e trazia uma grande vantagem para os usuários brasileiros: uma migração transparente do OpenOffice para o LibreOffice. Mas isso já é outra história.


Outra mudança perceptível é a substituição do Rhythmbox pelo Banshee. Há algum tempo atrás, ambos tinham uma apresentação muito semelhante, talvez pelo fato dos dois pertencerem ao Gnome. Qual não foi minha surpresa ao me depara com um Banshee com muitas mudanças. A interface, apesar de bastante parecida com o Rhythmbox, está bem mais "clean" e próxima do príncípio KISS (keep it simple, stupid, ou mantenha simples, idiota) que norteia o desenvolvimento do Gnome. Há integração com o serviço LastFM.com que automaticamente sugere músicas e artistas semelhantes aqueles que estão sendo tocados pelo player. Um botão semelhante ao do LastFM te leva para verbete correspondente ao artista da vez na Wikipédia e para minha alegria o Banshee importou o feed de todos podcasts que eu já tinha no Rhytmbox.


Algo que parece ter pesado na escolha do Banshee foi o recém criado plugin para a loja de músicas em MP3 da Amazon (que infelizmente não está disponível no Brasil). Durante o estágio de desenvolvimento pensou-se inclusive em desabilitar o plugin por padrão, para diminuir a concorrência com o Ubuntu One, a loja de músicas do Ubuntu. Apesar disso, ambas estão lá, disponíveis para que o usuário faça as suas escolhas livremente. Nada como um pouco de competição! Não foi possível testar nenhuma das duas, mas a Ubuntu One leva alguma vantagem por vender arquivos sem DRM (digital rights management ou controle de direitos digitais, uma tecnologia que impede cópias e compartilhamento dos arquivos) ao contrário do que faz a Amazon. O sucesso do plugin da Amazon, pode vir a gerar uma boa renda para a Fundação Gnome, que receberá um pequeno repasse a cada compra efetuada através da ferramenta.


No 11.04, houve a extinção da versão Netbook Remix, que deixou de fazer sentido, uma vez que tanto a versão para netbooks quanto a versão desktop trariam a mesma interface. Sendo assim, o Cheese, que era padrão do UNR, deixou de ser instalado. Seria interessante que o instalador reconhecesse a presença de um dispositivo, como uma webcam, por exemplo, e ao menos se oferecesse para instalar um programa que fizesse uso dela. Outro pacote muito útil no caso de dispositivos móveis é o gpointing-devices, que nunca veio instalado por padrão nem na versão URN, mas que permite configurar dispositivos touchpad, presentes na maioria dos laptops e netbooks.


Uma situação parecida ocorre com a instalação do Flash plugin que poderia acontecer como a dos codecs: ao tentar acessar algum conteúdo em flash na web, o sistema alertaria sobre a necessário de instalar o plugin antes que o usuário leigo tentasse baixar a versão para Windows de algum site do tipo "baixaqui". Dessa forma ele estaria não só facilitando a vida dos usuários, como também ensinando a maneira como as coisas funcionam em sistemas livres.


Além disso o sistema vem com o OpenJDK - a versão livre da máquina virtual java - instalado. Ele dá conta da maioria das aplicações e melhorou muito nos últimos tempos. A dificuldade só irá surgir caso tente-se executar algum aplicativo incompatível com ele e que exija a instalação do Java da Oracle. Por estar acessível pelo repositório "partners" e por este vir desabilitado por padrão, fica difícil ao iniciante imaginar qual o procedimento padrão antes de buscar a resposta em algum fórum ou canal IRC.


Central de Programas do Ubuntu


Unity


Muitas pessoas (inclusive este que vos escreve) estavam céticos em relação ao Unity. Quem utilizou a versão presente no Maverick Meerkat sabe que o programa apresentava muita instabilidade. No entanto, depois de seis meses de desenvolvimento e muitas mudanças mais tarde, é preciso dar o braço a torcer e dizer que os desenvolvedores fizeram modificações impressionantes para o espaço de tempo que tiveram.


Para começar, é preciso dizer que o Unity foi reescrito do zero ("from scratch", como costuma-se dizer em inglês). Além disso a biblioteca padrão mudou do Mutter para o Compiz. Apesar disso é possível dizer que o Unity e o Gnome-shell são bastante parecidos e compartilham do mesmo conceito: uma mesma interface utilizável tanto em ambientes desktops quanto nas reduzidas telas dos dispositivos móveis, com ícones grandes e uma barra lateral ao estilo dock.


Barra lateral


Logo de cara, a barra lateral à esquerda da tela é o item que mais chama a atenção. Ela traz atalhos para as aplicações mais utilizada ao mesmo tempo que exibe os ícones de todos os aplicativos abertos. Atalhos para outros aplicativos podem ser incluídos de maneira simples ao arrastar um ícone do Dash para a barra, ou ao clicar com o botão direito do mouse sobre o ícone e escolher a opção Manter no lançador quando este já estiver rodando. Mais para o final da barra, estão os ícones, da Lixeira, Aplicativos e Locais. Quando os ícones não mais cabem no espaço vertical da tela, eles se dobram e retornam a sua posição natural com um "passar de mouse" sobre a barra.


Dash


O botão com o símbolo do Ubuntu, no canto superior esquerdo da tela, agora dá acesso ao Dash, o gerenciador de aplicativos do Unity. Com isso, a mudança dos botões de minimizar, maximizar e fechar para o lado esquerdo da tela, tão criticada na versão Lucid Lynx, passou a fazer muito mais sentido: é melhor ter os botões de controle da janela próximos ao botão que dá acesso aos aplicativos do que cruzar a tela em busca deles.


Dash


Ao clicar no símbolo do Ubuntu, uma janela exibe ícones que te levam para a seção de Aplicativos de mídia, Internet, Mais aplicativos e Pesquisa. Na fileira de baixo há atalhos para Firefox, Shotwell, Evolution e Banshee. Um campo de busca está sempre ativo para que você possa executar o programa a partir do teclado, como fazia antes através da combinação [Alt]+[F2] (Gnome-launcher) ou simplesmente para refinar a busca.


Neste quesito o Unity demonstra alguma funcionalidade extra em relação ao Gnome-shell, pois o Dash mostra sempre os aplicativos mais utilizados, e outras opções semelhantes que podem ser baixadas através da Central de Programas do Ubuntu. É muito útil que o sistema mostre logo de cara os programas que mais uso para determinada busca, pois isso economiza tempo na maior parte das vezes. Também é muito interessante que ele me sugira um determinado programa para uma tarefa para a qual eu talvez não tenha uma ferramenta instalada ou ainda outras ferramentas que me auxiliem na execução desta. No entanto, há momentos em que fica-se desejando que fosse possível desligar a tal opção.


Painel


Outra característica que chama a atenção é o fato do Gnome-panel ter sido substituido por um painel semelhante ao Finder do Mac OS, mas que diferente deste, exibe o menu apenas quando o mouse é levado até ele. Essa última característica às vezes é boa e às vezes é ruim. É boa porque o painel torna-se mais informativo e ruim porque em alguns momentos é fácil esquecer-se que o menu do programa encontra-se no topo da tela; em outras, até mesmo que existe algum menu. Mais uma vez, seria interessante se esse comportamente pudesse ser alterado, passando a exibir o menu do programa ativo o tempo todo e não apenas quando se leva o mouse até ele, de acordo com o gosto de quem usa.


O painel funciona bem, mas até que você se acostume a ir em sua direção para encontrar suas opções de menus, pode ser que isso leve algum tempo. No entanto, não há como negar que as aplicações ficam mais bonitas com o recurso. Além disso, o ganho extra de espaço, principalmente em netbooks e laptops é bastante bem vindo. Algumas aplicações como o BrOffice, não apresentam os menus no painel. De certo alguma dificuldade de integrá-los ao programa, justamente por estes utilizarem bibliotecas gráficas próprias e não aquelas que são padrão no Gnome. O que mais incomoda no painel é de longe não poder utilizar os applets do painel do Gnome com os quais você estava acostumado.


Gerenciamento de áreas de trabalho


Ao se clicar no ícone do Alternador de espaços de trabalho, o Unity revela suas 4 áreas de trabalho. O recurso mais interessante é poder arrastar as janelas de um espaço para o outro, organizando de forma rápida a disposição de seus aplicativos. Mas se você gostava de ter seu cubo rodando com o compiz, esqueça! Não é possível utilizar ambos os efeitos ativados ao mesmo tempo (pelo menos não até agora). E se além disso, você sempre achou que ter apenas quatro áreas de trabalho era algo que te atrapalhava o seu rendimento; ai sim podemos dizer que o Unity não é para você, pois ao contrário do Gnome-shell, que gerencia diversas áreas de trabalho de forma natural, no Unity há hoje a possibilidade de possuir apenas quatro. Nenhuma a mais ou a menos.


Área de Trabalho Unity


Mas nem tudo são flores. Apesar de ser capaz de rodar na maioria dos hardwares existentes hoje em dia, o Unity necessita de alguma aceleração 3D. Isso não significa que você irá precisar de uma placa de vídeo dedicada para essa tarefa, pois boa parte das placas on-board vendidas já há alguns anos no mercado oferecem a aceleração necessária. Contudo, para esses casos a Canonical desenvolveu uma versão 2D do Unity que utiliza bibliotecas em Qt (as mesmas utilizadas pelo KDE). Mas inexplicavelmente, a interface não é instalada por padrão em hardwares incompatíveis com o Unity 3D. Uma falha que esperamos ver corrigida nas próximas versões.


Outro pequeno erro encontrado é que o campo de pesquisa do Dash não aceita acentos, tornando mais complicado encontrar algum aplicativo, arquivo ou pasta que esteja acentuado. Apesar de alguns pequenos bugs, o sistema encontra-se plenamente utilizável. Bem diferente da situação que ocorreu em sua estréia. Considerando-se que está é uma versão intermediária do Ubuntu, há ainda um tempo considerável para que as eventuais arestas do Unity sejam aparadas pelos desenvolvedores até o próxima versão LTS (long term support) prevista para abril de 2012.


Conclusão


Quem teve seu primeiro contato com o software livre em meados dos anos 2000, lembra-se da surpresa que era deparar-se com um desktop GNU/Linux que estivesse executando o Compiz. Todos aqueles efeitos, cubos, chamas e animações deixavam qualquer um impressionado com o que viam. Mas além do deslumbramento, o Compiz trazia também ferramentas que proporcionavam um maior aumento de produtividade; ou alguém é capaz de discordar que ter a possibilidade de trabalhar com diversas áreas de trabalho abertas ao mesmo tempo é algo que torna nossa interação com a máquina muito mais produtiva?


Até mesmo Mac OS e Windows copiaram as inovações do Compiz, que trouxe o universo da aceleração gráfica 3D, utilizado quase que exclusivamente em jogos, para o ambiente desktop, tirando assim maior proveito do hardware disponível. O conceito foi, mais tarde, exaustivamente copiado e ampliado. Prova disso são os diversos programas que fazem uso de abas, como o Firefox, Google Chrome, Nautilus etc. Abas nada mais são do que diversas áreas de trabalho em um mesmo aplicativo.


E se a alguns anos atrás o ambiente Linux era diferente de qualquer outro sistema, por conta de seu vanguardismo, hoje é possível dizer que todos os sistemas operacionais existentes possuem uma aparência muito próxima. Por um lado, isso facilita a migração de usuários de um sistema para outro, mas ao mesmo tempo nivela a experiência do usuário por baixo.


Com as mudanças que estão a caminho, o software livre retoma a dianteira da inovação e tenta, por suas próprias pernas, redefinir os paradigmas da interação homem-máquina em sistemas operacionais modernos. Se esse pioneirismo será benéfico ou não à expansão de sua própria base de usuários, é difícil dizer com precisão, mas prefiro ver o software livre se reinventar, mesmo que isso cause um tropeço ou outro pelo caminho, do que vê-lo sempre correndo atrás das inovações que outros trazem primeiro. O Ubuntu, como expoente máximo das distribuições GNU/Linux atuais, não quer para si o posto de lanterninha, mas a tarefa de iluminar os novos caminhos.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Linux 2.6.33


Por Pablo Hess
Publicado em 04/03/2010

Este artigo foi visualizado 10406 vezes.

Versão para impressão Enviar por email




Foi lançada no dia 24 de fevereiro a versão 2.6.33 do kernel Linux, com o apelido de “Man-Eating Seals of Antiquity”. Linus Torvalds anunciou na LKML a versão mais recente de seu kernel, apontando como novidades mais relevantes a integração do driver de vídeo Nouveau para chips gráficos Nvidia e também do driver para o dispositivo de blocos distribuído DRBD.


Números



O número crescente de linhas de código que compõem o kernel Linux quase alcançou, na versão 2.6.33, a marca dos 13 milhões, distribuídos em pouco mais de 31.500 arquivos.



Durante os 83 dias de desenvolvimento desta versão (isto é, desde o lançamento da versão 2.6.32 em 3 de dezembro do ano passado), 9.673 arquivos foram alterados por 10.871 commits na árvore git oficial.


Gráficos



A inclusão do driver Nouveau para chips Nvidia na árvore staging, com o recurso de kernel mode-setting, certamente facilitará a vida de muitos usuários. No entanto, o driver ainda não oferece aceleração 3D --- embora já ofereça mais recursos do que seu "concorrente" nv. Vale lembrar que o código do Nouveau ainda é considerado imaturo, motivo pelo qual ele se encontra na árvore staging.



Os drivers para chips Radeon R600 e Intel também tiveram pequenos avanços.


Armazenamento



O DRBD (Distributed Replicated Block Device, ou dispositivo de blocos replicado e distribuído), há tempos um recurso externo ao kernel (apesar de sua grande utilidade), finalmente foi incluído. Equivalente a um "RAID1 via rede", como descrevem seus desenvolvedores, o DRBD é uma ferramenta excepcional em ambientes de alta disponibilidade, e certamente vai contribuir para o avanço do Linux nesse terreno.



No campo dos discos locais, o maior avanço é o suporte ao comando ATA TRIM no subsistema Libata. Com esse comando, o kernel se torna capaz de informar aos dispositivos quais áreas do armazenamento estão livres – o que pode aumentar significativamente a vida útil dos dispositivos SSD, entre outras vantagens. Contudo, o novo recurso ainda não foi extensivamente testado e permanece desativado por padrão.



Entre os escalonadores de I/O, uma despedida: o antigo anticipatory foi descartado, pois oferecia apenas uma fração das funções do escalonador CFQ, padrão tanto para desktops quanto para servidores.



O subsistema MD também sofreu mudanças, com vantagens e desvantagens: ao ganhar suporte a barreiras de escrita (ou write barriers, como são mais conhecidas), dispositivos RAID via software agora são mais confiáveis e resistentes a falhas, ao custo de um desempenho sensivelmente pior.



O sistema de arquivos "legado" ReiserFS já está em estágio de manutenção há muitas versões do kernel, mas isso não o impediu de progredir na remoção da Big Kernel Lock (ou BKL, como é mais conhecida), potencialmente aumentando seu desempenho.


Memória comprimida



Há poucos meses, um desenvolvedor propôs um mecanismo interessante para compactar os dados armazenados na memória RAM. Com o uso de um ramdisk compactado como dispositivo de swap, o sistema poderia alcançar desempenho significativamente maior, ao mesmo tempo em que conseguiria manter na memória (e longe do swap em disco) mais dados.



O código do ramzswap (antigo compcache) ainda está em desenvolvimento, mas já foi incluído na árvore staging, e é altamente indicado para uso em netbooks e sistemas que equipam dispositivos embarcados.


Virtualização



Um recurso inovador introduzido na versão 2.6.32 do Linux foi o KSM (Kernel Samepage Merging), que desduplica páginas de memória. Na nova versão do kernel, essas páginas desduplicadas ganham a possibilidade de ser armazenadas em swap.



No momento, o KSM funciona somente em conjunto com o hypervisor KVM, que recebeu também algumas melhorias de desempenho, incluindo um melhor uso das funções de virtualização das CPUs modernas.



Na arena do VMware, o fabricante desenvolveu drivers para a GPU e o chip de rede Ethernet dessa solução de virtualização. Com isso, todo sistema Linux instalado dentro de uma máquina virtual VMware será capaz de oferecer o maior desempenho possível nas áreas gráfica e de rede.


Rede



A Intel dominou as novidades na área de drivers de rede no Linux 2.6.33. O driver iwlwifi ganhou suporte a diversos novos hardwares das séries 1000, 5000 e 6000, incluindo o recurso de WiMAX da série 6x50. Além disso, um novo driver sob o longo nome de iwmc3200top chega para oferecer suporte a um chip Intel multiuso (GPS, Bluetooth, Wi-fi e WiMAX). Mas nem tudo são flores: após alguns problemas com os recursos de economia de energia no driver iwl3945, estes foram temporariamente desativados.



O driver rt2800pci, desenvolvido pelo projeto rt2x00, também chegou para cobrir a área antes suprida pelo driver do fabricante (Ralink), que não vem cumprindo as exigências dos desenvolvedores do kernel.



Em uma camada mais alta, a extensão TCPCT (TCP Cookie Transactions) recém-incluída no Linux visa a proteger o TCP contra ataques de negação de serviço, como SYN floods. A velocidade da inclusão é consequência de sua necessidade no protocolo DNSSEC, pois, para ser usado, o TCPCT requer suporte tanto no cliente quanto no servidor.


Faxina na árvore staging



Após várias consultas sem resposta aos desenvolvedores do sistema Android, do Google, o pessoal do kernel Linux resolveu retirar da árvore staging os diversos drivers desse sistema.


Bola de cristal



O que podemos esperar para o Linux 2.6.34? Naturalmente, o avanço dos drivers gráficos com KMS dos principais fabricantes – Intel, AMD e Nvidia.



O sistema de arquivos Btrfs, cujo desenvolvimento pela Oracle deve continuar, mesmo após a aquisição da Sun (que traz junto o todo-poderoso ZFS), ainda não deve ser esperado, ao menos para uso em produção.



Para mais detalhes das novidades sobre o kernel Linux 2.6.33, confira algumas fontes de informação muito úteis:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Particionamento ideal no Ubuntu


Por Pablo Hess
Publicado em 03/03/2010

Este artigo foi visualizado 100259 vezes.

Versão para impressão Enviar por email




Este artigo será publicado também na Easy Linux 18.



Toda vez que sai uma nova versão da sua distribuição GNU/Linux preferida, é aquele trabalho todo: você confere o último backup, atualiza os documentos que estiverem desatualizados, instala o novo sistema e copia os arquivos de volta para um local onde eles possam ser usados — como a pasta Documentos/. O único aspecto positivo desse procedimento é forçar o usuário a fazer backups regulares; o resto, como você sabe, é trabalhoso e chato.



Felizmente, existem algumas técnicas bem sólidas para evitar todo esse trabalho. A mais prática é fazer o próprio sistema resolver o problema sozinho: basta criar mais uma partição no disco e informar ao sistema que os arquivos dos usuários encontram-se nela. Para isso, basta dedicarmos um pouco de atenção à instalação do sistema — que vai passar a precisar de um único passo a mais.



Com isso, ao instalar uma nova versão do seu sistema, você nem mesmo precisará refazer todas as configurações (papel de parede da área de trabalho, tema, ícones na área de trabalho, programas na barra do Gnome ou KDE...). E além disso, todos os seus documentos continuarão exatamente no mesmo local onde sempre estiveram. Então, mãos à obra!


Partições



A técnica descrita neste artigo já era usada bem antes da primeira distribuição GNU/Linux. Ela consiste em criar no disco rígido, no momento da instalação do sistema, uma partição específica para os documentos pessoais dos usuários.



Cada partição é um “pedaço” do disco rígido. Os sistemas GNU/Linux necessitam de pelo menos duas partições:



  • raiz, representada por uma barra, /: nela são armazenados todos os arquivos, tanto do sistema quanto dos usuários;

  • swap: também chamado de espaço de troca, é a memória virtual do sistema. Quando o sistema usa toda a memória RAM e ainda precisa de mais um pouco, ele pode mover dados da RAM para a partição swap, e assim manter vários programas abertos.




Um sistema Ubuntu típico, num disco rígido de 80 GB formatado automaticamente durante a instalação, pode ter seu disco rígido particionado da seguinte forma:


figura 01


Na partição maior (a partição raiz), ficam juntos os arquivos do sistema, bibliotecas de código, arquivos de configuração e todos os demais arquivos.



Dentro da partição maior (chamada de raiz, ou /), existem várias pastas, como /etc, /home, /usr, /var e /boot. Cada uma delas tem um propósito; o da /home é justamente armazenar os documentos e configurações pessoais de todos os usuários. Nosso objetivo é criar uma partição separada no disco e informar ao sistema para usar essa partição exclusivamente para a pasta /home. Simples, não?


figura 02


Temos agora três partições: raiz, /home e swap. O sistema fica na raiz, os documentos e configurações pessoais dos usuários ficam na /home e a memória virtual fica na swap.


Na prática



Vejamos agora um passo a passo para instalar o Ubuntu usando esse esquema de particionamento.



  1. Na sua próxima instalação do sistema, faça backup dos seus documentos como de costume.


  2. Comece a instalação do Ubuntu, seguindo os passos normais até chegar à etapa do particionamento do disco rígido.


    figura 04


    (Clique na imagem para ampliá-la numa nova aba/janela)



  3. Nesta etapa, selecione Especificar particionamento manual (avançado) e clique em Avançar.


    figura 05

    (Clique na imagem para ampliá-la numa nova aba/janela)



  4. A janela seguinte apresentará a formatação atual do disco rígido. Neste exemplo, temos uma partição sda1 de quase 30 GB com Windows, uma outra sda2 de 54,8 GB com o Ubuntu atualmente instalado e, por último, uma sda3 como área de swap.


    figura 06

    (Clique na imagem para ampliá-la numa nova aba/janela)



  5. Apague cada uma das partições usadas pelo Ubuntu e lembre-se de manter todas as partições de outros sistemas (como o Windows, caso esse sistema também esteja instalado no mesmo disco). Para isso, clique na partição a ser apagada e depois no botão Excluir.


    figura 07

    (Clique na imagem para ampliá-la numa nova aba/janela)



  6. Com o disco rígido “limpo”, vamos começar a criar as partições. Clique no texto que diz espaço livre e depois no botão //Adicionar.../.


    figura 08

    (Clique na imagem para ampliá-la numa nova aba/janela)



  7. A primeira partição que vamos criar é a raiz (/). Vamos usar 10 GB para essa partição, de forma a deixar os 45 GB restantes para as partições /home e swap. Então, na janela Criar partição, selecione os itens Primária, o tamanho de 10.000 MB (sem o ponto dos milhares), o início do espaço livre, o sistema de arquivos ext4 e, mais importante, o ponto de montagem / (não confundir com \). Ao final, clique no botão OK.


    figura 09

    (Clique na imagem para ampliá-la numa nova aba/janela)



  8. Em seguida, clique novamente no espaço livre e no botão Adicionar....


    figura 10

    (Clique na imagem para ampliá-la numa nova aba/janela)



  9. Na janela que se abre, vamos criar a partição de swap. Selecione Lógica para o tipo da nova partição e use 1000 para o tamanho da partição. Isso significa aproximadamente 1 GB de espaço de swap, que deve ser suficiente na maioria dos casos. Deixe marcado o início do espaço livre e, em Usar como:, selecione área de troca (swap). Depois, clique no botão OK.


    figura 11

    (Clique na imagem para ampliá-la numa nova aba/janela)



  10. A última partição a ser criada será a /home, que vai ocupar os 44 GB restantes no nosso disco de exemplo. Clique mais uma vez em espaço livre e em Adicionar....


    figura 12

    (Clique na imagem para ampliá-la numa nova aba/janela)



  11. Nesta janela, deixe marcada a opção Lógica para o tipo da partição, e deixe também o tamanho já indicado (44893, no nosso exemplo). Não altere a Localização para a nova partição. Em Usar como: selecione o sistema ext4 e, em Ponto de montagem: abra a lista e selecione /home, depois clique em OK.


    figura 13

    (Clique na imagem para ampliá-la numa nova aba/janela)






Ao final deste processo, a lista de partições do disco deve ser semelhante a:



figura 14

(Clique na imagem para ampliá-la numa nova aba/janela)



Como mostra a barra no alto dessa janela, isso significa que temos, agora, uma partição do Windows, uma partição ext4 para a raiz do sistema Linux, uma partição de swap e, por último, uma partição ext4 que comporta a pasta /home.



figura 03



Está feito.


Daqui para a frente...



Daqui para a frente, basta prosseguir com a instalação do seu sistema Ubuntu, clicando em Avançar e preenchendo as informações que forem pedidas, como de costume.



Agora, todos os seus arquivos pessoais vão residir na partição /home, enquanto os arquivos do sistema residirão na partição / (raiz).


Reinstalação futura



Quando for lançada a próxima versão da sua distribuição, a tarefa de reinstalação vai requerer passos semelhantes, assim como nas instalações posteriores. Então, guarde estas instruções num lugar seguro, pois você vai precisar delas novamente:



  1. Comece a reinstalação da forma tradicional e proceda até a etapa da formatação.


    figura 15

    (Clique na imagem para ampliá-la numa nova aba/janela)



  2. Selecione Especificar particionamento manual (avançado) e clique em Avançar. Essa etapa é o único aumento de complexidade necessário para o benefício do /home separado.


  3. Na etapa seguinte, basta informar ao sistema a forma correta de usar as partições que já existem no disco rígido. Comece pela partição raiz. Note que você sabe qual é ela (a segunda de cima para baixo, no nosso exemplo). Porém, o instalador do sistema ainda não sabe disso.


    figura 16

    (Clique na imagem para ampliá-la numa nova aba/janela)



  4. Clique na partição que estamos usando como raiz (a de 10 GB, no nosso exemplo) e depois em Alterar....


    figura 17

    (Clique na imagem para ampliá-la numa nova aba/janela)



  5. Na janela que se abre, jamais altere o tamanho da partição. No item Usar como:, selecione ext4, marque o item Formatar a partição (afinal, vamos instalar uma nova versão do sistema) e selecione como Ponto de montagem a barra (/). Por último, clique em OK.


    figura 18

    (Clique na imagem para ampliá-la numa nova aba/janela)



  6. Em seguida, selecione a partição que você usa como /home (a última da lista, no nosso exemplo)e clique em Alterar....


    figura 19

    (Clique na imagem para ampliá-la numa nova aba/janela)



  7. Na janela que se abre, novamente não altere o tamanho, e deixe o item Formatar a partição desmarcado. Defina Usar como: com ext4 (caso contrário, os dados da sua partição /home serão perdidos!) e selecione /home no item Ponto de montagem:. Ao final, clique em OK.


    figura 19

    (Clique na imagem para ampliá-la numa nova aba/janela)






Se você está se perguntando o que acontece com a partição swap, não se preocupe. O sistema sabe que swap é sempre swap, então se encarrega de usar aquele espaço da forma adequada.



Com essas configurações feitas, basta clicar em Avançar e continuar a instalação. O sistema vai encontrar em /home os mesmos arquivos que você havia deixado na última versão do sistema.



figura 21

(Clique na imagem para ampliá-la numa nova aba/janela)




Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Controle de usuários com GNU Accounting Utilities


Por Marlon Luis Petry
Publicado em 29/01/2010

Este artigo foi visualizado 10696 vezes.

Versão para impressão Enviar por email




Autor: Marlon Luis Petry



Para gerenciar servidores Linux com mais qualidade e segurança, é necessário saber tudo que acontece e como acontece. Para nos ajudar nessa tarefa, podemos usar as GNU Accounting Utilities, mais conhecidas por acct. Trata-se de um excelente pacote de ferramentas, que fornece desde logs dos comandos executados até estatísticas sobre as contas de usuário.



Então, vamos tornar as coisas mais interessantes fazendo esse bichinho funcionar.


Instalação no Gentoo



# emerge -av acct


Configuração no kernel



O kernel deve ser instruído por meio da opção BSD_PROCESS_ACCT, a criar uma system call (chamada do sistema), que o acct irá utilizar para registrar eventos relacionados aos usuários. A lista de eventos pode ser consultada no arquivo /usr/src/linux/include/linux/acct.h. Resumidamente, os eventos são: processo, usuário, tempo de processamento, taxa de utilização de memória e CPU.


Seu kernel oferece suporte?



Verifique se o kernel que você está usando oferece suporte aos recursos necessários:



#zcat /proc/config.gz |grep -e BSD_PROCESS_ACCT
CONFIG_BSD_PROCESS_ACCT=y
CONFIG_BSD_PROCESS_ACCT_V3=y



Outra forma de verificar o suporte por parte do kernel: ao executar o acct, você receberá a seguinte mensagem de erro, caso não haja suporte:



accton: Function not implemented


Início



#/etc/init.d/acct start



Para iniciar automaticamente no boot.



#rc-update add acct default


Saboreando os resultados



Depois de instalado e configurado, vamos descobrir o que realmente esse pacote nos oferece.



Comando ac: fornece estatísticas sobre tempo de conexão dos usuários no sistema, com base em login/logout definidos no log wtmp. A unidade de retorno é em horas. Para saber mais sobre o processo de login, acesse //O que acontece quando logamos no linux//.



Dentre os parâmetros do comando ac, existem dois que mais se destacam:



  • -d: total por dia

  • -p: total por usuário




Comando last: este comando mostra os logins e logouts no sistema. Usado sem parâmetros, ele varre o arquivo wtmp e mostra os resultados desde que o arquivo foi criado; porém, com os parâmetros fica mais interessante: por exemplo, para saber quando o usuário root fez login remotamente:



#last root -d



Isso mostrará todos os últimos logins do root, o IP de origem e o horário.



Comando lastcomm: mostra os últimos comandos executados, informando o dono do processo, o tempo de execução e a data. Esse comando é baseado nos logs gerados pelo acct; por padrão, o comando busca o arquivo /var/log/account/pacct.



Comando sa: cria um relatório condensado dos últimos comandos utilizados, contendo o número de vezes que o comando foi executado e quanto de recursos ele utilizou.


Conclusão



As GNU Accounting Utilities são uma excelente ferramenta que auxilia na administração de servidores Linux, tirando do limbo muita informação. Cruzando os dados de logins com os comandos executados, podemos saber quando os usuários utilizam o sistema, quais comandos executam e até mesmo em que momento o sistema fica mais sobrecarregado e qual o motivo da sobrecarga. Com todas essas informações, obtemos subsídios para tomadas de decisões mais céleres para o gerenciamento dos servidores.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

“Liberdade não é liberdade de escolha” – assim falou Richard Stallman


Por Pablo Hess
Publicado em 18/06/2009

Este artigo foi visualizado 10670 vezes.

Versão para impressão Enviar por email



Em sua atual passagem pelo Brasil, Richard Stallman concedeu à Linux Magazine uma agradável entrevista. Foi uma rara oportunidade de conversar cara a cara com o nem sempre palatável mestre maior do Software Livre, criador da GNU GPL e do conceito de Copyleft, autor do emacs e detentor de tantas outras qualificações, conhecido pelas respostas incisivas e correções a entrevistadores que escorregam na diferenciação dos termos “Free Software” e “Open Source” ou que se esquecem de prefixar o termo “GNU” ao se referirem ao sistema operacional GNU/Linux.


Stallman falou à Linux Magazine sobre SCO, Sun, Oracle, a liberdade de software e o conflito com aqueles que desejam subverter o significado de “Free Software” (Software Livre), usando em seu lugar o termo “Open Source” (Código Aberto) – além de críticas à Microsoft e ao software proprietário como um todo, é claro.


Linux Magazine» Tivemos no Brasil recentemente o programa “PC Para Todos”, que vendeu aproximadamente 3 milhões de computadores equipados com Software Livre, mas que também continham softwares não livres na forma de drivers binários no kernel Linux. Boa parte desses computadores receberam cópias não autorizadas de sistemas Windows. Você não acha justificável esse uso de softwares não livres, pois ajuda na transição de um mundo primordialmente proprietário para o objetivo completamente livre que você propõe?


Richard M. Stallman» Uma ideia seria vender computadores que não fossem compatíveis com o Windows.


LM» Mas isso restringiria a liberdade de escolha dos compradores.


RMS» Liberdade não é liberdade de escolha. Ter a opção de se acorrentar reduz sua liberdade. É simples: engana-se quem identifica liberdade como liberdade de escolha, porque a liberdade de se permitir acorrentar não aumenta a sua liberdade – provavelmente a diminui.


Este argumento está sobre uma superfície que não existe. Veja bem, se o hardware tivesse sido escolhido com cuidado, não haveria necessidade desses drivers proprietários. Eles poderiam ter dito: “Queremos um computador que funcione perfeitamente com Software Livre. Quem quer construí-lo para nós?”. Com essa quantidade (3 milhões), eles teriam uma ótima oportunidade de resolver esse problema, caso tivessem se esforçado. Poderiam até ter dito: “Queremos comprar esses computadores (3 milhões) de quem também for vendê-los para o público em geral”. Quem quer vendê-los?


LM» Agora que a SCO parou de espernear, quem você considera o maior inimigo da liberdade? Quem mais faz propaganda ativa contra o Software Livre e pró-software proprietário?


RMS» Eu nunca achei que a SCO representasse grande perigo. Com essa definição de inimigo, creio que seja a Microsoft. Mas isso não significa que o nosso maior problema seja a Microsoft. O maior problema são as patentes de software, e elas não estão ligadas a nenhuma empresa em particular. Existem muitas empresas que nos apóiam de várias formas, mas são favoráveis às patentes de software. A IBM, por exemplo, tem ações que nos ajudam e outras que nos prejudicam. Ela quer que as patentes continuem existindo e faz lobby a favor delas.


LM» Mas a IBM faz parte da “Open Invention Network”, cuida para que o Software Livre não seja atacado por detentores de patentes. Ela compra patentes para usá-las em defesa do Software Livre.


RMS» Sim, mas sua eficácia é limitada. As patentes não permitem defender-se dos “patent trolls”. Ninguém está invulnerável aos “patent trolls”, porque eles próprios não fazem nada.


LM» A única defesa contra ataques de patentes é o contra-ataque, então?


RMS» Sim. Quando uma empresa é atacada por violação de patentes, o máximo que ela pode fazer é provar que não infringe essas patentes.


LM» E se ela não conseguir provar que não infringiu as patentes...


RMS» Só lhe resta contra-atacar. Mas isso não funciona contra os trolls, porque eles são como fantasmas: não há um alvo a mirar.


No caso do processo contra a Tomtom, a OIN não conseguiu ajudar muito.


Os desenvolvedores de software precisam ter simplesmente a possibilidade de escrever código e compartilhá-lo – ou seja, o fim das patentes.


LM» O que você acha do sistema da Red Hat para comercialização de Software Livre? Ela distribui gratuitamente apenas o código-fonte de todos os pacotes que compõem sua distribuição GNU/Linux – é isso que possibilita a existência de distribuições como CentOS, por exemplo. Existe alguma outra grande empresa atualmente que unicamente com Software Livre e mantenha esse comportamento de acordo com a GPL?


RMS» Eu não acompanho esse assunto. Mas não existe qualquer obrigação ética em distribuir programas GPL em sua forma binária. Esse modelo parece bom. Mas não conheço nada sobre a distribuição GNU/Linux comercial da Red Hat, apenas sobre o Fedora, e sei que ele chega perto de ser completamente livre – exceto pelos blobs binários no kernel Linux que eles distribuem.


Não posso concordar com uma distribuição GNU/Linux com blobs binários.


LM» O Samba é um projeto 100% GPLv3 atualmente. Isso significa que a Novell não pode distribuir esse código por causa do acordo com a Microsoft?


RMS» Acho que é GPLv3 ou posterior. Essa distinção é importante.


Essa é uma pergunta complicada, e eu não sei a resposta. Ouvi falar que, do jeito como a GPLv3 foi criada, se a Novell distribuir o Samba, a Microsoft acabaria tendo que dar uma patente para todas as pessoas.


Para saber com certeza, é preciso conhecer detalhes complexos do acordo MS-Novell. Porém, se a Novell começasse a distribuir um software GPLv3 antes do acordo, a Microsoft seria obrigada a ceder uma patente de software. Mas eu não sei o que aconteceu no final das contas.


LM» Qual a relação da FSF com o Software Freedom Law Center?


RMS» A FSF não costuma precisar de um advogado para aplicar a GPL. Só recentemente precisamos disso pela primeira vez.


Acho que não precisamos conversar toda semana, mas apenas quando precisamos de um advogado. Mas sei que os pequenos detalhes da GPLv3 que a “fazem funcionar” são obra de Eben Moglen [responsável pelo SFLC]. Ele descobriu alguns aspectos do acordo MS-Novell e teve ideias de como voltá-lo contra as duas empresas. É por isso que a GPLv3 não diz simplesmente “a Novell não pode distribuir [o Samba]”.


O objetivo dessas artimanhas não era prejudicar a Microsoft, mas impedi-la de nos prejudicar caso a Novell distribuísse qualquer um desses softwares.


A entrevista será publicada na íntegra na Linux Magazine 57.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Análise do novo Ubuntu 9.04


Por Rafael Peregrino da Silva
Publicado em 27/04/2009

Este artigo foi visualizado 15199 vezes.

Versão para impressão Enviar por email



Por Kristian Kißling e Rafael Peregrino da Silva



Pontualmente na data de lançamento programada — que acontece em um ciclo de seis meses — foi lançada a nova versão do Ubuntu, a 9.04, codinome Jaunty Jackalope. Devagar — mas sempre —, a distribuição patrocinada pela Canonical avança em usabilidade, desempenho e beleza. Este artigo traz uma análise do novo Ubuntu, apresentando as maiores novidades da versão 9.04.



O novo animal da família Ubuntu — todas as versões recebem um codinome contendo um nome de animal, precedido por um adjetivo de mesma inicial: Warty Warthog, Hoary Hedgehog, Breezy Badger, Dapper Drake, Edgy Eft, Fausty Fawn, Gutsy Gibbon, Hardy Heron, Intrepid Ibex e a atual, Jaunty Jackalope — conta com uma série de inovações visíveis e muitas invisíveis. A primeira delas é o “polimento” que a interface gráfica recebeu, apesar de ter mantido a mesma linha de sempre. Esse cuidado com a interface segue a estratégia lançada pelo próprio Mark Shuttleworth em 2008, por ocasião da OSCON de elevar o design da interface gráfica ao patamar de uma obra de arte, ultrapassando o visual e a usabilidade do Mac OS X, da Apple. Sem dúvida, trata-se de uma meta ousada, ainda que muito válida e necessária, que começa a gerar os primeiros frutos, como se pode ver a partir da tela de inicialização do sistema (bootsplash) e da tela de login, que, na versão tradicional, leva a um desktop GNOME após o fornecimento do nome do usuário e da senha.












Nos próximos dois anos a interface gráfica do Ubuntu deverá ser elevada ao patamar de “obra de arte”, conforme declarações de Mark Shuttleworth de julho de 2008. A tela de login do GDM indicada acima mostra os primeiros sinais dessa estratégia.




Instalação


Banner Pockets Ubuntu

A instalação da nova versão não poderia ser mais simples: após baixar o CD do Ubuntu, inicializamos o computador por meio dele, como de costume. O ambiente de trabalho que aparece é totalmente funcional e permite que testemos o sistema sem tocar no disco rígido do computador. Para instalar, basta clicar no ícone “Instalar o sistema no computador” para, caso aceitemos todas as sugestões do instalador, em seis passos e em menos de meia hora, termos o “cornoelho garboso” (significado literal de Jaunty Jackalope, em uma tradução livre) “saltitando” na nossa frente, sem a necessidade do CD. É interessante notar que o instalador indicará sete passos para realizar a instalação, mas caso não modifiquemos nenhuma de suas sugestões e utilizemos o disco todo do computador, o sexto passo será pulado. As informações solicitadas pelo instalador são, basicamente, de idioma, localidade, layout de teclado, espaço em disco a ser utilizado, dados do usuário e nome escolhido para o computador (estas duas últimas informações em uma mesma tela).



Novidades visíveis



Em seu blog, Mark Shuttleworth chama a atenção em especial para a integração do novo sistema de notificações do ambiente de trabalho. Modificações de volume, a chegada de um email novo, a conexão à rede (ou a quebra desta), atualizações de software: tudo isso é notificado pelo sistema em uma área retangular no canto superior direito da tela (abaixo do símbolo do controle de volume), de modo muito mais ostensivo que em versões anteriores do sistema.












A nova área de notificações no ambiente de trabalho do Ubuntu 9.04 é uma das novidades que mais chama a atenção na nova versão do sistema operacional. Todos os eventos relevantes para o usuário são notificados ali.




Infelizmente, com a chegada da nova área de notificações, o ícone que indicava a presença de atualizações desapareceu. Agora o gerenciador de atualizações é acionado automaticamente se houver atualizações não instaladas no sistema por mais de uma semana. Atualizações de segurança são informadas na nova área de notificações a cada 24 horas — infelizmente apenas uma vez a cada atualização desse tipo. Para quem não estiver satisfeito com isso, o comando seguinte restabelece o comportamento tradicional:



gconftool -s --type bool /apps/update-notifier/auto_launch false


O controle de volume no painel superior, que se ativa com um clique do mouse, passou a ter orientação horizontal. Além disso, as fontes do sistema estão mais bem ajustadas às diversas configurações de monitor, o que produz uma experiência de uso mais agradável do desktop. Caso as fontes apareçam em tamanho exagerado ou ilegível, significa que o monitor está informando suas próprias dimensões erroneamente ao sistema. Informações sobre como corrigir esse tipo de problema — mais comum no KDE que no GNOME — podem ser encontradas no wiki do projeto Ubuntu. O novo fundo de tela do ambiente de trabalho, mais simples e discreto, ficou mais agradável e bonito que o da versão anterior, mas ainda falta um pouco para chegarmos no nível do Mac OS X, como o próprio Mark Shuttleworth declarou em seu blogmas isso deve ocorrer até o final de 2010.












Ambiente de trabalho padrão do Ubuntu 9.04.




Alguns usuários reclamaram que certos recursos que funcionavam com a versão 8.10 do Ubuntu deixaram de funcionar com a atualização para a versão 9.04. Entre eles estariam, por exemplo, placas de redes sem fio modelo Broadcom 4318 e algumas placas de vídeo ATI (veja mais a seguir a respeito de possíveis problemas de vídeo). Em nossos testes, realizados num notebook cujo hardware era inteiramente da Intel, não houve qualquer tipo de problema.



Novidades invisíveis, mas sensíveis



Quem vê cara não vê coração, diz o ditado popular. No caso da nova versão do Ubuntu, é importante dizer que não foi só na “cara” que houve avanços: a maioria deles ocorreu “debaixo do capô”. No que tange a isso, vale dar uma olhada em primeiro lugar na versão do kernel usada no sistema, e que consiste não somente dos gerenciadores de dispositivos de hardware, mas do motor de todo o sistema, gerenciando memória e acesso a recursos e periféricos. É comum falarmos de Linux nos referindo realmente à distribuição GNU/Linux utilizada, quando na verdade o Linux é somente o núcleo (daí a definição de kernel) da distribuição, o sistema operacional propriamente dito, peça central de um todo muito maior, e que tem em Linus Torvalds um gerente de desenvolvimento cuidadoso, orquestrando o trabalho de centenas de contribuidores regulares.



Os desenvolvedores de distribuições GNU/Linux integram os aplicativos e o kernel, formando um pacote mais completo, que contém, como no caso do Ubuntu, que é derivado do Debian, mais de 25.000 programas prontos para instalar e usar, muitos dos quais disponíveis também para outras plataformas operacionais, como o Windows® e o Mac OS X. Assim, o sucesso do Ubuntu vem especialmente de uma integração inteligente do Debian, associada a uma pré-configuração muito bem feita e dotada de um repositório de aplicativos gigante, de um visual caprichado, de um instalador simples de usar, bem como de uma série de automatismos estratégicos e de algumas ferramentas de configuração de interface simples de entender e usar.



No caso do kernel, a equipe de desenvolvimento do Ubuntu foi conservadora e preferiu ficar com a versão 2.6.28, já que a adoção da versão 2.6.29 seria um tanto quanto ousada, dada a proximidade do seu lançamento com a data determinada para a liberação da versão que ora analisamos. No entanto, o kernel utilizado no Jaunty Jackalope não é o 2.6.28 originalmente disponibilizado por Linus Torvalds (o assim chamado Vanilla Kernel): há nele uma série de modificações, oriundas das necessidades de integração do Ubuntu. Mesmo assim, caso o usuário sinta falta de algum driver importante, indispensável para o funcionamento de alguma peça de hardware “exótica”, é possível instalar uma versão mais atual do kernel por meio de um repositório externo. Mas atenção: o uso de uma versão mais nova do kernel embute uma componente de risco considerável, de modo que não se deve descuidar de ferramentas de becape nesse caso (o que já é de boa conta, de qualquer modo).



O kernel 2.6.28 por si só já traz algumas novidades interessantes na bagagem, entre elas o suporte ao sistema de arquivos Ext4, que deve substituir o atual Ext3 a curto prazo. O Ext4 já aparece, inclusive, disponível como opção de sistema de arquivos durante o particionamento dos dispositivos de armazenamento durante a instalação do novo Ubuntu, entretanto não como padrão, como o projeto pretendia anteriormente. Isso porque, durante a fase de testes dessa versão do Ubuntu, houve uma série de discussões sobre a questão conceitual de qual é a hora certa para o sistema de arquivos armazenar efetivamente os dados em cache no disco rígido. Isso aconteceu, na prática, porque dependendo da configuração desse parâmetro poderia haver — como chegou efetivamente a ocorrer em alguns casos — perda de dados. Trata-se de uma questão envolvendo duas variáveis que raramente andam lado a lado: desempenho e segurança. Nesse ínterim, entretanto, os desenvolvedores do Ubuntu já integraram uma modificação no kernel da distribuição, que configura o Ext4 no modo seguro. No kernel original, essa modificação só estará disponível a partir da versão 2.6.30.



Entre as principais vantagens do Ext4 estão o desempenho, a quantidade de arquivos com os quais o sistema de arquivos pode lidar, além, claro, da retrocompatibilidade com o Ext3 e até com o Ext2. Ademais, um arquivo no Ext4 pode ocupar todo o espaço do sistema de arquivos, partições e volume podem crescer até 1 EB — o que corresponde a um milhão de TB!



Quem tiver instalado o Ubuntu 9.04 com o Ext3 como sistema de arquivos e quiser migrar para o Ext4, deve excepcionalmente reinstalar o gerenciador de inicialização (GRUB) usando o comando grub-install, para que ele reconheça o novo sistema de arquivos corretamente. Nunca é demais relembrar que versões do kernel anteriores à 2.6.28 serão incapazes de lidar com partições formatadas como Ext4.



Os drivers de áudio integrados ao novo kernel lidam com jack sensing, ou seja, reconhecem automaticamente quando microfones, fones de ouvido ou caixas de som são conectados ao sistema. Houve também melhorias sensíveis no modo como o Linux trabalha com DVB, webcams e diversos outros tipos de periféricos.



Algumas das modificações contidas no kernel 2.6.28, lançado no final de dezembro de 2008, passarão totalmente despercebidas pelo usuário do Ubuntu 9.04. Como exemplo, podemos citar um novo gerenciador de memória desenvolvido pela Intel, que deverá servir de base para uma arquitetura renovada para acesso aos recursos de vídeo do sistema. Um recurso para aceleração do procedimento de inicialização do sistema (fastboot patch), usada pelo desenvolvedor Arjan van de Ven para reduzir o tempo de boot de uma outra distribuição GNU/Linux para apenas cinco segundos, também está disponível no kernel do Ubuntu — em virtude de problemas de estabilidade e compatibilidade, por enquanto esse recurso vem desativado por padrão.



O “X” da questão



Como de costume, o sistema X Window do consórcio X.org permanece como fundamento para a produção da interface gráfica do Linux, o que não é diferente no caso do Ubuntu. O sistema permite que um cliente X acesse um servidor X, seja localmente ou pela rede, que então “desenha” as janelas e seus movimentos na tela, processa os movimentos do mouse e a digitação no teclado do cliente X e carrega os drivers corretos para manipulação da placa de vídeo. Algumas das configurações desse sistema são realizadas por meio do arquivo /etc/X11/xorg.conf.



O novo servidor X, na versão 1.6, utilizado pelo Ubuntu 9.04, resolve alguns problemas da versão anterior (a 1.5) e traz consigo a versão 1.3 do aplicativo XRandr, responsável pelo ajuste automático e dinâmico da resolução da tela. Além disso, a versão 1.6 do X.org faz uso de DRI (Direct Rendering Infrastructure), o que permite a aplicativos o acesso direto ao hardware de vídeo, o que acelera a representação de conteúdo em três dimensões. Graças à integração do recurso de Predictable Pointer Acceleration, a nova versão do Ubuntu é também capaz de representar o ponteiro do mouse com mais precisão.



Como já citamos acima, a nova versão do servidor X pode gerar alguns transtornos também. Caso o usuário deseje usar jogos que usem intensamente recursos 3D ou ativem os já populares efeitos visuais avançados no ambiente de trabalho (tais como janelas balançantes ou transparentes, entre outros), é necessário ativar a aceleração 3D, cujos recursos são normalmente fornecidos pelos drivers (geralmente proprietários e fechados) das respectivas placas de vídeo. Para a versão 1.6 do X.org, tanto a AMD/ATI quanto a NVIDIA, os dois maiores fabricantes de placas de vídeo, tiveram de realizar ajustes em seus drivers para Linux (fglrx e nvidia), o que ainda não está totalmente finalizado. Por um lado, no caso de placas de vídeo mais modernas, ainda há uma série de problemas de visualização, e placas mais antigas, que funcionavam bem até então com versões mais antigas do X.org, só estão funcionando corretamente com os drivers de vídeo de código aberto, que não dispõem de suporte — ou dispõem apenas de suporte limitado — aos recursos 3D das placas de vídeo. Usuários de placas de vídeo Intel, por outro lado, não devem encontrar grandes problemas: apesar de os recursos de hardware serem muito menos poderosos para essas placas, o fato de elas serem de código aberto e gozarem de suporte integral da Intel, faz com que eles funcionem perfeitamente no novo Ubuntu.



Usuários tradicionais do Ubuntu deverão notar especialmente a opção Don't zap. Se antigamente era possível abandonar o ambiente de trabalho usando o atalho de teclado [Ctrl]+[Alt]+[Backspace], para voltar à tela do gerenciador de login e, daí, ao GNOME, a nova versão do X.org acabou com essa possibilidade. Alguns usuários provavelmente não vão gostar dessa limitação. É claro que o kernel Linux pode assumir essa tarefa, por meio do atalho [Alt]+[PrtScr]+[K], que reinicia computadores travados quase que sem exceção — o problema é lembrar desse tipo de atalho.



Para reativar o atalho anterior, precisamos editar o arquivo de configuração /etc/X11/xorg.conf, incluindo no final dele as seguintes linhas:




Section "ServerFlags"
Option "DontZap" "False"
EndSection


Após reiniciar o sistema, o atalho [Ctrl]+[Alt]+[Backspace] deverá voltar a funcionar como de costume.



Inicialização e áudio



A redução sensível no tempo de inicialização do Ubuntu 9.04 não se deve a nenhum programa novo, introduzido com esse propósito no sistema. O que houve foi realmente trabalho duro de desenvolvimento: os programadores do Ubuntu analisaram quem eram os “atrasadores” e “atravancadores” do processo de inicialização do sistema, usando-se para isso do Bootchart, removendo as fontes de atraso tanto quanto possível. Em especial a fase de reconhecimento automático do hardware consome tradicionalmente bastante tempo, comportamento que foi acelerado com o uso de paralelização do udev.



Além disso, o RAM drive de inicialização do Ubuntu 9.04 é 4 MB menor que o da versão 8.10, e contém um número menor de módulos e um aplicativo realmente muito menor para exibição da tela de inicialização (bootsplash), o que contribui decisivamente para uma grande economia de tempo.



Em nossos testes, o tempo de inicialização (até a tela de login) de um sistema Ubuntu 9.04 padrão foi reduzido em mais de 30%, em comparação com uma versão 8.10, instalada no mesmo hardware (um notebook dotado de um processador Intel® Pentium® Dual-Core, modelo T2310, 1,46 GHz, 1 GB de RAM e disco rígido SATA Western Digital Scorpio, modelo WD1200BEVS-0 de 120 GB e 5400 RPM). A inicialização do ambiente de trabalho após o login e o desligamento da máquina foram muito mais rápidos na nova versão da distribuição.



A tabela a seguir lista os tempos de inicialização e desligamento do sistema:


























Ubuntu 9.04 e 8.10: Comparativo de tempo de inicialização e desligamento no mesmo hardware
Versão do Ubuntu
Tempo consumido até a tela de login
Tempo consumido até o desligamento
Ubuntu 8.10 33 s 10 s
Ubuntu 9.04 23 s 7 s




O PulseAudio, novo servidor de som do Ubuntu Linux, permite que se confira um nível de volume diferente para cada um dos aplicativos em operação. No entanto, o sistema ainda não goza de uma boa reputação, no que tange à estabilidade. Ademais, é necessário instalar o pacote gnome-volume-control-pulse usando o APT ou o Synaptic. Após a reinicialização do sistema, vão haver dois ícones de controle de volume no painel padrão do GNOME, à direita, um deles com um controle horizontal e o outro (o recém-instalado) com um controle vertical. Para evitar confusão, é melhor remover o de controle horizontal (adeus melhoria de interface...). O pior é que a duplicação também ocorre no menu Sistema | Preferências, que ganha dois itens de mesmo nome (Som). Clicando-se com o botão direito do mouse sobre o ícone que restou, basta escolher o item “Preferência de som” no menu de contexto que aparecer, para abrir a janela de configuração do PulseAudio. Na aba “Aplicativos” é possível alterar isoladamente o volume dos aplicativos que estiverem em operação, conforme mostra a figura a seguir:












Graças ao PulseAudio, é possível ajustar o volume de cada aplicativo separadamente. Entretanto, o software ainda não goza de uma boa reputação no que tange ao quesito estabilidade.




Originalmente também estava planejado permitir aos usuários a criação de diretórios ou pastas criptografadas. Essa possibilidade já era, inclusive, contemplada em versões iniciais do Ubuntu 9.04, mas não em sua versão final, em razão de um sem-número de questões e problemas envolvendo esse recurso, que acabou por ser transferido para o plano de desenvolvimento da próxima versão da distribuição.



Aplicativos



Mesmo que as maiores novidades do sistema estejam onde o usuário não pode ver, as novas versões dos aplicativos da distribuição representam no fim das contas aquilo que é perceptível como “evolução” para todos. No caso do Ubuntu 9.04, muitos dos novos programas são diretamente ligados ao GNOME: a distribuição traz o ambiente de trabalho na versão 2.26, na qual existem algumas modificações em relação a versões anteriores. Entre elas está a adoção do Brasero como aplicativo oficial para gravar CDs e DVDs do Ubuntu — o aplicativo normatiza o nível de volume das trilhas de áudio de um CD antes de gravar, oferece suporte a gravação em modo multissessão e a verificação de integridade de dados. Até então, o projeto GNOME suportava oficialmente apenas uma extensão para o Nautilus para finalidades de gravação de CD/DVD, o que não se compara com a “concorrência” do K3b, do projeto KDE, atualmente considerado o principal aplicativo para gravação de CD/DVD do Linux.



Como aplicativos padrão do ambiente de trabalho do Ubuntu podemos contar o conjunto de programas para escritório OpenOffice.org, no Ubuntu 9.04 disponível na versão 3.0.1. O OpenOffice.org 3 foi lançado há um tempo razoável, muito tarde, entretanto, para ser admitido na versão 8.10 do Ubuntu. Essa versão é capaz de importar arquivos em formato PDF, que podem ser editados, ainda que de forma limitada. Os desenvolvedores do OpenOffice.org dão muita ênfase à possibilidade de aumentar os recursos da nova versão do software por meio de extensões, semelhantes aos add-ons do navegador Firefox, que podem ser baixados e “agregados” ao OpenOffice.org, enriquecendo o programa com novos recursos. Graças ao suporte melhorado ao formato OOXML — o formato XML criado pela Microsoft para os arquivos do Microsoft Office —, ficou simples importar esse tipo de documento no OpenOffice.org, que ainda “engripa” durante a importação de documentos muito complexos armazenados nesse formato.



A nova versão do Ubuntu lida melhor com monitores adicionais. Isso deve alegrar os usuários que precisam trabalhar com mais de um monitor, o que se tornou um padrão em parques de editoração gráfica — e onde o Mac OS X ainda reina, absoluto.



Uma novidade é o “Mantenedor do Sistema”, uma aplicativo que tem por função descartar arquivos e pacotes que não estejam mais sendo utilizados pelo sistema. Isso faz sentido, já que, via de regra, quando se instala um pacote com diversas dependências, se esse pacote for desinstalado posteriormente, as dependências permanecem instaladas no sistema desnecessariamente. O Mantenedor do Sistema registra esse “lixo” e o descarta. Aviso aos navegantes: durante o desenvolvimento do Jaunty Jackalope, foram vários os casos em que o Mantenedor do Sistema descartou aplicativos que o usuário havia instalado “à mão”, de modo que o uso do mantenedor deve ser feito com moderação.












O “Mantenedor do Sistema” tem por função encontrar e descartar aplicativos e bibliotecas que não são mais necessários no sistema, mas ainda peca pelo excesso de vez em quando.




O Ekiga 3.0 é o aplicativo de (vídeo)telefonia via Internet instalado por padrão no Jaunty, que não é compatível com o Skype, mas usa o protocolo SIP, padrão de-facto para telefonia IP. Assim, se o leitor usar por exemplo um provedor VoIP como o VONO, da GVT, que faz uso extensivo de tecnologia Asterisk, o Ekiga vai servir muito bem. O aplicativo também é muito bom caso se deseje falar com outros usuários de Linux. Sua interface foi refeita do zero e a qualidade de transmissão de vídeo, melhorada. Ao ser chamado, o programa procura automaticamente por portas abertas na rede que possam ser utilizadas para a comunicação IP. Caso isso não seja possível, ele sugere a configuração manual de port forwarding. Uma conta SIP pode ser facilmente criada durante a configuração inicial do software de telefonia IP.



Para uma comunicação via mensagem instantânea, o usuário pode usar o Pidgin. Com ele é possível trocar mensagens instantaneamente com usuários em qualquer tipo de rede: AIM, Google Talk, ICQ, MSN, IRC, Yahoo... a lista é quase interminável. Entretanto, o Pidgin pode não oferecer suporte para a comunicação via vídeo de alguns desse protocolos, de modo que a comunicação em geral se resume apenas a mensagens de texto.



A tabela a seguir lista alguns dos principais aplicativos instalados por padrão no sistema, bem como suas respectivas versões:






















































































Ubuntu 9.04 — Jaunty Jackalope: principais aplicativos e suas versões
Aplicativo
Versão
Função
Kernel 2.6.28 É o Linux propriamente dito
X.org 7.4 Gerenciador de janelas
GNOME 2.26 Ambiente de trabalho
OpenOffice.org 3.0.1 Conjunto de aplicativos para escritório
Firefox 3.0.9 Navegador de Internet
Pidgin 2.5.5 Aplicativo para troca instantânea de mensagens
Evolution 2.26.1 Correio eletrônico, gerenciador de tarefas, calendário e gerenciador de contatos
Gimp 2.6.6 Editor de imagens
F-Spot 0.5.0.3 Gerenciador de fotos
Rhythmbox 0.12.0 Reprodutor e gerenciador de músicas
Totem 2.26.1 Reprodutor de filmes
Ekiga 3.2.0 Cliente VoIP
Trasmission 1.51 Cliente de rede P2P BitTorrent
Brasero 2.26.0 Aplicativo de gravação de CD/DVD




Instalação de aplicativos



No que se refere à instalação de aplicativos, há uma série de avanços na versão 9.04 do Ubuntu. Em primeiro lugar, a instalação de plug-ins para o Firefox ficou mais inteligente: como na versão 8.10, a instalação do plug-in para conteúdos em Flash não baixou simplesmente as bibliotecas necessárias do site da Adobe. O sistema foi inteligente o suficiente para encontrar o pacote no repositório da distribuição e para instalá-lo simplesmente via gerenciador de pacotes. Ponto para a Canonical e para a comunidade Ubuntu, por resolver isso de maneira inteligente. Desta forma, se o sistema for utilizado por muitos usuários, essa instalação ocorrerá apenas uma vez, ao contrário do que acontecia em versões anteriores, nas quais cada usuário acabaria por instalar uma versão diferente do flash-player em sua própria pasta pessoal. Haja redundância e problemas de segurança para resolver... De qualquer modo, acreditamos que a Canonical já tenha ganhado importância e massa crítica o suficiente para firmar uma parceria com a Adobe e fornecer esse e outros aplicativos da empresa pré-instalados por padrão.



Também nos surpreendeu o fato de que, ao tentarmos assistir a um dos trailers dos filmes disponíveis no site da Apple, que o plug-in do Totem tenha reconhecido a inexistência de um decodificador de vídeo adequado para a reprodução de vídeos no formato QuickTime. E, para melhorar, o sistema não parou por aí: efetuou na sequência uma chamada ao aplicativo gdebi, forneceu o nome dos pacotes que precisavam ser instalados e, após o usuário escolhê-los, efetuou a instalação de modo totalmente descomplicado. É isso que o usuário comum quer. Se mantida essa trajetória, realmente não haverá mais grandes empecilhos para instalar programas no Ubuntu — um dos maiores problemas para o usuário comum.



Mas nem tudo são rosas, infelizmente: a instalação do Adobe Reader se mostrou complicada, requerendo a ativação de um canal de software “de terceiros”. A instalação de aplicativos baixados da Internet ainda deixa a desejar: se o pacote baixado for do tipo .deb, o gdebi o abre, mas antes de instalá-lo, verifica se o software em questão não está disponível no repositório da distribuição. Se esse for o caso, o gdebi indica a presença do software no repositório e recomenda que ele seja instalado de lá, mas não oferece nada mais além do botão de Fechar. Faltou andar aquela “milha extra” que faz toda a diferença para o usuário comum: custava abrir o Synaptic com o aplicativo que se deseja instalar já marcado para instalação e, simplesmente, resolver o problema? Isso já é feito no caso do Flash Player. Não há nada de novo a ser feito nesse sentido.



O mesmo vale para pacotes nos formatos .rpm, .tgz e — por que não? — até mesmo para executáveis do Windows®: o usuário que migra da plataforma da Microsoft vai simplesmente por uma questão de hábito procurar o aplicativo desejado na Internet, provavelmente no site do Superdownloads. O gdebi poderia ser estendido para, qualquer que seja o formato de arquivo que se deseja instalar, buscar pelo aplicativo no repositório da distribuição e para instalá-lo de lá. Com isso, o usuário aprenderia didaticamente que só raramente é necessário buscar por aplicativo fora do repositório da distribuição, algo que ele certamente acharia extraordinário e que contribuiria decisivamente para uma adoção mais ampla do Ubuntu — e do Linux em geral, se as outras distribuições adotarem um esquema semelhante ao que sugerimos aqui. Tal funcionalidade está a poucas linhas de código em Python no gdebi e a alguns ajustes em MIME-types do Firefox.



Conclusão



Em sua essência, o Ubuntu 9.04 não traz nenhuma mudança radical em relação às versões anteriores, mas muitas melhorias. Ao lado das alterações de interface gráfica, provavelmente o suporte ao Ext 4 deverá agradar a muitos usuários. No que tange ao suporte a hardware do X.org 1.6, entretanto, não se pode falar em evolução: no melhor dos casos, o usuário pode não ter qualquer problema (geralmente se usar placa de vídeo da Intel), mas caso use placas de vídeo mais “parrudas”, pode ser que a aceleração 3D, que funcionava no Ubuntu 8.10, simplesmente pare de funcionar. Por conta disso, antes de uma atualização para a nova versão, vale a pena verificar a situação do suporte ao hardware da placa de vídeo — de repente, é possível usar um driver mais antigo e que funcione. Como pontos altos do Jaunty Jackalope pode-se citar a redução do tempo de boot e a melhoria na aparência do sistema. Os avanços na instalação de programas e extensões também é digno de menção, muito embora esses avanços ainda tenham ficado a meio caminho da perfeição — que não está longe de atingir, no entanto. Nada que uma semana de trabalho consequente não resolva e que já poderia estar disponível na versão 9.10.













Ubuntu 9.04 “Jaunty Jackalope” — Galeria de capturas de tela (17 figuras)





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Xen: Entrevista com CTO de virtualização da Citrix e com gerente da comunidade Xen


Por Rafael Peregrino da Silva
Publicado em 20/04/2009

Este artigo foi visualizado 9948 vezes.

Versão para impressão Enviar por email



Por Pablo Hess



A aquisição da XenSource pela Citrix agitou ainda mais o mercado já crescente de virtualização.



Simon Crosby, CTO da divisão de virtualização e gerenciamento da Citrix, e Stephen Spector, gerente de comunidade Xen.org, contam nesta entrevista exclusiva para a Linux Magazine o que já está diferente e o que ainda vai mudar no cenário da virtualização.



Clique aqui e tenha a matéria na íntegra em seu computador.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Kernel 2.6.29: O Linux está com o diabo (da Tasmânia)!


Por Pablo Hess
Publicado em 24/03/2009

Este artigo foi visualizado 9806 vezes.

Versão para impressão Enviar por email



Tuz

Treze semanas. Foi esse o tempo necessário para a equipe de desenvolvimento do kernel Linux partir da versão 2.6.28 e chegar à 2.6.29. Em 89 dias (quase 13 semanas), o “Erotic Pickled Herring” deu lugar ao “Temporary Tasmanian Devil” (você sabia que as versões do kernel têm apelidos como esses?).




Embora os 10.933 arquivos alterados desde 24 de dezembro último não sejam exatamente um recorde (as duas versões anteriores tiveram mais que isso), a verdadeira surpresa está nas mais de 1,3 milhões de inserções de código – essas sim constituem um novo recorde.



As novidades, como se pode imaginar, não são poucas: dois novos sistemas de arquivos (e avanços no ainda recente Ext4), o progresso do mode-setting de vídeo baseado no kernel (KMS, para os íntimos), o suporte a redes WiMAX e uma série de alterações que já começaram a reduzir significativamente o tempo de inicialização do kernel – essas são apenas as mais chamativas, mas há muitas outras, como o Tuz, novo mascote do Linux que substitui temporariamente o adorável pinguim Tux durante a inicialização do sistema.


Sistemas de arquivos



O acesso a disco ainda é um dos principais gargalos do desempenho na maioria dos sistemas, tanto desktops quanto servidores – e até em alguns sistemas embarcados. Com tempos de acesso bem maiores que o restante do sistema, o armazenamento em disco continuará atrasando a computação como um todo até encontrarmos uma forma barata para guardar nossos incalculáveis volumes de dados.



É por isso que, além dos avanços nas tecnologias de armazenamento, como discos Flash e discos rígidos giratórios mais velozes e confiáveis, os sistemas de arquivos têm uma importância tão fundamental.



O kernel 2.6.29 finalmente trouxe o suporte ao sistema de arquivos de próxima geração Btrfs (pronuncia-se “better FS” ou “butter FS”, à sua escolha). Seus recursos são baseados no poderoso ZFS da Sun e ele está sendo desenvolvido por uma grande equipe de programadores muito capazes. Porém, a má notícia é que ele ainda está em desenvolvimento, e sua inclusão na árvore principal do kernel servirá justamente para acelerar a estabilização do código para que o Btrfs amadureça o mais rápido possível. Por enquanto, ainda não é possível confiar nele para conservar seus dados.



O SquashFS, no entanto, já é conhecido por usuários de Live CDs há tempos, mas somente agora passa a integrar a árvore principal do kernel. Seu “concorrente” CramFS, outro sistema compactado e somente-leitura que já residia no kernel há algum tempo, não parece estar muito vivo, e o SquashFS é perfeitamente competente.



O recente Ext4, introduzido como sistema de arquivos estável na última versão do kernel, recebeu melhorias e correções que o tornam mais adequado para uso em discos Flash. Uma das mais interessantes é a possibilidade de não utilizar o journal, introduzida por Ted Ts'o após o desenvolvedor descobrir que muitas pessoas utilizavam o venerável Ext2 – com todas as suas importantes limitações – nessas mídias apenas por não quererem sobrecarregar seus discos Flash com as constantes atualizações do journal.



Além disso, o sistema de arquivos distribuído OCFS2 finalmente passa a contar com suporte a ACLs, atributos de segurança, cotas e verificação (checksum) de metadados.


Vídeo



Os trabalhos da transferência do mode-setting de vídeo para dentro do kernel (e para fora do driver do X.org) começaram há 21 meses, acompanhados pelo desenvolvimento da infraestrutura de gerenciamento de memória gráfica GEM, e agora esse recurso já pode ser usado com chips gráficos Intel. O KMS (kernel-based mode setting), além de trazer melhor desempenho e simplificar o uso de chips gráficos, também resolve vários problemas da suspensão do sistema para a memória.


Rede



As redes sem fio jamais serão as mesmas quando o WiMAX começar a ser comercializado. Com até 75 Mbps e alcance medido em quilômetros, o padrão encabeçado pela Intel e baseado no IEEE 802.16 finalmente chegou ao Linux, primeiramente apenas com drivers para os dispositivos Intel Link 5x50, que funcionam por meio dos barramentos SDIO ou USB.



Nas redes sem fio tradicionais (IEEE 802.11), o sistema do demônio da Tasmânia disfarçado de pinguim (temporariamente, lembre-se) agora ganha também a capacidade de trabalhar como ponto de acesso mediante a instalação do hostapd.


Inicialização rápida



Arjan van de Ven continua dedicado a acelerar o processo de inicialização do kernel. Após os avanços perceptíveis implementados na versão 2.6.28, a 2.6.29 torna o cenário ainda melhor, pois começa a paralelizar a inicialização de subsistemas que não sejam interdependentes.



Infelizmente, alguns problemas desse paralelismo adiaram sua estreia para a versão 2.6.30, embora toda a infraestrutura já esteja presente e possa ser ativada na configuração e em tempo de incialização.


CPUs aos milhares



Se você estava feliz com seu computador de 4, 8 ou 16 núcleos – ou talvez 128, se você for uma pessoa influente –, saiba que o Linux agora suporta até 4.096 processadores. Para lidar com tantos processadores, são necessárias algumas alterações à forma como o sistema se refere a cada um deles, assim como o meio para se comunicar com eles. Então, junto com o novo limite superior, o kernel 2.6.29 traz o Tree RCU, um mecanismo hierárquico para acesso aos processadores que elimina graves problemas de desempenho enfrentados por sistemas com centenas de CPUs.


Demais



Outras novidades trazidas pelo Linux 2.6.29 incluem a criptografia de nomes de arquivos sob o eCryptfs, a capacidade de paralisar a atividade de determinados sistemas de arquivos para fins de becape ou snapshots, alterações na forma como o kernel lida com credenciais (usuário, grupo etc.) de processos, implementação do Xenfs para permitir a interação do Xen com o restante do sistema


Adeus, velharia



Uma decisão particularmente polêmica dos desenvolvedores do kernel deu cabo da compatibilidade do Linux 2.6.29 com as versões 3.0, 3.1, 4.1.0 e 4.1.1 do compilador GCC – o único capaz de compilar o kernel na atualidade.


Futuro



Para a versão 2.6.30, já podemos esperar algumas novidades. O sistema de arquivos Ext4 certamente contará com alguns patches para resolver um problema de perda acidental de dados após quedas do sistema, em decorrência do recurso de adiamento da alocação de blocos. Outra novidade deve vir do novo (sim, mais um) alocador de páginas de memória, o SLQB, para substituir o antigo SLAB e o mais recente SLUB.



Na área da segurança, os desenvolvedores têm falado bastante na plataforma Tomoyo, que deve ser integrada ao kernel no futuro, embora dificilmente a tempo para o 2.6.30.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Análise do Debian 5.0 “Lenny” [ATUALIZADA]


Por Rafael Peregrino da Silva
Publicado em 16/02/2009

Este artigo foi visualizado 10490 vezes.

Versão para impressão Enviar por email



Por Rafael Peregrino da Silva



Quase dois anos após o lançamento da versão 4.0 (codinome “Etch”) — e pouco depois do lançamento de sua sétima revisão —, a equipe de desenvolvimento do projeto Debian lançou finalmente a versão 5.0 (codinome “Lenny”) de uma das distribuições GNU/Linux mais conceituadas entre os profissionais habituados a trabalhar com o sistema do pinguim. Base para uma quantidade imensa de outras distribuições — entre elas o popular Ubuntu Linux, o Xandros, que equipa todos os modelos do EeePC, da ASUS, além das brasileiras DreamLinux, Insigne (pré-instalada em mais de 1.5 milhões de PCs para todos, comercializados no Brasil) e do (finado?) Kurumin Linux, uma das distribuições mais populares no Brasil no passado — o Debian GNU/Linux chega aos 16 anos emancipado: poucas distribuições Linux atingiram esse grau de maturidade com o nível de qualidade do projeto fundado em 1993 por Ian Murdock.



Em nosso teste usamos o CD de instalação via rede (ou netinst), um único CD que permite instalar todo o sistema operacional, mas contém apenas a quantidade mínima de software para começar a instalação e obter os outros pacotes pela Internet. Como os servidores do projeto Debian estão atualmente bastante sobrecarregados, a melhor maneira de obter a imagem do CD é recorrer ao bom e velho BitTottent, cujo arquivo .torrent pode ser obtido aqui. Com uma conexão banda larga comum, a imagem do CD (que tem apenas 150 MB) pode ser baixada em alguns minutos.



Instalação



A instalação não reserva muitas dificuldades ou surpresas: basta colocar o CD no respectivo leitor de mídia e escolher uma das alternativas que aparecem na tela, sendo que as opções Install e Graphical Install fazem exatamente aquilo que se supõe: instalam o sistema em modo texto ou gráfico. É digno de nota o fato de que é a primeira vez que um instalador gráfico é parte integrante de uma versão estável da distribuição Debian GNU/Linux.



A partir daí, sendo a instalação em modo texto ou gráfico, escolhe-se o idioma de instalação, o país e a disposição do teclado, dá-se um nome à máquina que está sendo instalada, configura-se o sistema para usar um servidor de horário (NTP) e particiona-se o(s) disco(s) para onde o sistema deverá ser instalado. Aqui uma recomendação de cautela: se for necessário criar diversas partições, é importante certificar-se de que há espaço suficiente no diretório raiz (/), em /var e em /usr. Em nossos testes, foi utilizado um esquema de se colocar a partição /home, na qual residem os dados dos usuários, separada do resto do sistema. Isso gerou problemas mais tarde, pois a etapa de seleção de software, apesar de levar em consideração a quantidade de espaço disponível no restante do sistema (que havia ficado simplesmente em /) — espaço esse sugerido pelo instalador quando do particionamento —, permite que se escolha mais aplicativos do que o espaço comporta. Não há qualquer mensagem de aviso ao usuário, recomendando que ele refaça a sua seleção de software. O particionamento do(s) disco(s), diga-se de passagem, apesar de simples, reserva muito espaço para melhoras, conforme já mostrou ser possível a última versão do Ubuntu, um derivado do Debian, conforme escrevemos acima. Seria interessante que houvesse um nível maior de colaboração entre as duas comunidades, com um consequente aumento de “polinização cruzada” entre os aplicativos dos dois projetos.



Após a senha do administrador e um usuário comum serem definidos, o repositório de software ser configurado, a seleção de software especificada estar instalada e a configuração do gerenciador de boot ser finalizada, basta reiniciar o sistema para iniciar um Debian 5.0 pronto para uso.



Uso como desktop?



O sistema é equipado com um kernel 2.6.26, finalizado por Linus Torvalds em 13/07/2008 e, desta forma, sete meses antes do lançamento do Lenny e duas versões mais velho do que o kernel mais recente, a versão 2.6.28(.5). Isso pode significar algum transtorno, especialmente para usuários de placas de rede WiFi e 3G para as quais novos drivers para Linux tenham sido lançados nos últimos seis meses. Razão para o uso de uma versão do kernel tão “antiga”, quando as últimas versões tanto do Ubuntu quanto do Fedora, lançadas respectivamente no final de outubro e novembro de 2008 já usam a versão 2.6.27, é a política de qualidade do projeto Debian, que premia a estabilidade do software. Usuários do Sid, ramo de desenvolvimento do Debian cuja árvore de dependências entre aplicativos é considerada instável (daí seu nome, unstable), também estavam limitados até agora ao kernel 2.6.26.











Desktop padrão do Debian 5.0, com o Iceweasel e o BrOffice.org Writer abertos e um filme sendo reproduzido no Totem.


Do ponto de vista das versões dos aplicativos instalados, uma novidade é a instalação de um servidor de janelas isento de configuração (X-Server 7.3). Pacotes para os drivers proprietários da ATI e da NVIDIA não são instalados por padrão e não há qualquer mecanismo trivial para instalá-los, muito embora eles estejam disponíveis na seção non-free do repositório da distribuição. O usuário tem que instalá-los ativando essa seção do repositório via linha de comando com o apt-get/aptitude ou graficamente com o synaptic.



Algo muito peculiar ocorre com codecs para formatos proprietários de áudio (MP3, WMA) e vídeo (QuickTime, WMV, H264 em geral): o Totem instalado por padrão não é capaz de reproduzi-los automaticamente, requerendo a instalação de plug-ins proprietários, algo que é muito simples, pois o próprio sistema se encarrega de instalá-los automaticamente se o usuário concordar com um aviso exibido na tela. Já o plug-in do Totem para o navegador de Internet foi capaz de reproduzir em nosso teste todo o tipo de conteúdo, pois conta com suporte aos codecs proprietários por padrão.



Ponto para o projeto BrOffice.org: a instalação em português do sistema instala automaticamente a versão nacionalizada do conjunto de aplicativos para escritório, em vez do OpenOffice.org. Infelizmente, da mesma forma que ocorreu com a última versão do Ubuntu, a versão instalada no Debian 5.0 ainda é a 2.4.1. A versão 3.0.0 sequer foi disponibilizada na árvore instável do projeto. Usuários que quiserem usar as fontes TrueType básicas da Microsoft deverão também ativar a seção contrib do repositório do Debian e instalá-las por meio do pacote ttf-mscorefonts-installer (o pacote msttcorefonts, utilizado até então para essa finalidade, deve ser eliminado do sistema em uma das próximas revisões).



Irritante é o fato de que nenhum dos aplicativos básicos da Adobe — a saber, o Adobe Reader (e seu respectivo plug-in para navegadores de Internet) e a extensão Flash Player para os navegadores de Internet — estão disponíveis em qualquer das seções dos repositórios oficiais do sistema. A versão 0.6.0 do Swfdec é responsável pela reprodução de animações em Macromedia Flash (a última versão estável do Swfdec, lançada no dia 21/12/2008, era a 0.8.4) e o Evince é o visualizador de arquivos PDF. O motivo que os desenvolvedores do Debian alegam para não disponibilizar os dois aplicativos da Adobe na seção non-free do repositório da distribuição, seria um problema com a nomenclatura das versões dos programas, que levaria a uma dificuldade de sincronizar atualizações de segurança realizadas pela Adobe nos dois aplicativos e a criação de pacotes para o Debian.



Outra coisa que incomoda é ter o Epiphany como navegador de Internet padrão, mesmo com o Iceweasel — que é como o Debian batizou o Mozilla Firefox, por questões de discordância com os termos de uso da marca da Fundação Mozilla — instalado por padrão. Há que se perguntar qual a motivação por trás da decisão de oferecer dois navegadores de Internet pré-instalados no sistema, sendo que a escolha do navegador padrão tenha recaído pelo menos popular deles.



A tabela a seguir ilustra alguns dos principais aplicativos instalados por padrão no sistema, bem como suas respectivas versões:












































































Debian 5.0 “Lenny”: aplicativos e versões
Aplicativo
Versão
Função
Kernel 2.6.26 É o Linux propriamente dito
X.org 7.3 Gerenciador de janelas
GNOME 2.22.3 Ambiente de trabalho
BrOffice.org 2.4.1 Conjunto de aplicativos para escritório
Iceweasel (Firefox) 3.0.6-1 Navegador de Internet
Pidgin 2.4.3 Aplicativo para troca instantânea de mensagens
Evolution 2.22.3.1 Correio eletrônico, gerenciador de tarefas, calendário e gerenciador de contatos
Gimp 2.4.7 Editor de imagens
Inkscape 0.46 Editor de imagens vetoriais
Rhythmbox 0.11.6 Reprodutor e gerenciador de músicas
Totem 2.22.2 Reprodutor de filmes
Ekiga 2.0.12 Cliente VoIP




DNA de servidor



No que tange à operação em servidores, área em que o Debian faz cada vez mais adeptos, a preocupação com segurança é sempre uma constante: diversos dos pacotes de serviços do sistema foram compilados com opções de segurança do GCC ativadas ou alterados com patches de segurança — como é o caso do PHP, por exemplo —, no intuito de dificultar a vida dos onipresentes agressores. Versões atualizadas do MySQL 5.1 e do PostgreSQL 8.3 são outras das aplicações que passaram por esse processo de melhoria de segurança.



A equipe de desenvolvimento do sistema também trabalhou pesado no suporte à virtualização: o Xen foi atualizado para a versão 3.2.1 e há suporte também para o KVM. O VirtualBox, por outro lado, está disponível em sua variante de código aberto (OSE) apenas na versão 1.6.6 — no fechamento deste artigo, a versão atual era a 2.1.2, disponível no site do projeto, agora de propriedade da Sun Microsystems. Para instalá-la basta incluir a seguinte linha ao arquivo /etc/apt/sources.list:




deb http://download.virtualbox.org/virtualbox/debian lenny non-free


e usar um dos gerenciadores de pacotes disponíveis para realizar a instalação propriamente dita.



Conclusão



O Debian 5.0 é uma distribuição GNU/Linux que, como de costume, prima pela qualidade, mas não pela disponibilização de versões mais atuais dos programas instalados. Praticamente todos os recursos disponíveis por padrão procuram oferecer recursos utilizando software livre. Essa opção, muito louvável de um lado, dificulta a escolha de alternativas proprietárias, que, infelizmente, em alguns casos, são as únicas que funcionam efetivamente — o caso do Flash Player sendo um bom exemplo (pelo menos por enquanto).



Como sistema para o desktop, a nova versão do Debian pode ser utilizada por usuários iniciantes ou experientes. A instalação dos plug-ins proprietários pode ser um desafio para os primeiros e há que se perguntar por que razão um iniciante deixaria de usar versões um pouco mais amigáveis do Linux baseadas no próprio Debian, como é o caso do Ubuntu, que se concentrou em resolver essas idiossincrasias que fazem da vida do usuário comum um inferno. Já o usuário experiente, que busca estabilidade e consegue superar facilmente esse tipo de transtorno, vai ficar satisfeito em poder trabalhar com um sistema leve, enxuto e extremamente estável, que conta com quase 23.000 pacotes prontos para instalar.



Como servidor, o Lenny é uma atualização obrigatória. Provavelmente, o sistema deverá ser um competidor forte para outras distribuições Linux, para diversos sabores de UNIX e também para o Windows®. Simples de gerenciar, flexível e bastante robusto, o Debian 5.0 veio para melhorar o que já era bom.



Seja servidor ou desktop, entretanto, o fato é que a nova versão continuará a ser a plataforma base de escolha para um grande número de distribuições populares, servidores dedicados (appliances) e dispositivos embarcados — a nova versão oferece suporte a 11 arquiteturas, fornecendo praticamente a mesma experiência de uso em todas elas.













Debian 5.0 “Lenny” — Galeria de capturas de tela




Saiba mais:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Mobilidade Programada II — Programando um rastreador GPS para o Android


Por Rafael Peregrino da Silva
Publicado em 12/02/2009

Este artigo foi visualizado 17115 vezes.

Versão para impressão Enviar por email



Por Oliver Frommel



A versão 1.1 do SDK do Android acabou de ser lançada, e corrige alguns erros da versão anterior, além de introduzir melhorias de compatibilidade do celular G1, que já pode rodar a nova versão 1.1.0 do Android. Há alguns dias publicamos um artigo inicial, que mostrava como preparar adequadamente um ambiente de desenvolvimento de aplicativos para o Android. Neste segundo artigo da série, vamos mostrar como desenvolver um programa de apenas poucas linhas de código, mas que é capaz de ler e exibir coordenadas GPS.



Com o SDK do Android e o plug-in para o Eclipse, é relativamente simples desenvolver aplicativos para celulares equipados com a plataforma operacional baseada em Linux desenvolvida pelo Google. As ferramentas contidas nesse kit de desenvolvimento funcionam bem, são fáceis de usar e a API é bem estruturada e documentada. Além disso, há na Internet uma grande quantidade de exemplos para todo o tipo de aplicação. Entretanto, é necessário estar atento ao fato de que o código-fonte de muitos desses programas é compatível com a versão anterior do sistema, mas não com a versão atual, recém-lançada. Conforme escrevemos acima, o aplicativo que vamos desenvolver neste artigo terá por função estender a estrutura do programa criada automaticamente pelo Eclipse no artigo anterior, tranformando-a em um aplicativo rastreador GPS, capaz de fornecer as coordenadas da posição geográfica atual.



Usando o ambiente instalado no artigo anterior, composto basicamente do kit de desenvolvimento do Android e o plug-in do Eclipse, é possível compilar um aplicativo rudimentar e executá-lo no emulador que faz parte do SDK. Caso um G1 “de verdade” seja conectado via USB ao PC ou laptop com Linux dotado com o ambiente de desenvolvimento, pode ser que ele não seja detectado pelas ferramentas do Android que o Eclipse roda em background, para — por exemplo — carregar aplicativos para o equipamento. A solução para contornar esse problema é configurar corretamente o subsistema udev, responsável pela criação e pelas permissões de arquivos de dispositivos no Linux. A seguinte regra fornece as permissões corretas ao arquivo de dispositivo criado quando o G1 é conectado ao computador:




SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"




Basta incluir a linha acima no arquivo /etc/udev/rules.d/50-android.rules e tornar esse arquivo executável, e daí por diante tudo deveria funcionar corretamente.



Como a figura seguinte mostra, o código gerado pelo Eclipse quando configuramos o sistema no artigo anterior, ficou bastante sucinto.










Ambiente Eclipse
Código gerado automaticamente pelo Eclipse, quando da criação do projeto do aplicativo que será desenvolvido, logo após a instalação do SDK e do plug-in.


A própria classe hello estende a classe Activity do sistema, que está prevista para uso em aplicativos de interface gráfica padrão. O pouco que resta do código está no método de retorno de chamada (callback) onCreate(), que é executado quando o aplicativo é inicializado. Após a chamada do método de retorno de chamada da classe pai, resta apenas ativar o modo de exibição na componente de layout main. O Eclipse deixa esse tipo de recurso armazenado no arquivo R.java, que é atualizado constantemente. Modificações nesse arquivo devem, assim, ser evitadas, para que não ocorram conflitos.



Para imprimir o clássico Olá mundo! no visor do celular, não é necessário nada além de um TextView, que deve então ser ativado como elemento de exibição atual. A cadeia de caracteres a ser apresentada no visor é fornecida ao objeto TextView pelo método setText().


TextView tv = new TextView(this);
tv.setText("Hello Android");
setContentView(tv);




Se o que se deseja é mais do que exibir um texto sem graça no visor — por exemplo, a posição geográfica atual do celular —, é necessário estar familiarizado com o conceito de “ouvinte” (listener). Em várias ocasiões, esse conceito serve de interface para determinados eventos — regulares ou ocasionais —, tais como o fornecimento de dados pelo usuário. O programador deve criar suas próprias funções como ouvintes de determinados eventos, de modo que essas funções sejam executadas quando o evento ocorrer. A plataforma Android assegura que os aplicativos não consumam tempo de processamento desnecessariamente, mas que permaneçam em estado latente, reagindo prontamente quando o evento designado para ela aconteça.



Uma característica notável da API do Android é que ela está perfeitamente adaptada ao desenvolvimento de aplicativos específicos para o G1. Assim, bastam algumas poucas linhas de código, para que se possa determinar a atual posição geográfica do celular via GPS. Para isso, basta criar um novo LocationProvider e associar a ele, através de um de seus métodos, uma função customizada — no nosso caso, locationListener, que é chamada de modo recorrente de tempos em tempos.




LocationProvider provider = lm.getProvider("gps");
lm.requestLocationUpdates("gps",
60000, // 1min
1, // 10m
locationListener);




Além do uso das coordenadas do GPS, há também outros tipos de LocationProvider, que por exemplo conseguem obter a posição geográfica de maneira mais precisa a partir da célula em que o telefone se encontra. A nossa função customizada LocationListener só precisa ler a latitude e a longitude através dos métodos do objeto de localização geográfica e fornecê-las ao objeto TextView:




private final LocationListener locationListener = new LocationListener() {
public void onLocationChanged(Location l) {
TextView tv = new TextView(LnmTrakr.this);
tv.setText("lat: " + l.getLatitude() + "\nlon: " + l.getLongitude());
setContentView(tv);
}
...




Como esse código cria empiricamente uma classe anônima, é necessário que a TextView faça uma referência à classe mais externa usando LnmTrakr.this. Para simular o funcionamento do equipamento de GPS no emulador do celular, é necessário realizar uma conexão via telnet ao emulador — usando para isso o comando telnet localhost 5554 — e, no console que se abrir, fornecer as coordenadas usando a seguinte sintaxe: geo fix 20 40.










Programa em execução, mostrando a latitude e a longitude no emulador do SDK.
Programa em execução, mostrando a latitude e a longitude no emulador do SDK.



Ao rodar esse aplicativo no emulador ou no próprio celular, percebe-se logo que não há como fechar esse programa. Com mais alguma linhas de código pode-se dotar o aplicativo de um menu próprio com um botão de “Sair”. O código abaixo ilustra como criar um menu com diversas opções de entrada (algumas delas estão “comentadas”, isto é, desativadas):


@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);

menu.add(Menu.NONE, 0, 0, "Exit");
//menu.add(Menu.NONE, 1, 1, "Settings");
//menu.add(Menu.NONE, 2, 2, "Other");
return true;
}




Com o manipulador de eventos apropriado, o programa pode ser encerrado, bastando para isso que se selecione o “0” no menu:




public boolean onOptionsItemSelected(MenuItem item){
switch (item.getItemId()) {
case 0:
finish();
}
return false;
}











Ambiente Eclipse
O Google quer coletar dados sobre o uso do Android. Claro, se não quisesse, não seria o Google...


Assim, com apenas algumas linhas de código, um primeiro aplicativo — capaz de realizar várias tarefas — foi finalizado. O código fonte em Java do arquivo principal pode ser baixado aqui. Apenas mais algumas linhas de código e o aplicativo torna-se capaz de — adivinhe — mostrar a posição geográfica atual no Google Maps. Ao finalizar o Eclipse, o Google preparou uma janela extra, com o intuito de lhe pedir permissão para realizar estatísticas sobre o seu uso do Android.



O programador pode escolher não conceder essa permissão — ao contrário do usuário do G1, que não tem essa opção.



Saiba mais:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Mobilidade programada — Programando aplicativos móveis com o SDK do Android no Eclipse


Por Rafael Peregrino da Silva
Publicado em 08/02/2009

Este artigo foi visualizado 11249 vezes.

Versão para impressão Enviar por email



Por Oliver Frommel



Recentemente, publicamos o artigo Programe seu andróide, com o qual é possível aprender como desenvolver um primeiro aplicativo para o “celular do Google”. A partir de agora, vamos publicar uma série de artigos, em um formato que ilustrará passo-a-passo, como desenvolver programas para o Android, sendo que cada um dos artigos se ocupará apenas de uma parte do processo de criação de programas para a plataforma.



O “ruído” em torno do projeto do celular G1 só é comparável ao do seu arqui-rival, o iPhone, da Apple. É muito fácil desenvolver aplicativos para o telefone — desenvolvido como parte de uma parceria entre o Google e o fabricante de hardware taiwanês HTC —, usando o ambiente integrado de desenvolvimento Eclipse, conforme mostraremos a partir deste que será o primeiro de uma série de artigos na Linux Magazine Online.



O anúncio do Google a respeito do desenvolvimento de um telefone celular próprio foi acompanhado pelo típico “burburinho” que envolve todas as iniciativas lideradas pelo gigante de buscas, e que deveriam, assim, tornar-se disponíveis para o equipamento. Por conta disso, grande número de desenvolvedores passaram a utilizar a plataforma Android, que tem o Linux por fundamento e sobre o qual há um conjunto de bibliotecas desenvolvidas especificamente para a plataforma, como por exemplo uma versão reduzida da glibc.



Mas o Google não seria o Google se não “reinventasse a roda” algumas vezes no curso do desenvolvimento da plataforma Android. Assim, a camada de aplicação da plataforma dispõe de um ambiente de programação Java, mas não a máquina virtual de costume, desenvolvida pela Sun Microsystems. Da mesma forma que o Google desenvolveu o V8, um novo interpretador Javascript para o seu novo navegador de Internet — o Chrome —, a empresa preferiu inovar e desenvolver do zero um novo ambiente operacional para aplicativos escritos em Java, batizado com o nome Dalvik, que economiza memória, em comparação com a Java-VM original da Sun, o que seria mais adequado para dispositivos móveis.



A interface de programação da plataforma Android foi modificada diversas vezes desde o seu lançamento, mas isso não deve mais ocorrer, uma vez que já há um equipamento em operação no mercado. Além da plataforma de software, o Google fornece também uma extensão para o Eclipse, com o intuito de facilitar o trabalho dos desenvolvedores de aplicativos para o Android.



O plug-in para o Eclipse



Baixe a última versão do Eclipse para o seu sistema operacional (a “Classic” 3.4.1, no momento da escrita deste artigo) aqui, copie o arquivo baixado para o diretório de sua preferência e o desempacote. Se ainda não o fez, abra um terminal, entre no diretório eclipse, automaticamente criado no processo de descompactação do arquivo do Eclipse, e chame o programa pela linha de comando, digitando ./eclipse. Feche a tela de saudação do programa e a área de trabalho aparece, dividida em diversos painéis. Algumas distribuições Linux também já contém o Eclipse em seus repositórios, de modo que o programa pode ser instalado diretamente de lá. Certifique-se apenas de que se trata da versão 3.3 ou 3.4.



A extensão do Android para o Eclipse pode ser facilmente instalada, bastando para isso entrar no menu Help | Software Updates e chamar o gerenciador de atualizações. Na área à direita da janela, clique em Add Site e forneça a seguinte URL na caixa de diálogo que aparecer: https://dl-ssl.google.com/android/eclipse/. Durante nossos testes, essa URL parou de funcionar por algum tempo. Uma alternativa se isso acontecer é fornecer no lugar dela o seguinte endereço na Internet: http://dl-ssl.google.com/android/eclipse/site.xml. Se o endereço fornecido aparecer na lista de sites de extensões, basta selecionar os plug-ins disponíveis sob o endereço — neste caso, as ferramentas de desenvolvimento. Um clique sobre o botão Install, na parte de cima à esquerda, instala a extensão, após o aceite da licença de uso. Recomenda-se reiniciar o Eclipse ao final do processo de instalação.



O ambiente Android



O kit de desenvolvimento completo para o Android — o famoso “SDK” — pode ser encontrado em http://code.google.com/android. Para baixá-lo, clique em Download the SDK.



Antes do download propriamente dito, aparecem as condições para o uso do SDK, cuja leitura é recomendada. Após baixar o arquivo do tipo ZIP, abra um terminal e descompacte-o usando simplesmente o unzip (ou, se preferir, algum dos aplicativos gráficos para essa finalidade, como o file-roller ou o kpackage). Antes de poder programar o seu primeiro aplicativo para o Android, é necessário dizer ao Eclipse onde encontrar o SDK. Para fazer isso, entre no menu Window | Preferences, onde uma entrada indicada por Android poderá ser encontrada. Um clique sobre o botão Browse abre uma caixa de diálogo de seleção de arquivos, por meio da qual deve-se indicar qual é o diretório em que o SDK se encontra.










Ambiente Eclipse
Ambiente Eclipse, configurado para a programação de aplicativos para o Android


Agora basta clicar em File | New | Project ou no ícone correspondente na barra de ferramentas da janela do Eclipse. Na lista de tipos de projeto que aparece, escolha Android, preenchendo na caixa de diálogo que se abre os campos de nome, nome das classes e a activity (um outro nome para um aplicativo Android). Com isso, o Eclipse cria a estrutura para o aplicativo a ser desenvolvido. Um clique sobre o botão com um ícone verde ou no menu Run correspondente, inicia o programa no emulador de hardware que vem com o SDK. Se houver um celular equipado com o Android conectado ao seu sistema, o Eclipse também pode executar o aplicativo diretamente no hardware.



Com isso, encerramos uma primeira etapa para começar a programar para o Android. No próximo artigo vamos começar a desenvolver um aplicativo simples com o nosso recém-instalado SDK. Esse aplicativo deverá evoluir no curso dessa série de artigos, tornando-se ao final um rastreador GPS.



Saiba mais:







Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Vídeo da análise do “celular do Google” com Android


Por Pablo Hess
Publicado em 04/02/2009

Este artigo foi visualizado 10321 vezes.

Versão para impressão Enviar por email




A Linux Magazine preparou uma análise do smartphone HTC G1, equipado com o sistema operacional Android. Desenvolvido com base no Linux, veja o que esse telefone celular reserva para seus usuários.









Veja os demais artigos sobre o Android:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Programe seu andróide


Por Rafael Peregrino da Silva
Publicado em 31/01/2009

Este artigo foi visualizado 7818 vezes.

Versão para impressão Enviar por email



O Android é uma plataforma de código aberto para dispositivos portáteis criado pelo Google em parceria com a Open Handset Alliance (OHA). Trata-se de uma aliança para o telefone celular aberto, composta por mais de 30 empresas do mercado de TI que apóiam soluções de código-fonte aberto, como Samsung, Intel, Motorola, Qualcomm e Telefónica. A OHA pretende repetir a estratégia da IBM com a fabricação do PC, composto por partes facilmente adquiridas no mercado.



Essa plataforma funciona como um sistema operacional como os já existentes Symbian e Windows® Mobile, com a diferença de ser baseado em Código Aberto. Com isso, qualquer desenvolvedor pode criar aplicativos para a plataforma Android. O kit de desenvolvimento do Android provê ferramentas e chamadas via APIs para o desenvolvimento de aplicativos baseados na linguagem Java.



Em outras palavras, trata-se de um pacote com programas para celulares, já com um sistema operacional, middleware, aplicativos e interface de usuário. Tais recursos permitirão que o Google e outras empresas ofereçam recursos mais ricos aos usuários que se encontram distantes de um computador de mesa.



Os principais recursos dessa plataforma móvel são a máquina virtual otimizada, o navegador integrado, a biblioteca 2D e 3D, o banco SQLite e o plugin para o
Eclipse , chamado ADT .



Para quem deseja ter contato com a metodologia de programação da plataforma Android, nosso artigo na Linux Magazine é um bom ponto de partida.



Saiba mais:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Análise preliminar do Android G1: operação e recursos


Por Rafael Peregrino da Silva
Publicado em 30/01/2009

Este artigo foi visualizado 8176 vezes.

Versão para impressão Enviar por email



Por Ulrich Bantle e Rafael Peregrino da Silva





Que a HTC é capaz de desenvolver smartphones de qualidade, ela já provou: o fabricante tawianês de celulares tem um longo histórico de desenvolvimento de dispositivos equipados com o Windows® Mobile. O G1, novo modelo de equipamento que vem com o sistema operacional Android, baseado em Linux e patrocinado pelo Google, não é exceção à regra. O casamento entre o hardware e um novo sistema operacional — neste caso a versão 1.1 do Android, cujo desenvolvimento abriga, via de regra, uma montanha de “surpresas”, tais como problemas de estabilidade e compatibilidade — é realmente um processo surpreendente de se acompanhar. O G1 pode até não ter um aspecto tão bem acabado como o do iPhone, mas reúne com certeza o potencial para inclusão na “liga” do Symbian, do Windows Mobile, do BlackBerry e mesmo do celular da Apple.



Neste artigo vamos testar a configuração básica e os recursos do equipamento. Nos próximos dias pretendemos publicar outros testes com o celular.



Competidor competente



As especificações técnicas do G1 comprovam a sua capacidade de competir ombro a ombro com os rivais no segmento: quadband, GPRS, EDGE, UMTS e HSDPA, capaz de lidar com conexões de até 7,2 Mbit/s, podem ser elencadas como algumas das modalidades de transmissão para as quais o dispositivo oferece suporte. Além disso, o celular ainda traz um rol de outras possibilidades de conexão, como Wi-Fi 802.11b/g, USB 2.0 e Bluetooth. GPS assistido, tela sensível ao toque de 320 x 480 pixels e um teclado escamoteável são outros destaques da configuração de hardware do equipamento. Por padrão, o celular vem equipado com um cartão SD de 2 GB — extensível até 8 GB. A câmera integrada com foco automático tem resolução de 3,2 megapixels, o que basta para aquelas fotos ocasionais — é necessário ter paciência com o atraso de disparo da câmera.



Compatível com Linux



O usuário de Linux vai ficar satisfeito com o fato de que o celular não vem com aquele CD de instalação irritante, que traz drivers ou outros tipos de programas, que em geral requerem que o Windows® esteja instalado. Assim que o celular é conectado a uma máquina equipada com Linux (no nosso caso, com o Ubuntu 8.04 LTS), um símbolo aparece na sua tela, indicando a conexão via USB. Basta ativar a conexão para que o Ubuntu e o G1 comecem a “conversar”. O telefone se registra no Nautilus como dispositivo de armazenamento removível com capacidade de 2 GB, arquivos MP3 armazenados nele são automaticamente listados no Rhythmbox e estão prontos para ser tocados. Fotos aparecem automaticamente no F-Spot e podem ser copiadas para o disco do PC sem problemas.



Não sincroniza com o Outlook



O fato de que o dispositivo não sincroniza automaticamente com o Microsoft Outlook por padrão, é também uma das peculiaridades do G1: é que o Google prefere que o usuário use os seus serviços, e não os da concorrência. Isso fica claro de cara na documentação que acompanha o produto: “A ativação do seu G1 requer uma conta no Google Mail”. A utilização dessa conta de e-mail segue as condições de serviço do gigante de buscas, e sua configuração pode ser realizada gratuitamente a partir do próprio G1, exigindo entretanto uma conexão de dados (GPRS/EDGE/UMTS/HSDPA), que, claro, não é gratuita. Para o nosso equipamento de testes essa ativação foi desnecessária, uma vez que o celular já foi enviado para a redação registrado.



Para usuários corporativos pode ser que o fato de a sincronização com o Outlook não ocorrer por padrão desmotive a aquisição do produto. No Android Market, repositório de aplicativos para o aparelho criado pelo Google, já há diversos aplicativos que possibilitam a sincronização, entre elas o Funambol, usando um servidor intermediário.



Fácil de usar



A operação usando a tela sensível ao toque, o teclado, a pequena trackball e os botões disponíveis junto à tela do celular, fica fácil depois de algum treino. É de se perguntar se o teclado escamoteável seria mesmo necessário: apesar de a sua qualidade ser inquestionável, somente para a entrada de URLs é que ele se mostrou realmente de utilidade em nossos testes. De vez em quando a tela sensível ao toque pode precisar ser acionada duas vezes, mas no geral funciona corretamente, permitindo a navegação por menus que são ativados através do acionamento de ícones de tamanho adequado.



Aplicativos



Entre os aplicativos disponíveis pode-se citar, além do Gmail, um cliente de e-mail capaz de sincronizar via protocolos POP3 e IMAP, bem como um navegador de Internet, com o qual é possível entrar na rede e efetivamente ler o conteúdo das páginas mostradas — ponto para a excelente qualidade do display do aparelho, que dispõe de contraste e luminosidade muito bons para dispositivos desse tipo. Além disso, pode-se encontrar entre os diversos programas instalados: calculadora, calendário, despertador, gerenciador de contatos, gerenciador de fotos e reprodutor de MP3. Mas o que surpreende realmente é a oferta de aplicativos no Android Market: a maioria dos programas disponíveis ali é grátis e indicam que o Google realmente fez um nome junto aos desenvolvedores na comunidade. Em diversas categorias podem ser encontradas uma grande variedade de ferramentas para complementar os programas que equipam o celular por padrão.



Conclusão



O sistema operacional de código aberto desenvolvido pelo Google com base no Linux coloca o gigante de buscas em pé de igualdade com os grandes fornecedores de tecnologia para equipamentos móveis, mesmo considerando que os serviços da empresa, tais como o Gmail e o Google Maps estejam enraizados no G1. O conjunto de recursos contemplados no equipamento, por si só, é muito bom. Na Alemanha, a operadora T-Mobile assegurou os direitos exclusivos de comercialização do aparelho, da mesma forma que ocorreu com o iPhone. Resta saber como e quando o G1 vai chegar oficialmente ao Brasil, mas é fato que as operadoras locais já estão negociando as condições de comercialização no país com a HTC e com o próprio Google. Como o Google tem uma presença forte no Brasil, é bem provável que ele demore menos para chegar aqui que o seu rival da Apple.












Galeria de imagens
























Saiba mais:





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Tanenbaum: Por que os computadores não funcionam sem parar?


Por Andrew S. Tanenbaum
Publicado em 08/12/2008

Este artigo foi visualizado 9554 vezes.

Versão para impressão Enviar por email



A briga entre o criador do Minix e czar dos sistemas Operacionais Andrew S. Tanenbaum e Linus Torvalds é lendária no mundo dos sistemas operacionais. Antes do Linux havia o Minix. Torvalds criou sua primeira versão do Linux em 1991 sobre o sistema do professor Tanenbaum. Agora, o sr. Tanenbaum concordou em escrever um editorial para a Linux Magazine. Sua opinião não mudou ao longo dos anos: o Linux (e o Windows) “não são confiáveis”.


Por Andrew S. Tanenbaum











Andrew S. Tanenbaum

Professor Andrew S. Tanenbaum



Os usuários de computadores estão mudando. Há dez anos, a maioria dos usuários de computadores eram pessoas ou profissionais jovens com amplo conhecimento técnico. Quando algo saía errado – o que ocorria com freqüência –, eles sabiam consertá-las. A maioria deles consegue consertar computadores tão bem quanto um nerd de computador padrão sabe consertar seu carro. O que eles querem mais do que qualquer outra coisa é que o computador funcione o tempo todo, sem interrupções ou falhas.


Muitos usuários comparam automaticamente seus computadores a suas televisões. Ambos estão repletos de componentes eletrônicos mágicos e possuem telas grandes. A maioria dos usuários tem um modelo implícito de uma televisão: (1) você compra a TV; (2) você a liga na tomada; (3) ela funciona perfeitamente sem qualquer falha durante os próximos dez anos. Eles esperam isso do computador e, quando não é o que obtêm, ficam frustrados. Quando os especialistas em computadores lhes dizem: “Se Deus quisesse que os computadores funcionassem o tempo todo, Ele não teria inventado o botão de RESET”, eles não se convencem.


Por falta de uma melhor definição de disponibilidade, adotemos a seguinte: um dispositivo é dito disponível (isto é, podemos dispor dele) se 99% dos usuários jamais experimenta qualquer falha durante todo o período em que o possuem. Por essa definição, virtualmente nenhum computador é disponível, enquanto a maioria das TVs, iPods, câmeras digitais etc. são. Usuários técnicos de computador estão dispostos a perdoar um computador que trave uma ou duas vezes por ano; usuários comuns, não.


Usuários domésticos não são os únicos incomodados com a baixa disponibilidade dos computadores. Até mesmo em ambientes altamente técnicos, a baixa disponibilidade dos computadores é um problema. Empresas como Google e Amazon, com centenas de milhares de servidores, experimentam várias falhas todo dia. Elas aprenderam a conviver com isso, mas prefeririam sistemas que simplesmente funcionassem sem parar. Infelizmente, os softwares atuais falham nesse aspecto.


O problema básico é que softwares contêm bugs, e quanto mais software, mais bugs. Vários estudos já mostraram que o número de bugs por mil linhas de código (KLoC) varia de um a dez em grandes sistemas de produção. Um software muito bem escrito talvez tenha dois bugs por KLoC ao longo do tempo, mas não menos. Um sistema operacional com, digamos, 4 milhões de linhas de código, portanto, deve ter pelo menos 8 mil bugs. Nem todos são fatais, mas alguns serão. Um estudo da Universidade Stanford mostrou que drivers de dispositivos – que compõem até 70% da base de código de um sistema operacional típico – possuem taxas de bugs 3x a 7x mais altas que o resto do sistema. Drivers de dispositivos têm taxas mais altas porque (1) são mais complicados e (2) são menos inspecionados. Enquanto muitas pessoas estudam o escalonador, poucas verificam os drivers de impressoras.


A solução: kernels menores


A solução para esse problema é retirar código do kernel, no qual o dano pode ser máximo, e colocá-lo em processos do espaço do usuário, onde bugs não conseguem causar falhas de sistema. É assim que o MINIX 3 é projetado. O sistema MINIX atual é o (segundo) sucessor do MINIX original, que foi lançado originalmente em 1987 como sistema operacional educativo, mas desde então foi radicalmente revisado para se tornar um sistema altamente disponível e auto-recuperável. Segue uma breve descrição da arquitetura do MINIX; há mais informações em www.minix3.org.


O MINIX 3 é projetado para rodar o mínimo de código possível no modo do kernel, em que bugs podem facilmente ser fatais. Em vez de 3-4 milhões de linhas de código no kernel, o MINIX 3 tem aproximadamente 5.000 linhas de código no kernel. Às vezes, kernels desse tamanho são chamados de microkernels. Eles lidam com gerenciamento de processos no baixo nível, escalonamento, interrupções e o relógio, e fornecem alguns serviços de baixo nível para componentes do espaço do usuário.


A maior parte do sistema operacional roda como uma coleção de drivers de dispositivos e servidores, cada um rodando como processo comum do espaço do usuário com privilégios restritos. Nenhum desses drives e servidores roda como superusuário ou equivalente. Eles não conseguem nem acessar dispositivos de I/O ou o hardware MMU diretamente; precisam usar serviços do kernel para ler e escrever no hardware. A camada de processos rodando diretamente no modo de usuário acima do kernel consiste em drivers de dispositivos, com o driver de disco, o de Ethernet e todos os outros rodando como processos separados protegidos pelo hardware MMU, para não conseguirem executar qualquer instrução privilegiada e nem lerem ou escreverem em locais de memória além dos seus próprios.


Acima da camada de drivers vem a de servidores, com um servidor de arquivos, um servidor de processos e outros. Os servidores fazem uso dos drivers assim como de serviço do kernel. Por exemplo, para ler um arquivo, um processo do usuário envia uma mensagem ao servidor de arquivos, que então envia uma mensagem para o driver de disco para buscar os blocos necessários. Quando o sistema de arquivos os tem em seu cache, ele chama o kernel para movê-los para o espaço de endereços do usuário.


Além desses servidores, há um outro servidor chamado “servidor de reencarnação”. Ele é o pai de todos os processos de drivers e servidores e monitora seu comportamento. Se ele descobrir um processo que não esteja respondendo a pings, ele inicia uma nova cópia a partir do disco (exceto pelo driver do disco, que fica oculto na RAM). O sistema foi projetado para que muitos (mas não todos) os drivers e servidores críticos sejam automaticamente substituídos enquanto o sistema funciona, sem perturbar os processos de usuário em execução e sem nem notificar o usuário. Dessa forma, o sistema é auto recuperável.


Para testar se essas idéias funcionam na prática, conduzimos os seguintes experimentos. Iniciamos um processo de injeção de falhas que sobrescreveu 100 instruções de máquina no binário do driver Ethernet em execução para ver o que ocorreria caso um deles fosse executado. Se nada acontecesse em poucos segundos, outras 100 eram injetadas e assim por diante. No total, injetamos 800.000 falhas em cada um dos três diferentes drivers Ethernet e causamos 18.000 travamentos do driver. Em todos os casos, o driver foi automaticamente substituído pelo servidor de reincarnação. Apesar de injetar 2,4 milhões de falhas no sistema, o servidor não parou uma vez sequer. Nem é preciso dizer que se ocorrer um erro fatal num driver do Windows ou do Linux rodando no kernel, todo o sistema operacional travará imediatamente.


Existe alguma desvantagem nessa técnica? Sim. Há uma redução de desempenho. Não a medimos extensivamente, mas o grupo de pesquisa em Karlsruhe, Alemanha, que desenvolveu seu próprio microkernel (o L4) e depois rodou o Linux como um de seus processos de usuário, conseguiu uma perda de desempenho de apenas 5%. Acreditamos que se dedicarmos um pouco de atenção a esse típico, também conseguiremos reduzir a perda para a faixa entre 5 e 10%. Desempenho não é uma prioridade para nós, já que a maioria dos usuários que lêem email ou navegam pelo Facebook não são limitados pelo desempenho da CPU. O que eles querem, no entanto, é um sistema que simplesmente funcione o tempo todo.


Se microkernels são tão disponíveis, por que ninguém os usa?


Na verdade, usam, sim. Provavelmente você roda vários deles. Seu telefone celular, por exemplo, é um computador pequeno, mas comum em todos os outros aspectos, e há uma boa chance de ele rodar o L4 ou o Symbian, outro microkernel. O roteador de alta performance da Cisco também usa um microkernel. Nos mercados militar e aeroespacial, em que disponibilidade é fundamental, o Green Hills Integrity, outro microkernel, é amplamente usado. O PikeOS e o QNX também são microkernels amplamente usados em sistemas industriais e embarcados. Em outras palavras, quando é realmente importante que o sistema “simplesmente funcione o tempo todo”, as pessoas usam microkernels. Para mais informações sobre esse tópico, veja www.cs.vu.nl/~ast/reliable-os/.


Concluindo, é nossa crença, baseada em várias conversas com usuários não técnicos, que o que eles mais desejam é um sistema que funcione perfeitamente todo o tempo. Eles têm uma baixa tolerância a sistemas pouco confiáveis, mas atualmente não têm escolha. Acreditamos que sistemas baseados em microkernels podem nos levar a sistemas mais disponíveis.


Confira também o texto original (em inglês) deste editorial.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Entrevista com o presidente do Serpro, Marcos Mazoni


Por Pablo Hess
Publicado em 01/12/2008

Este artigo foi visualizado 21099 vezes.

Versão para impressão Enviar por email










Marcos Mazoni, presidente do Serpro.
Marcos Mazoni, presidente do Serpro


O Serpro é um dos principais fornecedores de soluções de tecnologia da informação para o governo federal e seus órgãos e empresas. Marcos Mazoni, presidente do órgão e do Comitê de Implantação de Software Livre do governo federal, conversou com a Linux Magazine a respeito de seu primeiro ano à frente da instituição, os desafios enfrentados e o que podemos esperar do próximo ano.


Linux Magazine» No final de 2007, você previu uma economia de R$100 milhões em 2008 com a substituição de software proprietário por Software Livre no governo federal. Isso se concretizou?


Marcos Mazoni» Tivemos muitas substituições de software proprietário por Software Livre. Porém, o governo federal possui sistemas de informação construídos nos últimos 40 anos que ainda estão em operação. Por isso, as substituições ocorreram em grau muito maior em nossa infra-estrutura do que propriamente nos novos sistemas.


A adoção de Software Livre em nossas ferramentas de desenvolvimento e nossa infra-estrutura de rede, além da nossa gestão da infra-estrutura, promoveram uma economia talvez até maior do que R$ 100 milhões.


Diversos componentes de Software Livre, como nosso framework de desenvolvimento e nossa ferramenta de correio, agenda e catálogo (Expresso), entraram em importantes empresas, como Dataprev, Caixa Econômica Federal, Banco do Brasil e Petrobras, o que deu uma economia muito grande a todas as empresas do governo e, portanto, também para o orçamento.


LM» No momento, quais são os maiores clientes do Serpro?


MM» A Receita Federal corresponde a 70% da nossa atividade, enquanto o Ministério da Fazenda responde por 80%, ao Ministério do Planejamento cabem 10% e outros 30 órgãos compõem os 10% restantes do nosso trabalho.


Na prática, somos praticamente um órgão interno do Ministério da Fazenda.


LM» Como anda a migração do governo federal para o BrOffice.org?


MM» Após a adesão ao protocolo que orienta a utilização do ODF, estamos com todos os órgãos em processo de migração ou em planejamento com o PDTI para 2009. Isso inclui grandes estruturas, como o Exército, a Aeronáutica, Banco do Brasil, Caixa Econômica e outras.


LM» O episódio da aprovação na ISO do padrão concorrente do ODF, o OOXML, teve alguma repercussão negativa sobre os trabalhos de adoção do ODF no governo?


MM» Não, pois isso teve pouca influência sobre a adesão ao protocolo. Com os órgãos aderindo ao protocolo, eles fazem a opção natural pelo BrOffice.org.


LM» Você afirmou recentemente que em 2009 o Serpro iria promover treinamentos em ferramentas livres no governo, e que para isso seriam necessárias redes. Quais dessas redes já existem?


MM» Algumas já existem. Por exemplo, no BrOffice.org nós trabalhamos muito com o BrOffice Brasil. Outras estão em construção: estamos atuando nesse momento em parceria com cinco universidades federais com foco em ferramentas específicas. Com a Universidade Federal do Paraná estamos montando todo um processo de suporte e treinamento para bancos de dados livres; com a Universidade Federal de Pernambuco estamos trabalhando com ferramentas de reutilização de código e maturidade (desde análise de requisitos até a reutilização propriamente dita); estamos também trabalhando com mineração de dados com a Universidade Federal de Minas Gerais (Tamanduá); na Universidade Federal do Rio de Janeiro estamos trabalhando com a modelagem de dados. Estamos ampliando nossa rede para obtermos mais conhecimentos no mundo do Software Livre, pois o suporte depende cada vez mais de nós.


LM» Existe também interação com empresas privadas?


MM» Em dezembro, num evento no Rio de Janeiro, vamos colocar nossas ferramentas de desenvolvimento à disposição de comunidades externas. Nosso framework de geração de código Java, por exemplo, chamado 14 bis e derivado do Pinhão da Celepar. O nome é uma homenagem a Santos Dumont, cuja obra (o Demoiselle) foi disponibilizada em 1909 para quem desejasse alterar e utilizar para qualquer outro fim.


Vamos fazer o mesmo com nossa ferramenta de gestão de projetos, o E-Car, que hoje tem comunidades de governo e será aberta também a empresas privadas. A idéia é que o governo federal tenha mais ferramentas de TI para controle de custos e processos principalmente com a crise financeira mundial que terá conseqüências importantes no próximo ano.


Nossa lógica não é sempre termos que gerar o código, mas gerar renda dentro do país.


LM» Quais foram as maiores conquistas e dificuldades do Serpro e do Comitê de Implantação de Software Livre ao longo de 2008?


MM» No caso do Serpro, foi a opção que tínhamos de não trabalhar com software básico. Fomos obrigados a reverter essa opção, pois não tínhamos na empresa pessoas especialistas em sistemas operacionais, bancos de dados etc. O maior desafio, então, foi desenvolver a capacidade para que nossos funcionários voltassem a trabalhar com software básico. Descobrir aqueles que se encontravam em outros projetos para trazê-los ao desenvolvimento de software básico foi um desafio. Por último, construir essas ferramentas também foi difícil, mas conseguimos fazê-lo em um ano.


Entre as conquistas, a nova ferramenta de declaração do imposto de renda usada em 2008 foi marcante, assim como a criação de um modelo de governança dos softwares que desenvolvemos junto a órgãos públicos de outras esferas. Tudo isso foi feito sem qualquer prejuízo ao processo que já estava em andamento.


LM» Em relação à ferramenta de declaração do imposto de renda, existe alguma previsão para transformá-lo em Software Livre?


MM» Como ele é uma mistura de diversas ferramentas, há a questão legal dos códigos. Tão logo isso esteja resolvido, não há dificuldades para disponibilizá-lo.


LM» Após o intenso planejamento em 2008, quais dificuldades você prevê nas ações do próximo ano?


MM» Prevejo as dificuldades naturais a uma mudança de cultura. Na realidade, eu assumo parte da culpa, pois sempre mostramos bastante a questão da economia, debatemos muito sobre a questão da qualidade técnica dos produtos, mas acho que a principal chave foi pouco abordada: é a mudança de postura, de produtos adquiridos (software proprietário) para algo que vamos compartilhar e construir juntos (Software Livre).


Nesse sentido, mesmo dentro do universo do Software Livre, é muito comum nos vermos em comparações que pertencem, na realidade, ao modelo de software proprietário, como afirmar que um software “não faz algo”, em vez de “ainda não faz isso”. Por conta dessa postura, muitas vezes são iniciados projetos a partir do zero simplesmente porque não há alternativa livre que realize uma das funções desejadas para o software. Temos um exemplo disso, que foi o desenvolvimento de uma solução (Carteiro) de email, calendário, agenda e catálogo de endereços. Já existia o Expresso, que também era um software livre, e que realizava as mesmas tarefas.


Colaborar e participar de uma comunidade seria a melhor opção, pois teríamos uma evolução muito mais rápida e um salto de qualidade. Essa mudança de postura é o grande diferencial.


Santos Dumont, usando idéias de vários especialistas da sua época, precisou de apenas um ano para desenvolver o 14 bis, enquanto os irmãos Wright --- que não permitiram o uso de suas idéias --- levaram dez. Por isso, o brasileiro liberou também os conhecimentos sobre sua criação.


LM» Em caso de mudanças políticas na esfera federal, é possível que mude também a estratégia do governo para o Software Livre. Nesse caso, existem medidas no sentido de coibir um possível retorno ao favorecimento do software proprietário?


MM» Muitas pessoas falam isso, mas acho que nada na sociedade é “sem retorno”. Acredito que, se esse grupo político toma atitudes que beneficiam a sociedade, os outros grupos utilizarão essa estratégia tanto quanto nós --- mas talvez falando menos. Ninguém trocaria o Apache por uma ferramenta proprietária.


Não acredito que existam situações sem retorno.


LM» Uma das maiores carências do Software Livre no Brasil, hoje, é o ecossistema em torno das soluções. Porém, com órgãos públicos desenvolvendo softwares internamente, eles talvez não ajudem a solucionar isso. Como o Serpro pode promover melhorias nesse quadro?


MM» Acredito que a demanda atual por tecnologia é tão grande que nem todos os órgãos federais juntos conseguiriam supri-la. Então, teremos muitas contratações em 2009. Vamos nos integrar também à iniciativa privada através de uma maior abertura e facilitação do processo de contratação de serviços externos em Software Livre.


O que queremos evitar é a dependência de soluções. Acho que veremos importantes mudanças no ecossistema no próximo ano.


LM» Qual o impacto da crise financeira mundial sobre a indústria de software, especificamente sobre a indústria brasileira de Software Livre?


MM» Creio que teremos uma pressão de demanda, pois os gastos precisarão de mais controle --- refletindo-se em investimentos em tecnologia ---, a geração de receita terá de ser aumentada e os processos precisarão ser acelerados. Tudo isso deverá ser feito de forma equilibrada, ou seja, será necessário gastar menos com soluções que vão gerar mais renda.


Por isso, será importante para a nossa indústria local produzir Software Livre e ser referência nessa área.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Teste seu site com o IPOK


Por Pablo Hess
Publicado em 28/11/2008

Este artigo foi visualizado 6696 vezes.

Versão para impressão Enviar por email



Por Fernando Bertasso



Há algum tempo, os usuários interessados em ferramentas de DNS, análise de domínio, checagem de DNS reverso, pesquisa em blacklists etc., tinham alguns poucos sites a sua disposição. Os resultados muito técnicos e a pouca fluência no inglês dificultavam a conclusão do usuário, se havia ou não algum problema efetivamente.



Eis que surge dessa demanda o site IPOK, uma alternativa nacional e pioneira desse conjunto de ferramentas, que todo usuário que possua um domínio deveria ter em seus favoritos.



A principal ferramenta é o DNS Report. Ela analisa diversos serviços atrelados ao seu domínio: servidores DNS, de email, web etc. No total, mais de 30 testes são realizados, entre identificação de servidores, conexão e análise de respostas etc. Ao final, é apresentado um relatório com informações, erros de configuração (se houver), avisos e sugestões de melhoria.



Além do DNS Report, diversas outras ferramentas estão disponíveis: teste de DNS reverso, pesquisa em blacklists, cálculos de sub-rede e outras. O site ainda tem uma lista de ferramentas em desenvolvimento. As próximas a serem liberadas serão a de análise específica para servidores de email e uma ferramenta de proxy para testes de websites, simulando uma conexão externa.



A idéia vai além, pois por meio do IPOK será possível criar uma base de testes que “certificam” as configurações do domínio, servidores e configurações. O objetivo é criar uma espécie de “selo de qualidade”, atestando que as configurações mínimas foram realizadas e funcionam adequadamente.



Datacenters, empresas de hospedagem de websites e prestadores de serviços poderão anexar o relatório final como documentação para seus clientes, gerando maior confiança e transparência no serviço, além de poderem detectar e corrigir previamente qualquer problema que tenha passado despercebido.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Rodando o Snort: Preliminares


Por Pablo Hess
Publicado em 25/11/2008

Este artigo foi visualizado 9814 vezes.

Versão para impressão Enviar por email



Por Alexandre Teixeira

O principal objetivo deste artigo é apresentar de forma bem clara os requisitos mínimos para utilização do Snort em um ambiente simples, com apenas um sensor, utilizando as ferramentas auxiliares mais conhecidas. Não serão apresentados detalhamentos, mas direcionamentos, com intuito de eliminar a “nuvem” que aparece ao tentar o primeiro contato com esse NIDS – Network Intrusion Detection System.


A versão atualizada deste documento assim como outros artigos e dicas poderão ser encontrados no site da comunidade Snort no Brasil: http://snort.org.br.


O Caminho das Pedras


Serão listadas abaixo as etapas que envolvem as decisões mais importantes para implantação correta do Snort, mas sem muito detalhamento – isso poderá ser exposto em futuros artigos. A ordem da realização das etapas poderá mudar ligeiramente, dependendo do ambiente e da disponibilidade dos recursos. Essas etapas, quando bem executadas, tornam o aprendizado e o primeiro contato com o Snort mais fáceis.


Sistema operacional


Essa é uma etapa importante. O Snort pode rodar em plataformas específicas de hardware, como é o caso dos appliances da Sourcefire [1] – entretanto, usuários iniciantes utilizarão para aprendizado ou testes no ambiente de trabalho máquinas Intel, na maioria das vezes. Logo, deve-se escolher um sistema operacional com o qual o usuário tenha o mínimo de conhecimento. O autor sugere a utilização de Linux devido ao grande número de referências e documentação específica para este SO na Internet.


Neste ponto, também se define qual tipo de pacote de instalação será utilizado. No caso do Linux, recomenda-se a instalação do pacote padrão da distribuição, ou seja, caso o usuário utilize CentOS recomenda-se a instalação do pacote RPM referente ao software Snort dessa distribuição.


Armazenamento de Eventos


O Snort oferece várias maneiras de armazenar os logs dos dados de eventos gerados pelo IDS: em arquivo texto ou binário e nos banco de dados SQL listados abaixo:


  • PostgreSQL;
  • MySQL;
  • UnixODBC;
  • MS SQL Server;
  • Oracle.

A opção de arquivo binário é sugerida para cenários mais avançados, onde o Snort necessita de maior desempenho ao armazenar e processar os eventos. Para ler mais detalhes sobre essa solução, Alejandro Flores escreveu um ótimo artigo sobre o tema: “Implementando o Barnyard com Snort”. O artigo está disponível na seção de documentos do site [2].


Recomenda-se a escolha de qualquer base SQL, assim como no caso da escolha de SO, de acordo com o nível de conhecimento do usuário e a disponibilidade da utilização. Essa configuração é feita através do parâmetro output database do arquivo de configuração.


Implementação e Localização do Sensor


O sensor é tratado como uma interface ou ponto de entrada de dados capturados. Todo evento detectado pelo Snort é associado a um sensor, que basicamente é encarado pelo SO como uma interface em “modo promíscuo” conectada a um dispositivo de rede. Nesse modo, a placa de rede repassa ao SO todo o tráfego recebido, incluindo dados não direcionados ao endereço da placa de rede onde se localiza o sensor.


Dessa forma, a localização dos sensores é um dos principais pontos a serem definidos na arquitetura do sistema de detecção. A melhor localização é encontrada ao se responder a pergunta: O que se deseja monitorar? A resposta para essa questão pode ser bem ampla como a própria pergunta: tudo. No entanto, quanto maior o tráfego na rede e a quantidade de servidores, aplicações e usuários, maior será o consumo de recursos do IDS: processamento, espaço em disco e memória etc., sem contar o custo de administração e tuning.


Assim, quanto mais específico, melhor, ou seja, mais fácil será configurar o ambiente para obter os resultados esperados. O NIDS pode ter um fim específico, desde o monitoramento de invasões e atividades maliciosas ao auxílio na depuração de problemas de rede.


Dentre as aplicações e motivações para implementação do NIDS, podemos destacar:


  • Detecção de ataques com origem na Internet, incluindo probes ou portscans, worms e ataques direcionados (pentesting);
  • Utilização indevida da Internet (downloads, covert channels, vazamento de dados);
  • Geração de relatórios estatísticos (protocolos e serviços mais utilizados, incluindo tentativas de acesso ou verificação);
  • Capacity Planning;
  • Detecção de falhas de rede tais como interfaces com mau funcionamento, falha de arquitetura de rede (STP, roteamento etc.);
  • Detecção de utilizadores de software legado ou aplicações que serão desativadas;
  • Engenharia reversa de protocolos de comunicação;
  • Auxílio na aplicação e gerenciamento de regras de Firewall;
  • Identificação passiva de ativos de tecnologia.

Nos cenários acima, é comum se utilizar o sensor nos segmentos internos (redes específicas ou corporativas) ou nos ambientes externos (Internet, DMZ etc.). Não cabe aqui, no entanto, definir em qual segmento deverá ser implantado um sensor, mas apenas auxiliar na decisão, que dependerá de cada caso ou objetivo.


Vale lembrar que o sensor pode rodar em um único servidor ou máquina com fins específicos, sem necessidade de interface de rede em modo promíscuo. Um exemplo disso é um laboratório virtual para desenvolvimento de aplicações que se comunicam em rede.


Dependendo da aplicação, a localização do sensor pode inviabilizar a produção de eventos necessários ou ainda prejudicar o tuning ou a configuração para produzir tais eventos de maneira mais eficiente. Os cenários mais comuns utilizam port mirroring (espelhamento de portas) do switch ou hubs unindo os segmentos a serem monitorados. Além destes, existe ainda o mecanismo chamado network tap. Todos eles possuem características diferentes que influenciam diretamente no poder de vazão dos dados e, conseqüentemente, na performance da solução.


Recomenda-se a pesquisa e leitura sobre esse assunto, pois os métodos empregados fogem do propósito deste artigo. Na Internet existe muito material a respeito. Palavras-chave: network tap, port mirror, ids sensor.


Console para Visualização dos Eventos


Para o funcionamento do Snort é necessário basicamente uma biblioteca de captura de pacotes na rede, o driver da placa de rede e o próprio Snort, que é essencialmente um sniffer.


Entretanto, para armazenar os dados em uma base de dados SQL, é necessário uma API para que os eventos sejam armazenados em um banco de dados (que pode, inclusive, rodar na mesma máquina). Para visualizar os eventos, é necessário um software que apresente de forma simples os eventos persistidos na base de dados. Para configurar os parâmetros do arquivo snort.conf, pode-se utilizar outro software e assim por diante, cada software adicional com uma finalidade específica, como é o caso do Barnyard, já citado aqui.


Dos principais softwares para visualização dos eventos destacam-se o Acid, agora chamado de BASE. Ele necessita de um servidor web, pois disponibiliza as informações através de scripts escritos em PHP. Mais detalhes podem ser encontrados no site do projeto [3].


Existem outras consoles que podem ser baixadas do próprio site do Snort [4].


Mais pedras no caminho – erros durante a instalação


Após a verificação das etapas acima, o comando abaixo deve funcionar. Caso contrário, inicia-se a etapa de depuração de erros:


snort -i eth0 -T -N -u snort -g snort

Nesse caso, o Snort irá carregar o software necessário para capturar pacotes pela interface eth0 (parâmetro -i) apenas como teste (parâmetro –T) sem logar pacotes (-N) e utilizando as credenciais de usuário e grupo específicos do Snort para executar o processo snort.


Caso esteja tudo configurado corretamente, a saída abaixo será mostrada:



Running in packet logging mode
Log directory = /var/log/snort

--== Initializing Snort ==--
Initializing Output Plugins!
Verifying Preprocessor Configurations!
Decoding LoopBack on interface eth0

--== Initialization Complete ==--

,,_ -*> Snort! <*-
o" )~ Version 2.8.3.1 (Build 17)
'''' By Martin Roesch & The Snort Team: http://www.snort.org/team.html
(C) Copyright 1998-2008 Sourcefire Inc., et al.
Using PCRE version: 6.6 06-Feb-2006


Snort sucessfully loaded all rules and checked all rule chains!
Snort exiting

Se a saída apresentar algum erro ou não se parecer com o conteúdo mostrado acima, utilize o Google para encontrar a solução, colocando na caixa de busca o erro entre aspas. Exemplo:



Initializing Network Interface eth0
ERROR: OpenPcap() FSM compilation failed:
syntax error
PCAP command: snort
Fatal Error, Quitting...

Basta inserir no campo busca o texto “ERROR: OpenPcap() FSM compilation failed:” que serão apresentados vários links para fóruns e FAQs que discutem possíveis soluções. Outra opção é se cadastrar na lista de discussão do Snort-BR [5] para que outros usuários possam ajudá-lo.


Tuning – Arquivo de configuração Snort.conf


Enquanto essa etapa não funcionar, não há motivo para alterar ou editar o arquivo de configuração do Snort, snort.conf. Este só deve ser modificado após o Snort iniciar corretamente.


Essa etapa pode ser considerada como final no processo, apesar de ser constante, pois é aqui que são tratados os famosos eventos falsos positivos. Além disso, é nesse momento que o usuário irá fazer as seguintes etapas:


  • Configuração de banco de dados (decisão apresentada acima);
  • Configuração de pré-processadores;
  • Configuração das variáveis (HOME_NET principalmente);
  • Configuração de assinaturas;
  • Configuração de módulos e plugins.

Dos pontos apresentados acima, o mais importante sem dúvida é a configuração de variáveis de ambiente, motivo pelo qual será abordado neste artigo.


Variáveis do Arquivo Snort.conf


No arquivo de configuração do Snort – snort.conf – existem várias variáveis que serão utilizadas, principalmente, na montagem das assinaturas. Logo, conclui-se que seu valor irá influenciar diretamente o comportamento do sensor, seja ao gerar eventos incorretos demais (falsos positivos) ou ao deixar de gerar eventos desejáveis, intrusões, ataques e outros eventos que se deseje monitorar.


A principal variável é HOME_NET, que deve ter como valor uma ou mais redes ou hosts a serem monitorados. Assim, caso essa variável seja mantida com o valor padrão (any - qualquer), qualquer IP será tratado como monitorado pelo Snort, o que irá gerar mais eventos e, conseqüentemente, mais falsos positivos e outros eventos indesejáveis.


Um evento é qualquer log gerado pelo Snort. Ele pode ser uma simples informação (uma consulta DNS) ou um ataque (pacote ICMP suspeito), ou ainda um indício de intrusão ou invasão (saída de um comando de listagem em um pacote HTTP).


Nesse contexto, faz algum sentido um ataque HTTP em direção a um servidor DNS? Pode ser que sim, caso seu sensor tenha como finalidade gravar todos os eventos para fins estatísticos; ou não, dada a quantidade de eventos e o conhecimento do analista de segurança acerca da arquitetura de firewall e servidores, só se faz necessário gerar alertas que envolvam conexões que realmente podem existir, com começo e fim.


Na prática, isso é configurado através das variáveis ou através da edição ou criação de regras de exclusão específicas (tópico um pouco mais avançado). No exemplo acima, trata-se da variável HTTP_SERVERS, que é utilizada nas assinaturas que geram alertas ou eventos de conexões ou ataques envolvendo o protocolo HTTP, geralmente implementado nas portas 80 e 443.


O ideal é testar pelo menos os valores das variáveis HOME_NET e EXTERNAL_NET, pois elas são utilizadas pela maioria das assinaturas. Com isso, verifica-se o comportamento no cenário utilizado. Uma boa prática, aplicável na maioria dos cenários, é definir um valor específico para HOME_NET e configurar o valor da variável EXTERNAL_NET para “tudo menos as redes definidas na variável HOME_NET”, ou seja, o valor ! $HOME_NET. Novamente, isso dependerá do seu cenário e deverá ser avaliado, de acordo com a necessidade.


Essas explicações servem apenas de incentivo ao leitor para utilizar de maneira eficiente as funcionalidades disponíveis no Snort. Qualquer modificação, seja em regras, pré-processadores ou variáveis, poderá influenciar no número de eventos gerados pelos sensores.


Manutenção e Atualização de Assinaturas ou Regras


Este é um dos tópicos mais polêmicos em relação ao Snort. Mesmo sendo um dos poucos NIDS que disponibilizam e permitem a total customização de regras, alguns usuários ainda não concordam com a metodologia utilizada pela empresa que mantém o Snort.


As assinaturas desenvolvidas pela equipe da empresa somente são disponibilizadas à comunidade (usuários registrados no portal do Snort) após 30 dias, pois são distribuídas sob a licença da equipe de desenvolvedores da Sourcefire – VRT (Vulnerability Research Team). Os detalhes da licença e da distribuição são apresentados em [6]. Esse é outro tópico que merece um artigo específico. Mais informações poderão ser encontradas nos links [7], [8] e [9]. O processo de atualização de assinaturas pode ser automatizado, e existem ferramentas específicas para esse fim, como o Oinkmaster [10].


Sobre o Autor


Alexandre Teixeira (alexandre.abreuΘgmail.com) é analista de segurança e especialista em soluções Open Source. Atualmente, trabalha em uma grande empresa do setor de telecomunicações. Possui as certificações SSCP, GCUX, RHCE, LPIC-2, SnortCP e outras. Dúvidas ou sugestões podem ser enviadas para seu email.


Links deste artigo


[1] Sourcefire: http://sourcefire.com


[2] Documentação no site do Snort: http://www.triforsec.com.br


[3] BASE: http://base.secureideas.net/


[4] Interfaces para o Snort: http://snort.org/dl/contrib/front_ends/


[5] Lista de discussão do Snort-BR: http://snort.org.br/index.php?option=com_content&task=blogcategory&id=19&Itemid=27


[6] Licença e distribuição de assinaturas: http://www.snort.org/about_snort/licenses/vrt_license.html


[7] Regras Oficiais: http://www.snort.org/vrt/


[8] White Hats: http://www.whitehats.com/ids/


[9] Emerging Threats: http://www.emergingthreats.net/


[10] Oinkmaster: http://oinkmaster.sourceforge.net/




Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Ardour: Áudio profissional para Linux


Por David Dasenbrook
Publicado em 10/11/2008

Este artigo foi visualizado 7212 vezes.

Versão para impressão Enviar por email



Há poucos anos, os estúdios de gravação precisavam de uma enorme área para acomodar impressionantes e caros gravadores multipista, mixers e pilhas de equipamentos de produção de efeitos. Atualmente, isso tudo cabe em um PC normal.


Melhores, mas nem por isso maiores, são computadores com hardware e software adaptados para as necessidades do estúdio musical, criando as chamadas Workstations de Áudio Digital.


Enquanto as soluções proprietárias geralmente custam muito dinheiro e, via de regra, estão disponíveis apenas para Windows ou Mac OS, a comunidade Linux se esforçou enormemente nos últimos anos para preparar o sistema operacional livre para o trabalho no campo do áudio profissional. Um dos projetos mais interessantes é o software livre Ardour.


Clique aqui para ler o PDF da matéria que mostra como usar o Ardour e o sistema de baixa latência Jack.




Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Pascal + GTK


Por Luiz Fernando “Zendrael” Estevarengo
Publicado em 02/10/2008

Este artigo foi visualizado 7482 vezes.

Versão para impressão Enviar por email



Por Luiz Fernando “Zendrael” Estevarengo



Ok, você leu o título deste artigo e deve estar pensando: “Putz! Pascal não!” – mas calma, leia as próximas linhas que tenho certeza que serão interessantes. Senão como programador, leia como curioso!



A linguagem Pascal nasceu com o intuito de ensinar a programar. Com sua sintaxe simples e objetiva, é utilizada até hoje por muitas instituições de ensino e normalmente acompanha os primeiros passos da maioria dos programadores; e em alguns casos, acompanha os passos até hoje. É errôneo dizer que “Pascal só serve pra fazer programas para o DOS” ou “Pascal só é bom no Delphi”... isso demonstra desconhecimento do nível da linguagem e das possibilidades ligadas a ela.



Vamos falar um pouco dessas possibilidades: hoje, através do compilador FreePascal podemos desenvolver aplicações compiláveis em diversas plataformas, entre elas o Windows (XP, Vista, CE), Mac OS X, GNU/Linux, *BSD e até mesmo GameBoy Advance (e há em desenvolvimento uma biblioteca para Nintendo DS também). Pois bem, e como alternativa ao Delphi e ao Kylix, temos o Lazarus cuja filosofia é “Write once, compile everywhere” – escreva uma vez, compile em qualquer lugar – o que demonstra quão avançado está o velho Pascal em relação ao que normalmente se conhece dele. Mas o foco aqui é a combinação Pascal + GTK certo? E o que tudo isso tem a ver? Simplesmente que a união de uma das mais simples linguagens de programação com uma das mais conhecidas bibliotecas gráficas permite escrever aplicações compiláveis multiplataforma! Duvida da facilidade? Ok, então mãos ao teclado e vamos lá!



Vou supor que você já tenha o compilador FreePascal instalado em sua máquina e as respectivas bibliotecas necessárias. A saber, se estiver em uma distribuição Debian GNU/Linux ou derivada, os pacotes são: fpc e fp-units-gtk2. Outras distribuições devem conter os respectivos pacotes em seus repositórios. Se você não achou, pode visitar o endereço www.freepascal.org e procurar o link de download.



Abra seu editor de texto preferido e digite o seguinte código (a explicação de cada linha vem em seguida):



program exemplo_1;

uses glib2, gtk2;

var
pJanela : PGtkWidget;
pLabel : PGtkWidget;

begin
gtk_init(@argc, @argv);

//criando widgets
pJanela := gtk_window_new(GTK_WINDOW_TOPLEVEL);
pLabel:= gtk_label_new( 'Pascal + GTK2' );

//configurando propriedades
gtk_window_set_title( GTK_WINDOW( pJanela ), 'Exemplo simples');

//empacotando
gtk_container_add( GTK_CONTAINER( pJanela ), pLabel );

//mostrando tudo
gtk_widget_show_all( pJanela );

//iniciando loop
gtk_main();
end.



Antes, deixe-me dizer que você vai apenas visualizar uma janela sendo aberta com um rótulo dentro, nada demais. É só um simples exemplo, ok? Depois mostrarei outras coisas. A idéia agora é entender como isso funciona.



Na primeira linha, iniciamos nosso programa da forma padrão de qualquer aplicação em Pascal e em seguida chamamos as bibliotecas que serão utilizadas:



program exemplo_1;

uses glib2, gtk2;



Na seção var declaramos nossos objetos. Se você está acostumado com linguagens dinamicamente tipadas como Python ou PHP, pode achar estranho ter de declarar cada objeto da interface, mas, assim como em C, isso é de grande valia e, em termos de organização de código, é sempre bom manter as coisas nos seus lugares corretos e não “jogados” em qualquer lugar do fonte. Para cada objeto em nossa aplicação, dizemos que ele é do tipo pGtkWidget, que nada mais é que um ponteiro (sem desespero!) para um objeto GTK.



var
pJanela : PGtkWidget;
pLabel : PGtkWidget;



Em seguida, iniciamos o bloco principal da aplicação (como o main() de C) e iniciamos o GTK com os parâmetros passados para nossa aplicação, caso eles existam.



begin
gtk_init(@argc, @argv);



Agora, vamos começar a criar nossos objetos. Em uma única linha criamos a janela principal de nossa aplicação e dizemos, com o parâmetro que a função recebe, que se trata de uma janela do tipo “normal” – isso porque existe outro tipo, o popup (uma janela sem bordas ou controles do gerenciador de janelas). E na linha seguinte, criamos o GtkLabel que vai ficar dentro dela já passando seu conteúdo como parâmetro também:



//criando widgets
pJanela := gtk_window_new(GTK_WINDOW_TOPLEVEL);
pLabel:= gtk_label_new( 'Pascal + GTK2' );



Depois disso, configuramos os widgets da maneira que acharmos necessária. Aqui estamos definindo o título da janela e depois colocando o rótulo dentro dela:



//configurando propriedades
gtk_window_set_title( GTK_WINDOW( pJanela ), 'Exemplo simples');

//empacotando
gtk_container_add( GTK_CONTAINER( pJanela ), pLabel );



Moleza, até agora, não? O próximo passo é exibir a janela. De nada adianta criar uma janela e não exibi-la. Para isso, usamos a função gtk_widget_show_all(), que mostra a janela (passada como parâmetro) e todo o conteúdo que estiver dentro dela:



//mostrando tudo
gtk_widget_show_all( pJanela );



Por fim, basta iniciar o loop principal do GTK e finalizar o bloco principal do programa:



//iniciando loop
gtk_main();
end.



Para compilar, basta utilizar o comando:



$ fpc nome_do_programa.pas



E rodar a aplicação com:



$ ./nome_do_programa



Há, claro, muito mais coisas envolvidas em se criar uma aplicação dessa forma, como os contêineres do GTK, as funções para definir e consultar propriedades dos objetos etc. Porém, antes que você desista de estudar o Pascal+GTK por sua complexidade (ou preguiça de digitar os códigos para criar os objetos gráficos), vamos a um recurso muito útil: o Glade. Glade é uma aplicação muito conhecida de quem desenvolve programas com GTK. Ele é uma ferramenta RAD (Rapid Application Development – Desenvolvimento Veloz de Aplicações) que auxilia na criação das interfaces da aplicação. Vamos fazer um teste?



Primeiro, vamos baixar o Glade: mais uma vez, em sua distribuição deve existir o pacote glade ou glade-3 (última versão). Se você não encontrar, procure em http://glade.gnome.org.



Depois de instalado, abra a aplicação e brinque como quiser, posicione qualquer objeto na tela, dimensione etc. Não vou explicar como se faz isso pois esse não é o foco de nosso artigo nesse momento. Salve seu arquivo .glade na mesma pasta onde estiver o fonte da aplicação que estamos criando e vamos nos concentrar na programação:



program exemplo_2;

uses glib2, gtk2, libglade2, sysutils;


var
arquivo_glade : PGladeXML;


begin
gtk_init(@argc, @argv);

//carrega arquivo glade
arquivo_glade := glade_xml_new( Pchar( '/arquivo.glade' ), nil, nil);

//iniciando loop
gtk_main();
end.



O leitor deve ter observado que são necessárias menos linhas de código para se utilizar uma interface externa (com N objetos) e somente uma variável para ela. Na verdade, o Glade gera um arquivo em formato XML contendo a especificação de cada objeto GTK criado. Por exemplo, seu tamanho, posição, nome etc. Isso também é útil para que possamos separar, em nossa aplicação, a interface da lógica envolvida. O próprio GTK se encarrega de processar o arquivo XML da interface e criar os objetos.



Note que o início da aplicação é o mesmo, à exceção da declaração de duas novas bibliotecas: libglade2 – responsável por tratar os objetos Glade – e sysutils – utilizada para fornecer algumas funções necessárias (como Pchar();, por exemplo):



program exemplo_2;

uses glib2, gtk2, libglade2, sysutils;



Ao invés de declararmos objetos da interface, declaramos apenas um ponteiro para o arquivo XML gerado pelo Glade:



var
arquivo_glade : PGladeXML;



Em seguida, iniciamos normalmente a aplicação e criamos a interface a partir do XML. Utilizamos o Pchar para converter a string do caminho da interface:



begin
gtk_init(@argc, @argv);

//carrega arquivo glade
arquivo_glade := glade_xml_new( Pchar( '/arquivo.glade' ), nil, nil);

E, por fim, finalizamos a aplicação normalmente:

//iniciando loop
gtk_main();
end.



Se a interface criada contiver a definição da janela para ser mostrada normalmente, basta compilarmos o programa e executá-lo em seguida. Se nada aparecer, verifique se a propriedade “visível” da janela está marcada para “sim”:



$ fpc nome_do_programa_.pas
$ ./nome_do_programa



Olha só! Quem diria que ia ser tão fácil assim? Este artigo não abordou aspectos como sinais e callbacks, nem a utilização de bancos de dados. Eu apenas quis que o leitor despertasse a curiosidade e abrisse a mente para algo “novo” ou “não tão falado”. Essa mesma aplicação pode ser compilada sem problemas em plataformas que suportem o GTK sem a necessidade de se alterar uma linha sequer. Espero que o leitor tenha gostado e se anime a buscar mais informações sobre curiosidades e funcionalidades pouco conhecidas das linguagens de programação.



Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Lançado o KDE 4.1: uma análise do ambiente desktop


Por Rafael Peregrino da Silva
Publicado em 29/07/2008

Este artigo foi visualizado 7104 vezes.

Versão para impressão Enviar por email



A tão esperada versão 4.0 do KDE não foi poupada de críticas — apesar dos avisos de que a versão deveria ser considerada uma technology preview. Os desenvolvedores do sistema recomendaram aguardar pelo KDE 4.1 — o que, como mostraremos nesta análise, parece ter sido uma decisão acertada: a nova versão impressiona pelas melhorias na estabilidade e se mostra mais madura.



Por Kristian Kißling e Rafael Peregrino da Silva



Entretanto, nem tudo é perfeito ainda: quem estiver procurando por uma versão estável do KDE, deve continuar trabalhando com a versão 3.5. O novo KDE 4.1 nos passa a impressão de ser um bom sistema em versão preliminar: estável, mas ainda com algumas falhas de implementação.



Por outro lado, aquilo que já está funcionando, impressiona! E isso já a partir da tela de abertura, passando por programas como o Gwenview e o Dolphin, para desembocar nos Plasmoids (ver figura 4), que parecem estar funcionando muito melhor, sem nos esquecermos dos efeitos visuais integrados ao desktop. De acordo com Dirk Müller, release manager do projeto, separam as versões 4.0 e 4.1 do KDE nada menos que 20.803 modificações somente no ambiente desktop, sem contar as 15.432 alterações no repositório de traduções.



Graças aso novos ícones, ao desktop baseado em tecnologia Plasma e ao novo "menu iniciar" do sistema, o KickOff (ver figura 5), a interface gŕafica do KDE 4.1 possui uma aparência mais elegante e bem acabada que a do seu antecessor (a versão 3.5) — alguns diriam também mais "soturna". O desktop no KDE 4 é gerenciado por tecnologia Plasma, que lança mão do Webkit da Apple para funcionar. Com isso, é possível usar os Dashboards do Mac OS X no KDE 4.



Quem girasse um plasmoid na versão 4.0.0 do KDE, acabaria invariavelmente com um ambiente desktop totalmente travado nas mãos. No KDE 4.1 a grande maioria dos plasmoids padrão do sistema e o próprio desktop funcionam corretamente, de maneira estável, com bom desempenho e usando os recursos do hardware "com moderação" — justiça seja feita, graças ao uso da versão 4.4 da Qt, biblioteca da Trolltech que historicamente forma a base do KDE.



Proprietários de placas de vídeo da marca Nvidia vão precisar de uma mãozinha para colocar o KDE em operação corretamente. O KDE TechBase traz uma série de dicas para configurar placas desse fabricante. Em nosso laboratório, tanto placas de vídeo da Intel quanto da AMD/ATI funcionaram corretamente e com bom desempenho.











Figura 1: A aparência elegante da nova tela de abertura do KDE 4.1 impressiona.



Na contramão do desejo largamento disseminado entre usuários de deixar seus arquivos espalhados na área de trabalho, os desenvolvedores haviam vetado essa opção na nova versão do KDE. O novo applet de nome Folder View, através do qual uma área específica dentro da área de trabalho é criada com essa finalidade, preencheu essa lacuna. O funcionamento desse applet é ilustrado no vídeo a seguir:











Vídeo 1: Funcionamento do applet Folder View.



Além disso, o framework Plasma confere ao KDE efeitos visuais avançados, semelhantes àqueles que usuários de Linux estão acostumados a ver no Compiz, e que podem ser ativados/desativados via Administração do Sistema | Ambiente de Trabalho. Após ativá-los, basta pressionar as teclas [Alt] + [Tab] para observar as janelas que estiverem abertas desfilar em modo cover flow (no KDE, chamado de modo cover switch), conforme ilustra a figura 2.











Figura 2: O efeito cover switch em ação durante a alternação de aplicativos do KDE.



Mas não foi somente na interface com o usuário que ocorreram avanços: o novo framework multimídia do KDE, o Phonon, dispõe agora de suporte para o GStreamer, o DirectShow 9 e o QuickTime. O leitor deve estar se peguntando: "DirectShow? QuickTime? O que isso tem a ver com Linux?" Exatamente: o KDE 4.1 "roda" tanto no Windows® quanto no Mac OS X — apesar de em uma versão mais simples. Para encontrar arquivos e documentos com rapidez, o KDE 4.1 usa o aplicativo Strigi, que indexa documentos (PDFs, arquivos em geral, MP3 etc.) armazenados no disco rígido. O aplicativo Nepomuk, por sua vez, refina a busca, já que busca por conexões semânticas que tenham sido atribuídas pelos usuários aos seus arquivos. E finalmente há indícios de uso de um framework semântico: no gerenciador de arquivos Dolphin é possível por exemplo, inserir comentários em figuras e rotulá-las tematicamente, conforme ilustra a figura 3. No futuro, o Nepomuk deverá estender essa característica ao KDE 4 inteiro, transformando-o em um desktop semântico.











Figura 3: Com o gerenciador de arquivos Dolpin é possível criar vínculos semânticos para arquivos.



Finalmente os conhecidos aplicativos para gerenciamento de informações pessoais (PIM, do inglês Personal Information Management) fazem parte do KDE 4. O aplicativo Akonadi também foi incluído na nova versão: ele é o programa responsável por reunir informações (como, por exemplo, endereços) e fornecê-las como processo de fundo (i.e., em background) para os diferentes componentes dos aplicativos PIM.











Figura 4: O desktop do KDE 4.1, com plamoids e o novo menu de chamada rápida de aplicativos (o antigo "Executar Comando").



O gerenciador de arquivos Dolphin dispõe, além das abas de costume, de uma visão em árvore, e o Konqueror — sim, ele está de volta ao KDE 4 — ganhou o recurso "Copiar para" de volta ao seu menu de contexto. O reprodutor de mídia Dragon, é econômico em recursos, mas dá conta dos seus afazeres. Não espere muito dele no momento, já que ele não resiste à uma comparação com reprodutores de mídia mais maduros, como o Amarok, que caminha a passos largos na direção da sua versão 2.0. O visualizador de imagens Gwenview mereceu atenção especial dos desenvolvedores: o programa não só está com um visual renovado (e muito atraente, diga-se de passagem), como também é de fácil operação, tendo ganhado um navegador de imagens para o modo de exibição em tela cheia (ver figura 6). Além disso, o programa ainda permite desfazer modificações realizadas.











Figura 5: O "menu iniciar", do projeto KickOff, que pode ser também configurado para o modo de visão "convencional".



Quem desejar testar a nova versão do KDE, pode fazê-lo utilizando a versão em live CD criada por Stephan Binner. Basta baixar a imagem ISO, queimá-la em um CD e iniciar o sistema através dele, que nada mais é do que um live CD do Opensuse 11 com o KDE 4.1 como desktop padrão. Quem tiver interesse em instalá-lo, poderá encontrar com facilidade pacotes para a sua distribuição preferida. Os desenvolvedores já estão trabalhando na versão 4.2, que deve ser liberada para download — de acordo com o roadmap do projeto &mdash em janeiro de 2009.











Figura 6: O visualizador de imagens Gwenview é rápido, ganhou novos recursos e um visual atraente.




Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Acesso centralizado: PHP com autenticação via LDAP


Por Rafael Peregrino da Silva
Publicado em 08/06/2008

Este artigo foi visualizado 14318 vezes.

Versão para impressão Enviar por email



Não importa se o objetivo é escrever um aplicativo web próprio ou colaborar com uma solução de código aberto: armazenar as informações dos usuários em um diretório LDAP simplifica o gerenciamento do acesso entre diversos aplicativos, deixando a infraestrutura de TI mais consistente. A única coisa que faltava era a autenticação via LDAP...



Por Falko Benthin, Peter Kreußel e Rafael Peregrino da Silva



O LDAP é o padrão estabelecido quando se trata do armazenamento de informações de usuários e endereços e, nessa área específica, funciona de forma mais eficiente que um banco de dados. De outro lado, o PHP dispõe de uma API de comunicação com esse serviço de diretório, que é utilizada por algumas aplicações web — infelizmente uma minoria delas atualmente — para autenticação de usuários. Este artigo ilustra como programar uma conexão LDAP a aplicações PHP.



A versão do PHP utilizada deve ser compilada com a opção --with-ldap. Esse recurso pode, alternativamente, ser incluído como módulo. Qualquer que seja o caso, pode-se verificar se esse recurso está disponível usando a função phpinfo(), conforme mostra a figura 1. No repositório de extensões do PHP PEAR [1] há também a classe auth(), que simplifica a manipulação de dados via LDAP [2]. Além do suporte ao LDAP, essa classe também possibilita a autenticação via banco de dados, arquivos de senha etc. A listagem 1 ilustra como selecionar o LDAP como fonte de dados para autenticação.



A linha 2 faz a conexão da extensão PEAR. A linha 9 cria o objeto PHP necessário à realização de autenticação com os parâmetros da matriz (array) $options[] — o endereço e a porta do servidor LDAP (localhost, 389), a versão do protocolo LDAP que está sendo usada e o domínio LDAP de "base" (dc=j-hoch-3,dc=de).











Figura 1: Uma extensão conecta o LDAP ao PHP. A função phpinfo() informa se a extensão está compilada ou foi carregada como módulo.









Listagem 1:
Auth.php

01 <?php
02 require_once "Auth.php";
03 $options = array('host' => 'localhost',
04 'port' => '389',
05 'version'= 3,
06 'basedn' => 'dc=j-hoch-3, dc=de',
07 'userattr' => 'uid',
08 'useroc' => 'person');
09 $auth = new Auth('LDAP', $options,
10 $loginFunction = 'Nome da função',
11 $showLogin = true);
12 //Inicia autenticação
13 $auth->start();
14
15 if($auth->getAuth()){
16 //Código para usuários autentificados
17 }
18 else{
19 //Código para usuários não autentificados
20 }
21
22 //Desconectar usuário
23 $auth->logout();
24 ?>




Caso especial



A expressão 'useroc' => 'person' na linha 8 informa ao objeto Auth que os atributos da classe LDAP person devem ser usados na busca. Ela modifica o padrão, segundo o qual PEAR::Auth busca por dados na classe posixAccount, e que requer os campos gidNumber, homeDirectory e uidNumber. Como aplicações web não necessitam desses campos, a autenticação no exemplo anterior usa ao invés disso campo uid (User ID). Outras opções seriam o campo Common Name (cn) ou o Search Name (sn).



Se o parâmetro $showLogin na linha 9 tiver como valor true, a extensão PEAR produz automaticamente um formulário de login, caso o usuário ainda não esteja "logado" no sistema. Através de uma função, responsável pela criação do código HTML do formulário, pode-se fazer ajustes em sua aparência. É importante ressaltar que o formulário retorna o nome do usuário e a sua senha via $POST através dos campos username e password do formulário.



A listagem 2 mostra um arquivo LDIF (LDAP Directory Interchange Format), que é o formato no qual o LDAP arquiva seus dados. Ele contém dois usuários exemplo, entre eles aquele que possui as informações necessárias para autentificação. No exemplo, os dados de login são armazenados por dn:dc, uid e userpassword.









Listagem 2:
Arquivo LDIF

01 dn: cn=Falko Benthin,ou=editors,dc=j-hoch-3,dc=de
02 objectclass: top
03 objectclass: person
04 cn: Falko Benthin
05 sn: Benthin
06 uid: fbenthin
07 ou: editors
08 mail: fbenthin@j-hoch-3.de
09 l: Potsdam
10 postalcode: 14467
11 userpassword: segredo1
12
13 dn: cn=Hans Hein,ou=editors,dc=j-hoch-3,dc=de
14 objectclass: top
15 objectclass: person
16 cn: Hans Hein
17 sn: Hein
18 uid: hhein
19 ou: editors
20 mail: hhein@j-hoch-3.de
21 l: Potsdam
22 postalcode: 14467
23 userpassword: segredo2




A chamada do método $auth->start() na linha 13 da listagem 1 serve para instanciar o objeto Auth e autenticar um usuário. Para tanto, esse método realiza uma conexão anônima ao servidor LDAP e verifica se há uma entrada no diretório LDAP correspondente ao username fornecido no campo definido em userattr. Se houver exatamente uma pessoa cujos dados batam com o valor fornecido, Auth::start() tentará realizar uma conexão autenticada utilizando-se para isso do Distinguished Name e da senha inserida através do formulário.



Se todas as informações baterem, a sessão PHP do visitante do site é classificada como válida, e $auth->getAuth() passa a fornecer o estado true até a sessão do usuário expirar — conforme timeout configurado em php.ini — ou quando o próprio usuário deixar a sessão, através da chamada de $auth->logout(). A variável $username contém os nomes dos usuários que serão solicitados com mais freqüência pelas aplicações web em tempo de execução.



Próximos capítulos



Vimos que, com o módulo PEAR Auth, é fácil realizar autenticação consultando uma base LDAP. Entretanto, ainda falta alguma coisa para que uma aplicação web seja capaz de consultar a base LDAP: ainda é necessário substituir no código PHP as chamadas do método getAuth(), nas quais a aplicação verifica especificamente se o usuário ainda está logado no sistema. O mesmo vale para as partes do código, através das quais o programa lê os nomes dos usuários no banco de dados.



Qual será o nível de dificuldade desse tipo de alteração em um caso concreto, vai depender muito mais de o quanto a aplicação tenha sido desenvolvida de maneira estruturada e sistemática. Se o sistema tiver sido desenvolvido de modo que para a autenticação seja sempre realizada através de uma função ou método, então as modificações requeridas no código serão pequenas, e as dificuldades de alteração deverão ser mínimas. Aliás, esse é o método preferível em todos os casos, já que assim a aplicação poderá utilizar um sem-número de backends de sistemas de autenticação, que serão assim conectados ao sistema através de uma camada de abstração.



Um debugger (software de depuração de erros) que permita executar o código passo-a-passo, é uma boa ferramenta, para entender a aplicação. O mais confortável nesse caso para o PHP é o uso do Eclipse, com as extensões PHP Development Tools [3] e o debugger de executáveis [4] gratuito da empresa Zend (ver figura 2). Há também uma versão livre do debugger DBG [5], e o Xdebug está disponível para download e licenciado sob a licença PHP [6].











Figura 2: A combinação do Eclipse, das PHP Development Tools e do debugger da empresa Zend fornecem um ambiente bastante adequado de desenvolvimento, que facilita entender o funcionamento de aplicações web escritas em PHP.



Um exemplo real



A listagem 3 mostra um exemplo de código que não usa LDAP, por meio do qual o banco de dados de fotografias Photo Organizer 2.33 [7] verifica se o usuário já está ou não logado no sistema. Esse trecho de código fonte — muito freqüentemente anexado via include a sistemas de gerenciamento web de fotografias —, está no arquivo site.php, e mostra aquilo que um desenvolvedor interessado em ajustar o código fonte de uma aplicação web deveria procurar, para que o uso de LDAP passe a ser realizado: o Photo Organizer se utiliza para gerenciar a sessão do usuário de um cookie próprio (linha 1 da listagem 3). O resto do código ilustra a realização de uma consulta ao banco de dados após a filtragem dos dados através da função pg_escape_string().







Listagem 3:
Gerenciamento de sessão em
um Photo Organizer

01 if (isset($_COOKIE[$po_cookie])) {
02 $session_id = pg_escape_string($_COOKIE[$po_cookie]);
03
04 $res = pg_query($dbh, "SELECT identifier, type,
05 preferences, username, first_name,
06 last_name, password
07 FROM users
08 WHERE session_id='$session_id'");
09 if (($res != FALSE) && pg_num_rows($res)) {
10 $row = pg_fetch_assoc($res);
11 $po_user['id'] = $row['identifier'];
12 $po_user['type'] = $row['type'];
13 $po_user['session'] = $session_id;
14 $po_user['prefs'] = $row['preferences'];
15 $po_user['username'] = $row['username'];
16 $po_user['first_name'] = $row['first_name'];
17 $po_user['last_name'] = $row['last_name'];
18 $po_user['password'] = $row['password'];
19 }
20 }




Outras aplicações usam as funções de gerenciamento de sessões nativas do PHP, que trabalham ou com cookies ou com parâmetros fornecidos na URL. Uma sessão desse tipo é normalmente iniciada com session_start() ou através da opção de inicialização (fornecida através do arquivo .ini) session.auto_start, que pode ser alterada em tempo de operação.



Referências





Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

Análise do novo Ubuntu Server 8.04 LTS


Por Rafael Peregrino da Silva
Publicado em 24/04/2008

Este artigo foi visualizado 8333 vezes.

Versão para impressão Enviar por email



Por Mathias Huber e Rafael Peregrino da Silva





O projeto Ubuntu liberou hoje a versão 8.04 de sua distribuição. Os administradores de sistemas devem olhar com atenção a versão para servidor: o Ubuntu Server 8.04 (codinome Hardy Heron). É uma distribuição Linux corporativa, para qual o fabricante oferece suporte e atualizações de longo prazo (o famoso Long Term Support — LTS), o que significa pelo menos 5 anos de “tranqüilidade”.



O suporte comercial à distribuição é oferecido pela Canonical. Na página da empresa podem ser encontrados o e-mail e telefone de suporte para contato. Todas as atualizações e correções de falhas relativas à segurança poderão ser baixadas gratuitamente através do sistema de administração de pacotes da própria distribuição.



O novo Ubuntu Server oferece suporte às arquiteturas Intel x86 e AMD64. A instalação base do sistema, que é derivada do Debian, é capaz de operar num computador com 128 MB de RAM. Apesar disso, essa configuração mínima não é recomendada para fins práticos, principalmente em servidores. Recomenda-se que o sistema seja instalado num computador com no mínimo 512 MB de RAM. Um sistema típico utiliza, após instalação, cerca de 500 MB de espaço no disco rígido.



Instalação ágil



A instalação em modo texto funciona de forma simples e descomplicada. Usuários acostumados com o Debian deverão se sentir à vontade. Entretanto, em relação ao Debian, o procedimento de instalação do Ubuntu Server é muito mais ágil: basta responder a algumas questões básicas relativas ao particionamento do disco, configurar a rede e criar um usuário padrão e pronto, o servidor está instalado. Resta definir apenas quais serviços estarão disponíveis no servidor. Por padrão, o sistema não disponibiliza nenhum serviço em rede, que ainda precisam ser instalados e configurados. O melhor é fazê-lo durante a fase final da própria instalação, quando da execução do Tasksel, (o controverso programa de seleção de recursos). Ele oferecerá uma pré-seleção de serviços mais comuns, entre as quais um servidor OpenSSH e um sistema básico LAMP. Os pacotes necessários serão instalados e seus respectivos serviços iniciados automaticamente. Se forem instalados todos os recursos oferecidos pelo Tasksel, será ocupado cerca de 1 GB no disco rígido.



Além da instalação manual padrão, o Hardy Heron oferece outros tipos de procedimento, como a instalação via rede utilizando boot remoto PXE/TFTP/HTTP ou um modo de instalação não supervisionada. Existe, como recurso adicional, uma imagem alternativa da instalação, que instala um servidor de terminais LTSP 5. Para administrar o ciclo de vida completo do servidor, a Canonical oferece uma ferramenta comercial, o Landscape.



Aos usuários da versão com suporte estendido 6.06 (Dapper Drake), bem como para edições anteriores, o projeto Ubuntu “promete” uma atualização livre de problemas através do comando do-release-upgrade.












Durante a instalação, o administrador pode usar o Tasksel para selecionar grupos de pacotes pré-definidos e, assim, ativar recursos e serviços. Por exemplo, quem precisar do OpenSSH, pode simplesmente selecioná-lo na lista mostrada na imagem.



Adeus interface gráfica



O Ubuntu Server vem por padrão sem interface gráfica. Isso é melhor do ponto de vista de segurança, além de facilitar a administração remota do sistema via terminal. Assim que uma interface de rede é ativada, o serviço SSH começa a funcionar, e o servidor pode ser administrado via rede, sem a necessidade de um monitor.



Serviços adicionais podem ser instalados via sistema de gerenciamento de pacotes, para o qual o Ubuntu faz um uso extensivo do mecanismo sudo. Por exemplo, o comando sudo aptitude install ntp instala um servidor NTP e inicia o serviço ao final da instalação (na configuração básica, data e horário são obtidos do servidor ntp.ubuntu.com). A lista a seguir fornece uma visão geral dos pacotes que estão disponíveis para instalação no Hardy Heron.




Kernel

* Default 2.6.24-server Tickless,
No Preemption, Deadline I/O, PAE, 100Hz

Web

* Apache 2.2 event/prefork/worker/dev

Servidor de banco de dados

* MySQL 5.
* PostgreSQL 8.3

Servidor de e-mails

* Dovecot 1.0
* Postfix 2.5
* Exim 4.69

Linguagens de programação

* PHP 5.2
* Perl 5.8
* Python 2.5
* Gcc 4.2
* Ruby 4.1

Serviços de rede

* LTSP 5.0
* Samba 3.0
* OpenLDAP 2.4
* OpenVPN 2.1
* FreeRadius 1.1

Ferramentas de monitoramento

* Munin 1.2
* Nagios 2.11

Backup

* Bacula 2.2
* BackupPC 3.0

Gerenciamento de pacotes

* Aptitude 0.4
* APT 0.7
* Dpkg 1.14

Ferramentas de segurança

* AppArmor 2.1
* Iptables 1.3
* ufw 0.16

Clustering

* Ocfs 2
* Gfs 2
* RH-Cluster 2
* DRDB 8

Virtualização

* KVM 62
* Libvirt 0.4
* Virt-Manager 0.5

Storage

* Lvm 2
* aoetools 23
* openiscsi 2.0


Para configuração de firewall e para a produção de imagens personalizadas de sistemas operacionais, o Ubuntu fornece ferramentas especiais, criadas pela equipe de desenvolvimento da própria distribuição.



Ufw: simplificando a instalação de firewalls



A nova versão do Ubuntu traz pela primeira vez uma ferramenta integrada para a configuração dos recursos de firewall do kernel Linux, criada pela equipe de desenvolvimento do Ubuntu. Essa ferramenta padrão é o programa de linha de comando Ufw (acrônimo para Uncomplicated Firewall). Para regras simples, a operação do programa faz jus ao nome escolhido. Após a instalação do sistema operacional, o firewall está desligado. Os comandos abaixo ativam o firewall, liberando também a porta 80 (normalmente utilizada pelo protocolo HTTP):




sudo ufw enable
sudo ufw allow 80


Se um serviço estiver listado no arquivo /etc/services, ele pode ser utilizado pela ferramenta diretamente, conforme mostra o comando abaixo:



sudo ufw allow smtp


Instruções para regras mais complexas podem ser encontradas no Ubuntu Server Guide.

Entre os recursos de segurança adicionais da distribuição para servidores, está o AppArmor — que vem acompanhado de perfis de configuração para diversos programas e suporte a Non-executable memory (Nx) para sistemas de 64 bits.



Virtualização com sandbox de imagens



O suporte à virtualização da nova versão do Ubuntu para servidores é "bem servido": o kernel do servidor já contém a máquina virtual KVM, a biblioteca libvirt fornece interfaces para ferramentas como o Virt-Manager, que pode gerenciar tanto máquinas virtuais rodando sob o KVM quanto sob o
Xen. Além disso, o sistema também pode utilizar sem problemas o OpenVZ, da Parallels, bem como o VMware Server.

Para o uso de outros sistemas de virtualização, entre eles o próprio VMware Server e o VMware ESX, a Canonical criou uma versão especial do Ubuntu Server 8.04: o Ubuntu Server Edition JeOS (Just enough Operating System). O JeOS é um sistema minimalista, que contém apenas os pacotes imprescindíveis para o seu funcionamento, procurando com isso economizar espaço e reduzir a necessidade de atualizações de segurança. A imagem ISO do JeOS 8.04 tem 100 MB, e o sistema instalado ocupa apenas cerca de 300 MB.



Mas o que o JeOS tem de mais atraente é a sua sandbox de imagens. O Ubuntu-VM-Builder gera imagens de sistema operacional para o KVM, o Qemu e o VMware, e adiciona pacotes específicos de software ao JeOS padrão. Por exemplo, o comando a seguir cria uma máquina virtual para o KVM, acrescentando a ela o editor vim:




sudo ubuntu-vm-builder kvm hardy --addpkg vim


A Canonical recomenda o uso do JeOS também para fornecedores de software que desejem empacotar seus programas em uma imagem e fornecer sistemas como uma appliance (sistema dedicado) virtual.



Mais informações podem ser encontradas no Ubuntu-Server-Guide, disponível atualmente para a versão 8.04 apenas em inglês. Aliás, essa documentação pode ser instalada no sistema, estando disponível como pacote da distribuição (ubuntu-serverguide), e guia o usuário, passo a passo e com diversos exemplos, através da instalação e configuração de servidores básicos, como DNS, OpenSSH e e-mail. Além disso, fornece informações detalhadas a respeito de recursos específicos do Ubuntu, como o Uncomplicated Firewall, o VM-Builder ou o sistema de controles de versão distribuído adotado pela Canonical, o Bazaar.




Gostou? Curta e Compartilhe!

Versão para impressão Enviar por email

Comentários

lançamento!

LM 117 | Desenvolvimento




Impressa esgotada
Comprar Digital  R$ 10,90 Digital

  1. Baixe o curso de shell script do Julio Cezar Neves

    Publicado em 07/04/2008 às 19:41 | 234197 leituras

  1. Resultado do concurso "Por que eu mereço ganhar um netbook?"

    Publicado em 30/09/2009 às 3:00 | 132438 leituras

  1. Software público brasileiro na Linux Magazine Especial

    Publicado em 29/07/2011 às 15:07 | 118396 leituras

  1. Lançado o phpBB 3

    Publicado em 13/12/2007 às 18:42 | 111458 leituras

  1. TeamViewer disponível para Linux

    Publicado em 26/04/2010 às 1:27 | 88602 leituras

  1. Consumidora da Califórnia processa novamente Microsoft por downgrade para XP

    Publicado em 03/01/2011 às 11:04 | 4375 leituras

  1. Líder em IPv4, Brasil fica para trás na adoção do IPv6

    Publicado em 16/07/2014 às 10:28 | 2599 leituras

  1. Brasil lidera ranking mundial de ataques com o vírus Conficker

    Publicado em 09/05/2013 às 12:31 | 5589 leituras

  1. Samsung exibe rede WiMAX2 que alcança velocidade de 330 Mbps

    Publicado em 07/10/2010 às 14:30 | 3886 leituras

  1. Encarando a Microsoft

    Publicado em 10/11/2011 às 15:40 | 5714 leituras

whitepapers

mais whitepapers