Blog de Nivaldo Júnior

Cassandra + PHP

2010-07-28T07:30:00.001-03:00

No post anterior eu expliquei sobre o funcionamento do Cassandra. Agora vamos colocar a mão na massa e vamos configurar o nosso servidor Debian para criar aplicações em PHP que interajam com o Cassandra.

O PHP precisa de uma biblioteca chamada Thrift para se comu

nicar com o Cassandra. Temos duas formas de trabalhar com ela, a primeira é usando a biblioteca dentro do diretório da nossa aplicação e a segunda é compilar um módulo nativo para o PHP. O módulo nativo proporciona muito mais velocidade. Vamos mostrar abaixo como configurar as duas formas.

1- Configuração do servidor

Passos para instalar o Thrift no servidor sem o módulo nativo do PHP:

- apt-get install libboost-dev automake libtool flex bison pkg-config g++
- wget http://ftp.unicamp.br/pub/apache/incubator/thrift/0.2.0-incubating/thrift-0.2.0-incubating.tar.gz
- tar -xzvf thrift-0.2.0-incubating.tar.gz
- cd thrift-0.2.0
- ./configure
- make
- ./compiler/cpp/thrift -gen php ../PATH-TO-CASSANDRA/interface/cassandra.thrift
- mkdir -p /usr/share/php5/Thrift- cp -R gen-php/ /usr/share/php5/Thrift/packages/
- cp -R lib/php/src/* /usr/share/5php/Thrift/

Passos para instalar o módulo nativo do PHP:

- cd PATH-TO-THRIFT/lib/php/src/ext/thrift_protocol
- apt-get install php5-dev
- phpize
- ./configure --enable-thrift_protocol
- make
- cp modules/thrift_protocol.so /usr/lib/php5/20060613/
(A pasta lib do PHP vai depender da versão instalada no seu servidor)- vi /etc/php5/cli/conf.d/thrift_protocol.ini
extension=thrift_protocol.so
- Verificar instalação:
php -i | grep -v "PWD" | grep "thrift_protocol"
- /etc/init.d/apache2 restart

2- Inserindo dados no Cassandra com o PHP

Agora que já temos o servidor configurado e pronto para funcionar, vamos fazer alguns testes inserindo dados no cassandra. Vamos usar como base o exemplo do post anterior.

Re-lembrando os dados:

ColumnFamily: Usuarios

['junior']['login'] = ['junior']
['junior']['nome'] = ['Nivaldo']
['junior']['sobrenome'] = ['Montenegro']
['junior']['email'] = ['nivaldomjunior@gmail.com']
['usuario2']['login'] = ['usuario2']
['usuario2']['nome'] = ['Fulano']
['usuario2']['sobrenome'] = ['de tal']
['usuario2']['email'] = ['fulano@gmail.com']
['usuario2']['fone'] = ['(83)1234-1234']

SuperColumn: Agenda

['junior']['amigo1']['nome'] = ['Amigo 1']
['junior']['amigo1']['telefone'] = ['(88)1234-1234']
['junior']['amigo2']['nome'] = ['Amigo 2']
['junior']['amigo2']['telefone'] = ['(99)4312-4312']
['usuario2']['amigox']['nome'] = ['amigox']
['usuario2']['amigox']['telefone'] = ['(77)9987-0987']
['usuario2']['amigoy']['nome'] = ['Amigo y']
['usuario2']['amigoy']['email'] = ['fulano@gmail.com']
['usuario2']['amigoy']['fone'] = ['(83)1234-1234']

O código do arquivo php está em um arquivo de imagem, mas vou disponibilizar posteriormente o arquivo php para download.

Código do arquivo criar.php:

Clique aqui para baixar o arquivo criar.php.

3- Consultando dados no Cassandra

As consultas são realizadas em cima dos índices, ou seja, não dá para consultarmos diretamente os valores das chaves como estamos acostumados a fazer em um banco de dados SQL.

Por exemplo, vamos consulta os dados da Agenda do usuário junior:

4- Mais informações

Bom, este foi um exemplo rápido sobre como podemos usar o Cassandra com PHP. Espero que sirva como base para que você inicie no desenvolvimento com PHP e Cassandra.

Alguns links de referência:

- Using Cassandra with PHP

- ThriftExamples

- Site do projeto Cassandra

Até a próxima! :)

Entendendo o banco de dados NoSQL Cassandra

2010-07-23T14:50:00.001-03:00

Por necessidade, resolvi realizar testes em bancos de dados NoSQL. Estava precisando de um banco de dados que comporte pelo menos 1.5 milhões de registros por dia e que forneça uma forma rápida para realizar consultas.

Testei três NoSQL: Cassandra, MongoDB e CouchDB.

Criei uma pequena aplicação em PHP para inserir 500 milhões de registros (exagerei né? Mas precisava ter certeza) e um PHP para listar a quantidade de registros. Percebi que ainda tem poucos tutoriais que mostram de forma clara como as coisas funcionam e por isso resolvi escrever alguns pequenos posts mostrando o caminho das pedras.

Resolvi então escrever alguns posts sobre banco de dados NoSQL com PHP.

Vamos começar falando sobre o Cassandra com PHP.

1- Por onde começar?

A primeira coisa a fazer é acessar o site do projeto http://cassandra.apache.org e fazer o download do Cassandra. A versão que usei para os testes foi o Cassandra 0.6.3.

Passos para baixar e iniciar o Cassandra:

- wget http://ftp.unicamp.br/pub/apache/cassandra/0.6.3/apache-cassandra-0.6.3-bin.tar.gz
- tar -xzvf apache-cassandra-0.6.3
- cd apache-cassandra-0.6.3
- ./bin/cassandra -f

Depois desses comandos o Cassandra estará funcionando com as configurações padrão. Mas antes de começarmos a usar é necessário entenderemos a estrutura desse banco de dados NoSQL. Pra quem é acostumar com bancos de dados tradicionais, é necessário um pouco de esforço para a quebra de paradígma.

2- Conhecendo a estrutura do Cassandra

O Cassandra é um banco de dados NoSQL e armazena as informações no formato chave = valor, mas para quem está acostumado com bancos de dados tradicionais, tabelas, joins, normalização, etc., é difícil colocar na cabeça que tudo o que você aprendeu a vida toda foi por água abaixo. :)

Li vários artigos e tutoriais para entender o esquema de armazenamento e indexação do Cassandra. Um excelente ponto de partida é este artigo: WTF is a SuperColumn? An Intro to the Cassandra Data Model.

Pra quem não sabe o que significa WTF: What the fuck... ou seja, que porra é uma supercolumn?!?! :)

Com este artigo dá para entender bem o funcionamento do esquema de armazenamento e indexação, por isso, não explicarei detalhadamente como funciona, apenas superficialmente através de exemplo para complementar o artigo citado.

De forma bem simplificada:

- Column: Armazena chave, valor e timestamp. Todos os dados são armazenados em columns. A column não precisa ser criada em arquivo de configuração, basta inserir uma nova column com chave/valor que o banco de dados cria automaticamente. Column - ['id']['chave'] = ['valor']

- SuperColumn: Armazena chave = chave/valor/timestamp. É como se fosse um conjunto de columns. A SuperColumn na verdade é uma ColumnFamily do tipo Super. Possui duas chaves. SuperColumn - ['id']['chave1']['chave2'] = valor

- ColumnFamily: É uma família de colunas, ou seja, é o agrupamento de várias chave = valor. É necessário criar a ColumnFamily dentro das configurações do cassandra (storage-conf.xml). Ou seja, as Columns ficam armazenadas em uma ColumnFamily.

Exemplo:

ColumnFamily: Usuarios

Usuarios = { // ColumnFamily
   junior: { // Esta é a chave da CF (id)
   // Dentro da CF podemos ter um número infinito de chave/valor
   login: "junior",
   nome: "Nivaldo",
   sobrenome: "Montenegro",
   email: "phatduckk@example.com",
   }, // Fim
   usuario2: { // Esta é a chave para outra linha na CF (id)
   // Podemos inserir outro número infinito de chave/valor e não precisa ter as mesmas chaves/valor que outras linhas da CF
   login: "junior",
   nome: "Nivaldo",
   sobrenome: "Montenegro",
   email: "phatduckk@example.com",     fone: "(83) 1234-1234"
   },
}

- KeySpace: É um conjunto de ColumnFamily. Analogamente, é como se fosse um banco de dados criado dentro do cassandra. É necessário realizar configurações no arquivo storage-conf.xml para criar as KeySpaces e realizar um restart no Cassandra.

Evoluindo o exemplo dado para a ColumnFamily, podemos transformar a ColumnFamily em uma SuperColumn e termos dados mais organizados sobre os clientes.

Exemplo SuperColumn:

Exemplo:

SuperColumn: Agenda

Agenda = { // SuperColumn
   junior: { // ColumnFamily   amigo1: { //Chave da ColumnFamily
   // Dentro da CF podemos ter um número infinito de chave/valor
   nome: "Amigo 1",
   telefone: "(88)1234-1234",
   } //Fim do amigo1
   amigo2: { //Outra chave na ColumnFamily
   nome: "Amigo 2",
   telefone: "(99)4312-4312",
   } // Fim do amigo 2

   }, // Fim da CF junior
   usuario2: { // Outra ColumnFamily
   amigox: { //Chave da ColumnFamily
   // Podemos inserir outro número infinito de chave/valor e não precisa ter as mesmas chaves/valor que outras linhas da CF
   nome: "amigox",
   telefone: "(77)99870987",
   } //Fim amigox
   amigoy: { //Outra CF
   nome: "Amigo Y",
   fone: "(83)1234-1234"
   email: "fulano@gmail.com",
   } //Fim amigoy
   }, //Fim da CF usuario2
}

Ou seja, temos os seguintes níveis no Cassandra:

KeySpaces

   ColumnFamily
   Columns
   SuperColumn
   ColumnFamily
   Columns

Um fato importante é que as buscas necessariamente precisam ser realizadas usando os índices, ou seja, as chaves das ColumnFamilys. Não tem como fazermos as consultas usando os valores finais das chaves diretamente no banco de dados. Para isso é necessário buscarmos todos os dados e realizarmos a consulta usando a linguagem de programação. Por isso, é extremamente importante criar índices que realmente sejam utilizados e não usar números sequencias como costumamos fazer nos campos id das tabelas em um banco de dados tradicional.

3- Configurando o cassandra para atender o exemplo acima

É necessário configurar o Cassandra para criar as KeySpaces, ColumnFamilys e SuperColumns (ColumnFamily do tipo Super) que iremos precisar para armazenar os nossos dados. As configurações são relativamente simples, mas precisamos definir qual o tipo de ordenação que faremos para cada ColumnFamily e SuperFamily, pois os dados são armazenados e ordenados automaticamente de acordo com a configuração criada para a ColumnFamily ou SuperColumn.

Exemplo de configuração:

O parâmetro CompareWith nas ColumnFamilys é o que vai determinar a forma de ordenação da ColumnFamily. O CompareWith no nosso exemplo vai ser usado para ordenar a chave da ColumnFamily, que no nosso exemplo tem dois valores: junior e usuario2. No artigo citado acima (esse link) tem um exemplo bem detalhado sobre a forma de ordenação.

Já nas SuperColumns, o parâmetro CompareWith ordena o nome da ColumnFamily, no nosso exemplo os valores junior e usuario2, e o parâmetro CompareSubColumnsWith ordena a chave da ColumnFamily, que no nosso exemplo tem os valores amigo1, amigo2, amigox e amigoy.

4- Conclusão

O Cassandra é um banco de dados NoSQL extremamente flexível e poderoso, principalmente quando se pensa em escalabilidade, mas a organização dos dados é o que vai determinar o sucesso da utilização desse tipo de banco de dados. É necessário realizar um trabalho minucioso em cima dos índices para que as buscas sejam realmente rápidas e eficientes, minimizando a filtragem de dados usando a linguagem de programação.

Espero que eu tenha esclarecido as suas dúvidas e no próximo post vou falar um pouco sobre como utilizar o Cassandra com PHP em um servidor com Debian.

Instalando e configurando o FOP2 para monitorar o seu Asterisk

2010-07-01T17:11:00.001-03:00

Esses dias tava navegando em sites sobre Asterisk e vi o pessoal falando sobre o FOP 2 (Flash Operator Panel). Lembrei que tinha testado a primeira versão do FOP, mas não tinha gostado muito. Achei a interface um feinha.

Resolvi então testar o FOP 2 e gostei muito, compramos inclusive uma licença para monitorar mais de 15 ramais.

Estou usando no PABX da empresa monitorando todos os ramais, os dois E1s, os troncos SIP e IAX, as portas analógicas FXO (interface de celular), as filas de atendimento e as salas de conferência e estamos muito satisfeitos com o desempenho e funcionamento.

O procedimento de instalação e configuração é bem simples.

1- Faça o download do FOP 2 em http://www.fop2.com/download.php

2- Descompacte a versão que você baixou, no meu caso Debian Lenny

# cd /usr/src/

# tar -xzvf fop2-2.11-debian-i386.tgz

3- Instale o FOP 2 executando make install:

# cd fop2/

# make install

Este será o resultado do comando:

New configuration file /usr/local/fop2/fop2.cfg.new installed.

Original fop2.cfg preserved.

New configuration file /var/www/fop2/config.php.new installed.

Original config.php preserved.update-rc.d: warning: /etc/init.d/fop2 missing LSB information

update-rc.d: see System startup links for /etc/init.d/fop2 already exist.Done!

4- Edite o arquivo fop2.cfg para configurar o FOP2

# cd /usr/local/fop2/

# vi fop2.cfg

- Configure o manager através dos parâmetros:

; AMI definitions

manager_host=localhost

manager_port=5038

manager_user=admin

manager_secret=senha

- Configure os usuários que terão acesso ao FOP2 e defina um arquivo de botões

user=8195:1234:all

buttonfile=buttons.cfg

No meu caso, 8195 é também o nome do meu usuário SIP. Dessa forma eu poderei interagir com o FOP2 para executar comandos de discagem, transferência, etc e tudo será direcionado para o telefone IP da minha mesa.

- Comente a última linha do arquivo:

;#exec autoconfig-users-freepbx.sh

5- Crie um arquivo com as configurações dos seus ramais SIP, trunks, salas de conferência e filas (buttons.cfg, conforme definido no fop2.cfg):

Exemplo de arquivo:

# vi buttons.cfg

[SIP/8195]

type=extension

extension=8195

context=Ramais

label=Junior

[QUEUE/Fila-XYZ]

type=queue

label=SAC

extension=100

context=ramais

[DAHDI/1]

type=trunk

label=E1 da Embratel

channel=DAHDI/1

channel=DAHDI/2

channel=DAHDI/3

channel=DAHDI/4

[CONFERENCE/1000]

type=conference

label=Sala de conferencia

server=1

extension=8177

context=ramais

6- Após configurar os arquivos necessários, precisamos iniciar o serviço do FOP server para que o FOP2 funcione. Faça isso executando o comando:

# /etc/init.d/fop2 start

7- Acesse a URL http://IP_SERVIDOR/fop2 e utilize o usuário e senha criado no fop2.cfg para ter acesso aos recursos do FOP

Caso você não esteja conseguindo acessar o FOP depois de digitar o login e senha, você pode iniciar o servidor manualmente usando o comando /usr/local/fop2_server e verificar qual a mensagem de erro que está sendo mostrada na inicialização do serviço.

Usando as configurações do fop2.cfg, é possível definir grupos de acesso e associá-los aos usuários. Dessa forma você poderá montar paines de operadora diferentes de acordo com cada usuário que acessar.

Para maiores informações sobre o FOP, é só consultar a documentação online dele no endereço: http://www.fop2.com/documentation.php

Então é isso! :)

Um breve tutorial de como instalar e configurar o FOP.

Otimizando a performance do seu banco de dados no PostgreSQL

2009-12-05T09:38:00.015-03:00

Quem trabalha com informática fatalmente vai ter que mexer com tudo. No início você trabalha somente com redes ou com desenvolvimento de software, mas atualmente as duas áreas estão cada vez mais integradas.

O desenvolvedor de software tem que conhecer cada vez mais de redes, segurança e protocolos de comunicação para desenvolver um software eficiente, que consuma poucos recursos, seja seguro e tenha qualidade. Já o administrador de redes, precisa conhecer o desenvolvimento de software para conseguir monitorar as aplicações que funcionam no seu servidor, verificar questões de segurança e em alguns momentos desenvolver scripts ou pequenos programas que auxiliem na administração da rede e dos servidores.

O novo desafio que peguei pela frente foi fazer a otimização de um servidor de banco de dados PostgreSQL.

A necessidade surgiu após fazer a análise do funcionamento do servidor durante um período de produção. A CPU do servidor estava trabalhando sempre acima de 75% e a memória sempre abaixo de 15%.

Algumas partes do sistema estavam extremamente lentas, principalmente a tela de consulta de log de transações realizadas e o detalhamento de cada transação.

Antes de iniciarmos a conversa sobre otimização, vamos a alguns números do Banco de Dados e do servidor em questão:

Servidor: Dell PowerEdge Quad Xeon 2.33 Ghz, 4GB RAM, 1TB HD
Quantidade de tabelas: 50
Tamanho atual do banco: 5,3 GB

O banco de dados possui 4 principais tabelas que recebem inúmeros INSERTs por dia. A estimativa é que sejam inseridos no banco de dados todos os dias cerca de 1.000.000 de registros (Putz! Haja registro! Mas vamos em frente... vai dar certo! hehehe).

Lendo um pouco sobre o PostgreSQL e sobre Banco de Dados, cheguei à conclusão que para melhorar o desempenho era necessário:

Melhorar a estrutura de tabelas do banco de dados
Realizar algumas configurações no PostgreSQL
Programar manutenções diárias no banco de dados

Antes de executar as modificações, realizei o acesso à página de logs do sistema (nessa página a consulta é realizada por data e em um dia de consulta o retorno é de aproximadamente 110.000 registros) e ao detalhamento de um dos logs. Resultado:

Tempo para carregar página de logs: 4,53 segundos

Tempo para carregar detalhamento: 35,42 segundos

O primeiro passo é melhorar a estrutura do banco de dados através da criação de índices nos campos que são geralmente usados na clásula where do SQL.

Analisei as consultas e encontrei os principais campos em cada tabela. É importante observar que não adianta criar índices em todos os campos de todas as tabelas, se não a CPU do seu servidor vai para as alturas.

A análise da consulta pode ser feita usando o comando EXPLAIN ANALYZE. Basta executar EXPLAIN ANALYZE seguido do seu select que está lento e você vai ter um resumo do tempo consumido em cada parte da sua consulta e a partir daí você saberá quais os campos são necessários criar um índice.

Mas antes de melhorarmos os índices do nosso banco de dados, vamos fazer uma limpeza geral de registros que foram deletados mas que o banco de dados ainda não os removeu por completo, apenas marcou os registros como apagados. Fazemos isso através do comando VACUUM FULL.

Este comando não pode ser executado frequentemente, já que ele dá um lock nas tabelas na hora que está fazendo a operação. É importante que você faça a manutenção do seu Banco de Dados para evitar o uso deste comando. Falarei sobre estas operações no meu próximo post.

O comando VACUUM FULL demora um pouco para ser executado, dependendo do tamanho do seu banco de dados. No meu caso, demorou 103 segundos, ou seja, 1 min e 43 segundos.

Agora vamos criar os índices das tabelas. A criação dos índices é feita usando o comando CREATE INDEX seguido do comando ANALYZE tabela, exemplo:

CREATE INDEX log_chamada_id_idx1 on log_operacao_cti(log_chamada_id)

Onde log_chamada_id_idx1 é o nome do índice, log_operacao_cti é o nome da tabela e log_chamada_id é o campo da tabela que eu desejo criar um índice.

ANALYZE log_operacao_cti

Resultado da criação dos índices no meu banco de dados:

Agora que temos índices criados nas nossas tabelas, vamos realizar um novo teste no sistema para ver como está o tempo de carregamento.

Resultado após as alterações:

Tempo para carregar a página de logs: 1,46 segundos

Tempo para carregar o detalhamento: 492 ms

Percebeu a diferença? :)

O próximo passo é melhorar a configuração do servidor PostgreSQL para que ele consuma os recursos disponíveis no hardware de forma mais eficiente e programar manutenções no banco de dados para mantermos o banco sempre limpo e funcionando perfeitamente, mas isto é assunto para um próximo post.

Java Heap Dump: Analisando a utilização de memória da sua aplicação Java

2009-12-03T06:34:00.002-03:00

No post passado eu falei um pouco sobre o VisualVM mas não falei sobre como fazer o dump do heap do Java em uma máquina monitorada remotamente.

Não dá para fazer isso usando o VisualVM. Você precisa acessar a máquina remota e executar o seguinte comando:

jmap -F -dump:live,format=b,file=dump-heap-java.hprof PID

PID é o número do processo do Java. Para saber o número do processo do Java no Linux, execute o seguinte comando:

ps ax|grep java

Este comando demora um pouco para ser executado, tenha paciência, pois vai depender do seu Heap Size atual. Ele vai gerar um arquivo do tamanho do heap atual. No meu caso, gerou um arquivo de 778 Mb.

Agora que já temos o arquivo de dump, é necessário copiá-lo para a máquina aonde tenha o VisualVM rodando.

Carregue o arquivo no VisualVM usando o Menu File > Load...

Procure o arquivo de dump do heap e abra ele.

Agora que estamos com o dump carregado no VisualVM, vamos tentar encontrar o que está gerando problema de uso de memória na aplicação Java.

Clique na aba Classes e será exibida uma lista com as classes, o percentual de instâncias, a quantidade de instâncias e, o que nos interessa, o tamanho alocado por essa classe.

Vamos ordenar a lista por tamanho, clicando na coluna tamanho.

Veja que o primeiro da lista é o byte[]. Clicando duas vezes nele, será apresentada a aba Instances contendo todas as instâncias que estão usando o byte[] na memória.

Perceba que temos várias instâncias com o mesmo tamanho (16681), o que significa que é a mesma classe que está usando o byte[] e não está desalocando o recurso.

Clique em uma das instâncias e vai abrir na lateral direita a área References na parte inferior. Clique com o botão direito na classe que vai aparecer e em seguida escolha a opção Show Instance.

O resultado irá mostrar o que está ocupando a memória:

No meu caso era um comando SQL de Insert a um banco de dados de teste MySQL. Perceba na imagem que temos o comando SQL completo, separado em vários chars.

Associado a este dump, utilizei o dump dos threads onde vi qual a classe que estava gerando os Threads Blocked. Neste meu caso, o problema estava no servidor de Banco de Dados que estava mau configurado e não estava tendo recursos suficientes para atender a todos os requests.

Utilizando dump de Heap e dump de threads como mostrei no meu post anterior, você conseguirá detectar todos os problemas de gerência de memória da sua aplicação.

Uma outra funcionalidade legal que você pode utilizar no VisualVM é utilizar o JConsole somado ao plugin JTop para monitorar o consumo de CPU por threads para detectar uso excessivo de CPU gerado por algum bug no software, mas isto é assunto para um outro post.

Links de referência:

VisualVM: Analisando o funcionamento de sua aplicação Java

2009-12-01T09:02:00.035-03:00

O desenvolvimento de aplicações em Java e a otimização é algo que requer uma atenção muito especial. Muitos por aí falam que odeiam o Java falando que é muito difícil de desenvolver, que tem problema de uso de memória e etc.

Os programadores Java que me desculpem, mas estou começando a achar que o problema não está no Java e sim na forma como se desenvolve e como se implanta o sistema. Acrescento ainda, o problema vem desde a Faculdade, onde não se fala absolutamente nada sobre otimização e análise de desempenho de aplicações.

Antes de liberar o sistema para a produção é extremamente importante fazer uma análise geral do funcionamento da aplicação, do uso de CPU, de memória e o número de threads geradas, para saber se a aplicação está alocando e desalocando os recursos corretamente, abrindo e fechando as threads, etc.

Bom, mas vamos ao que interessa. Como fazer para monitorar a sua JVM?

Para iniciar é necessário prepararmos a JVM para ser monitorada. Neste exemplo vou utilizar o servidor de aplicação Jetty rodando em um servidor Linux na pasta /opt/jetty.

Abra o arquivo jetty.sh que está dentro da pasta /opt/jetty/bin/ e adicione a seguinte variável no começo do arquivo (após os comentários):

JAVA_OPTIONS="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=8086 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

Explicando cada parâmetro:

-Dcom.sun.management.jmxremote: Habilita o gerenciamento remoto

-Dcom.sun.management.jmxremote.port=8086: Porta que será usada para conexão

-Dcom.sun.management.jmxremote.ssl=false: Habilitar ou não o SSL

-Dcom.sun.management.jmxremote.authenticate=false: Se haverá necessidade de autenticação para se conectar na JVM

Feito isto, basta iniciar o seu Jetty usando o script jetty.sh:

/opt/jetty/bin/jetty.sh start

O seu Jetty vai iniciar e permitirá que você se conecte remotamente na JVM para fazer o monitoramento.

Outra opção para iniciar o jetty é executar diretamente na linha de comando:

java -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=8086 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -jar /opt/jetty/start.jar

Para o monitoramento utilizaremos a excelente ferramenta da Sun chamada VisualVM. Não sei se é a melhor, mas atendeu às minhas necessidades e resolveu os meus problemas. :)

Execute o comando jvisualvm em qualquer máquina que tenha uma JVM instalada. No meu caso, uso Mac OS X Snow Leopard para o monitoramento.

Tela inicial do VisualVM

Na coluna na lateral esquerda execute os seguintes passos para adicionar o seu servidor remoto:

Clica com o botão direito em Remote
Clica em Add Remote Host...
Coloca o IP ou nome da máquina a ser monitorada no campo e clica em OK
Clica com o botão direito no Host adicionado
Clica em Add JMX Connection...
Preencha o campo Connection com IP:PORTA, onde a porta é a que foi adicionada no JAVA_OPTIONS do Jetty, no meu caso 8086, e depois clica em OK

Pronto, a sua JVM já vai ser monitorada. Você poderá acompanhar na aba Monitor em tempo real a utilização de CPU, Heap Size, número de classes e número de threads.

Na aba Threads, é possível monitorar os threads em tempo real.

Um recurso muito útil para descobrir problemas de má utilização de memória é fazer um dump das threads e analisar qual a thread que está ficando presa e qual classe que foi executada para causar o travamento da thread.

Para fazer um thread dump, basta clicar com o botão direito no IP do servidor monitorado e clicar em Thread Dump.

Ele vai gerar um dump de todas as threads rodando na sua JVM. Este comando pode demorar dependendo da quantidade de threads que você tem atualmente sendo executadas.

Ao clicar duas vezes no Dump, abrirá uma nova aba com todas as informações das suas threads.

Agora é só procurar por BLOCKED e aí você vai encontrar as threads que estão travadas.

Importante: nem sempre uma thread blocked significa que ela ficará travada para sempre. Pode acontecer de uma thread que esteja fazendo alguma operação com um banco de dados esteja esperando recurso disponível para executar o processo e aí ela fica blocked até o recurso ficar disponível. Neste caso, o problema pode estar no seu banco de dados que não está suportando a quantidade de transações, no seu pool de conexões ou no seu SQL que está mau feito.

Ah... lembrei de uma coisa legal. Se você está rodando o servidor de aplicação no mesmo host do VisualVM, você pode fazer dump do Heap do Java e fazer a análise no VisualVM. Se a aplicação está rodando remotamente, então para fazer o dump do heap e analisá-lo, é necessário fazer alguns passos extras. Mas não se preoculpe, no meu próximo post eu falarei sobre isso... :)

Agora é só você brincar com a ferramenta e descobrir o que é possível fazer com ela. :)

Links de relacionados:

Dica: Como substituir uma String em vários arquivos ao mesmo tempo

2009-11-30T15:09:00.006-03:00

Hoje precisei substituir uma String em 51 arquivos VXML. Como fazer isso? Editar um por um? Não... isso é coisa pra quem usa Windows! :)

Para quem tem um Linux basta usar o comando replace ou então o sed.

Exemplo usando sed:

for i in * ; do sed -i 's/ORIGINAL/NOVO/g' $i; done

Exemplo usando o replace:

replace ORIGINAL NOVO < oldfile > newfile

Usei o sed para fazer o trabalho por que achei mais fácil. Mas tá aí a dica pra quem precisar.

java.lang.OutOfMemoryError: Dica para quem tem esse tipo de problema com Java

2009-11-26T06:15:00.004-03:00

O Java é uma linguagem de programação muito poderosa, mas desde que me entendo por gente, tem problema de gerenciamento de memória.

Recentemente, realizamos a implantação de uma URA (Unidade de Resposta Audível) que tem um backend para integração com o CTI e com a base de dados do cliente. Toda a integração foi desenvolvida em Java e rodava inicialmente em Tomcat, mas foi migrada para o Jetty com o objetivo de evitar problemas de gerenciamento de memória.

Eis que um belo dia, surge a surpresa. O Jetty simplesmente fechava, depois de um período de produção, com carga. O processo desaparecia e não tinha nada no log mostrando o que houve.

Começamos a monitorar o sistema e recebi a seguinte mensagem no prompt quando o problema aconteceu novamente:

# An unexpected error has been detected by Java Runtime Environment:
#
# java.lang.OutOfMemoryError: requested 264496 bytes for Chunk::new. Out of swap space?
#
# Internal Error (414C4C4F434154494F4E0E43505000C7), pid=7896, tid=1878612880
#
# Java VM: Java HotSpot(TM) Server VM (1.6.0-b105 mixed mode)
# An error report file with more information is saved as hs_err_pid7896.log
[thread 1406139280 also had an error]
#
# If you would like to submit a bug report, please visit:
# http://java.sun.com/webapps/bugreport/crash.jsp
#

Pesquisei na Internet e encontrei informações referentes a um possível bug na Java VM. Putz, como eu estava com sorte. Tudo bem. Atualizei para a última JVM, colocamos na produção novamente e o problema apareceu novamente.

Vi em vários sites na Internet orientando para aumentar o heap através do parâmetro -Xmx. Testei, mas não funcionou.

Foi então que descobri que o problema estava relacionado a uma limitação da JVM 32bits de usar no máximo 2GB no heap size. Ou seja, o Jetty começava a alocar os recursos e quando chegava nos 2GB de alocação, gerava esse problema de OutOfMemoryError.

java.lang.OutOfMemoryError: requested 32756 bytes for ChunkPool::allocate. Out of swap space?
Essentially the native objects does not have enough memory to use. This is usually because you have allocated too much memory to your heap reducing the amount available for native objects. See this article.
The solution is to reduce the amount of heap memory you have allocated. For example if you have set -Xmx4096, you should consider reducing this to -Xmx2048m.
Remember if you are using a 32bit JVM you cannot allocate more than -Xmx2048m for linux (and even less for windows). Using a 64 bit JVM can resolve this problem, but is not recommended for fisheye/crucible instances (refer to System Requirements).

Solução: Limitar o seu max heap size em 2048.

Para quem precisa fazer tunning em servidores de aplicação Java seguem alguns links úteis:

Como mudar a memória de um Macbook Pro Unibody

2009-11-24T04:36:00.013-03:00

Vou re-ativar o meu blog e tentar mantê-lo atualizado. Nos últimos anos tenho tentado fazer isso, mas infelizmente, devido ao tempo não tenho conseguido.

Vou iniciar os meus posts falando sobre como trocar a memória no Macbook Pro 15' Unibody.

Ontem tomei coragem e finalmente comprei 4GB de memória RAM DDR3 para o meu Macbook Pro 15' Unibody. Estava realmente precisando.A troca da memória no Macbook Pro é um processo bem simples que não precisa de muito trabalho para ser realizado.

Antes da troca: 2GB de RAM

Parte de cima do Meu Macbook Pro 15' Unibody

Parte de trás do Macbook Pro

É necessário uma chave philips pequena para retirar os parafusos da tampa traseira do Macbook. Utilizei o kit de chaves abaixo para realizar a abertura da tampa.

Vamos iniciar a troca. Primeiro, remova a tampa da bateria que não é presa por parafusos, apenas por uma trava e em seguida remova a bateria.

Abra a tampa traseira do Macbook usando a chave Philips e retire os 8 parafusos. Remova a bateria antes de realizar a troca da memória.

Depois de remover a tampa o seu Macbook ficará assim:

Agora que está aberto, basta remover as duas memórias antigas do Macbook e adicionar as duas memórias novas. Feche o Macbook e ligue para testar.

O resultado, seu Macbook agora terá 4Gb de RAM e ficará uma bala! :)

Compartilhando informações

2009-01-25T13:47:00.002-03:00

Por diversos anos tentei criar um site pessoal com informações de áreas do meu interesse, testei Drupal, Wordpress e Joomla, utilizei cada um dos CMS por um tempo, mas nunca consegui manter o site sempre atualizado. Resolvi então, abandonar os CMS e abrir um Blog! Acho que ficará mais fácil de atualizar...
Espero estar começando um Blog com informações que sirvam para todos que trabalham com Asterisk, Linux, roteadores Cisco e outras tecnologias que eu esteja trabalhando.
Bom... espero que isto seja apenas o começo...

Abraço a todos!