Translate

Pesquisar este blog

domingo, 28 de dezembro de 2014

Fazendo um backup contínuo do PostgreSQL (Point-In-Time-Recovery)

Eu separei o post de Backup do PostgreSQL  agora em dois posts para ficar mais fácil de entender a diferença dos dois tipos de backup.


Quando os dados de um banco ficam grandes demais/ou a missão é crítica para fazer o dump da database, é necessário o backup contínuo da database.

O backup contínuo é o backup da qual é feito um backup físico da base (backup de base), as alterações, a cada X minutos, o PostgreSQL salvará em arquivos de segmento incrementais.
Um script ou uma linha de comando copiará o arquivo de segmento para o destino de backup, que pode ser um servidor de arquivos, uma unidade de fita, etc.
É preciso modificar algumas linhas  do postgresql.conf:

archive_command = 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'  # Unix
archive_command = 'copy "%p" "C:\\server\\archivedir\\%f"'  # Windows
wal_level = archive
archive_mode = on
checkpoint_timeout = 5min 
 
O banco expandirá o %p para o caminho do arquivo e o %f para o 
nome do arquivo apenas. 
O nome do arquivo é importante na sua restauração.
Aqui eu também dimninuí o tempo máximo de checkpoint (checkpoint_timeout) para 5 minutos. 


 1-) Fazendo o backup de base
O backup de base é o backup físico de toda a base inicial. Depois virão os backup incrementais para fazer as atualizações seguintes a este backup.

ATENÇÃO: Fazer um dump com pg_dump (isso é backup lógico), não vai funcionar. É preciso que o backup seja físico copiando os arquivos fisicamente.

Chame a linha de comando e:
psql -U postgres -c "select pg_start_backup('nomedolabel')"
No Windows geralmente a pasta da database/cluster é a pasta data\ da instalação.

No Unix ela costuma ser /var/lib/pgsql/XXXX/data.
Copie a pasta da database, mesmo com o banco ligado e funcionando.

Depois páre o modo de backup do banco:
psql -U postgres -c "select pg_stop_backup()"


2-) Recuperando um backup contínuo
  • Páre o servidor.
  • Mova a pasta da database danificada para outro lugar.
  • Restaure o backup de base, feito no item 1. Verifique as permissões de arquivos.
  • Remova todos os arquivos presentes em pg_xlog/ do backup de base, recém restaurado do item 1.
  • Se você tiver os arquivos da pasta pg_xlog/ do cluster danificado, copie para o pg_xlog/ do restore.
  • Crie um arquivo recovery.conf no cluster restaurado para indicar o banco a fazer uma restauração. Ele possui várias opções, você deve pelo menos criar a linha restore_command:
    restore_command = 'cp /mnt/server/archivedir/%f "%p"' 
     
  • Modifique o pg_hba.conf para  os usuários não poderem se conectar enquanto o servidor se restaura.
  • Ligue o servidor. Ele vai entrar em modo de recovery, quando terminar vai renomear o recovery.conf para recovery.done. 
  • Depois veja se está tudo correto com o banco. Caso OK modifique o pg_hba.conf novamente,  e dê select pg_reload_conf()  para os usuários se logarem.

O arquivo recovery.conf possui muitas opções. Ele pode, inclusive, restaurar somente até determinada data. Isto é util se alguém dropou uma tabela acidentalmente, por exemplo.
Por isso leia tb:
http://www.postgresql.org/docs/9.4/static/recovery-target-settings.html
http://www.postgresql.org/docs/9.4/static/continuous-archiving.html

quarta-feira, 17 de dezembro de 2014

Compilando Delphi para Java e Android: FPCJVM

Introdução

Na década de 90, tornou-se popular a linguagem Object Pascal, devido à explosão da ferramenta Delphi no mercado.
Toneladas de linhas de código foram feitos desde então nessa ferramenta.
Quando surgiram os dispositivos móveis, eles eram baseados na linguagem Java ao invés, fazendo com que muitos programas em Delphi ficassem obsoletos por não migrarem para a nova plataforma.

Foi criado um compilador de Object Pascal Open Source, chamado FPC, que possui portas para diversas arquiteturas-alvo, inclusive Java.  (FPCJVM)
O FPCJVM é um compilador Pascal que gera código para a máquina virtual Java (JVM). Ao invés de um executável puro ele gera vários arquivos .class para ser executados pela JRE, ou pelo Android.


Criando seu primeiro programa Swing em "Object Pascal".

program testeSw;
{$mode objfpc}
{$namespace teste}
uses jdk15;


 
var
    Fr: jsJFrame;
   
begin
    Fr:=JsJFrame.Create('Teste');
    Fr.setContentPane(jsJLabel.create('Olá Mundo'));
   
    fr.pack;
    fr.setVisible(True);
end.

A linha
{$mode objfpc}
indica para usar o modo de Object Pascal do FPC. Sim, o compilador pode suportar vários dialetos da linguagem Pascal. O objfpc é o default se você usa Lazarus.

A linha
{$namespace teste}
indica em que pacote Java a Unit salvará as classes geradas.

Os pacotes do Java possuem uma nomeclatura diferente no Pascal. Elas possuem um prefixo que é a primeira letra do pacote da classe. Assim o javax.swing.JFrame se transforma em jsJFrame.

Compilar o programa é assim:
ppcjvm.exe -O2 -g testeSw.pas

Executar vai necessitar algumas bibliotecas de Run-Time do FPCJVM.
 java -cp .;..\units\jvm-java\rtl teste.testeSw


Limitações:

O compilador possui várias limitações devido às diferenças entre as linguagens de programação (ex: Java não suporta ponteiros). Eu me lembro de algumas:
  • Não suporta nenhuma unit do Pascal, exceto por jdk15 ou android14.
  • Permite declarar ponteiros, e deferenciá-los diretamente, mas não permite que se faça aritmética com eles.
  • Não é permitido procedures/funções com parâmetros out ou var.
  • Várias funcionalidades do Java, como anotações, interceptadores não são suportados.

Mais info: http://wiki.freepascal.org/FPC_JVM/Language

terça-feira, 7 de outubro de 2014

Fazendo backup do PostgreSQL

O PostgreSQL é conhecido por sua facilidade de fazer backups.
Ao contrário do MyIsam do MySQL, ele é capaz de fazer o dump sem bloquear as tabelas. E de versões antigas do Firebird,  o backup não costuma sair corrompido.

ATENÇÃO: O dump do banco só deve ser feito se os dados não forem críticos demais e o volume dos dados não for alto demais. Caso contrário deve-se fazer um backup contínuo, que é mais seguro.


1-)Fazendo um dump da database.
O dump  pode ser gerado em formato custom, tar ou plain (SQL).

Chama-se o utilitário pg_dump , ou o PgAdmin3 para fazer o dump.

# pg_dump -b -h myhost -U myuser mydatabase > mybackup.backup
Existem outras opções, por isso pode ser preciso chamar pg_dump --help.


2-)Restaurando o backup:

2.1-)Para um backup em texto:
# cat /mnt/backup/backup.sql|psql -U myuser -h myhost mydatabase

2.2-)Para um backup custom, é necessário descompactar o backup com o comando pg_restore primeiro:
# pg_restore /mnt/backup/backup.backup|psql -U myuser -h myhost mydatabase


quarta-feira, 24 de setembro de 2014

Configurando o PostgreSQL


O banco PostgreSQL é um banco objeto-relacional, conhecido por sua estabilidade e larga lista de funcionalidades, das quais incluo:

  • Suporte a transações (dãã).
  • Triggers (dãã) .
  • Backups quentes, incrementais (PITR), robustos e em saída SQL opcional.
  • Stored Procedures: em linguagem PL/Pgsql, ou em um vasto número de linguagens plugins.
  • Suporte a XML e JSON!
  • Plugin de geoprocessamento disponível (PostGis).
  • Pode importar e exportar CSV. 
  • Replicação.
  • Commit assíncrono (asynchronous commit).
  • Foreign Data Wrappers (FDW).
  • Full Text Search (FTS) com dois algoritmos de índice diferentes (GIN e GiST).

As versões mais novas melhoraram muito no quesito performance e escalabilidade, e também a popularidade desse banco aumentou nos últimos anos.

A configuração do PostgreSQL pode melhorar em muito sua performance, e chega a assustar quem acredita na sua fama de ser um banco pesado.

Os parâmetros de memória ficam no arquivo postgresql.conf, há alguns que destaco:

  • shared_buffers = Memória compartilhada do banco. Existe apenas um buffer desse em todo o sistema (ele é compartilhado). Em média 25% de toda a RAM do computador. No Linux, em versões antes do 9.3,  você terá também que setar um parâmetro de memória com sysctl -w kernel.shmmax=XXXXXXXXXX.
  • checkpoint_segments = Número de arquivos de segmentos de checkpoint. Quando há escrita intensa, o banco dá um "travadinha" e o arquivo de log do servidor dá uma mensagem para aumentar esse parâmetro. Nesse caso aumente o valor desse parâmetro de 3 para algo como X = shared_buffers/16MB.
  • maitenance_work_mem = Memória usada para operações de DDL, como ALTER TABLE, CREATE INDEX. É usada essa quantia apenas durante essas operações.
  • work_mem = Memória usada para operações de ORDER BY, etc. Cada conexão usa um buffer desses.
  • temp_buffers = Memória usada para tabelas temporárias, etc.Cada conexão usa um buffer desses;

Configurando o Firebird

Este blog de agora em diante se chama Linuxmissãocrítica, porque abrange  Linux. Não apenas Slackware como antes (Missão Slackware).

Em outro post, nós vimos passo a passo como compilar e instalar o Firebird no Slackware Linux.

Compilá-lo é um modo de dar melhor performance, por setar as flags do processador, ele irá funcionar somente para aquela CPU,e usará todas as instruções disponíveis nela para melhor performance, ao invés de apenas instruções genéricas 386 ou x86_64.


Abra o arquivo firebird.conf do servidor:

O Parâmetro de memória DefaultDbCachePages. Ele indica o quanto de páginas de memória são alocadas por database (SuperServer) ou por conexão (Classic/SuperClassic).
Ele é de 2048 por default (75 no SC/C), multiplicando por 8192 bytes (o tamanho de uma página do FDB) dá 16 megabytes, muito pouco.

O Parâmetro TempBlockSize indica a memória temporária para order by e datasets, etc. Se você usa bastante pode aumentar.

O parâmetro TempCacheLimit indica o quanto de memória temporária pode ser deixada em memória.

O detalhe safado é o CpuAffinityMask. Ele indica quantas CPUs serão utilizadas no SuperServer do Windows. Mas deve ser informado em máscara de bits. Safado porque se não for setado o Firebird suará apenas a primeira CPU:
1 = Primeira CPU
3 = Duas primarias CPUs
15 = Quatro pimeiras CPUs

Estes últimos dias eu tinha feito testes severos com o Firebird no JMeter, além de ler muitas matérias na web, e cheguei à conclusão destes parâmetros, que modificadas corretamente podem melhorar grandemente a performance.
Existem muitas outros parâmetros que não consegui um ajuste fino, mas deve existir como ajustar.

domingo, 17 de agosto de 2014

Conectando o PostgreSQL com outros bancos: FDW

Foreign Data Wrappers implementam a especificação SQL/MED de 2003, para manipulação de dados externos.

Surgiram no PostgreSQL 9.1 ainda como somente-leitura. No PostgreSQL 9.3 essa extensão pode ser leitura e escrita, dependendo da maturidade do plugin utilizado.

https://wiki.postgresql.org/wiki/Foreign_data_wrappers

 Neste exemplo nós vamos utilizar o file_fdw para ler um arquivo CSV, e associá-lo como uma tabela no banco:

#psql -U postgres teste
#create extension file_fdw;
#create server arquivos foreign data wrapper file_fdw;
#create foreign table empregado_csv (
# id integer,
# nome varchar(4000),
# data_contrato varchar(20),
# data_demissao varchar(20)
# ) server arquivos options (format 'csv', filename '/tmp/empregado.csv', delimiter ';', header 'true');

-No exemplo, eu instalei a extensão file_fdw com o comando create extension. É necessário apenas uma vez por banco de dados criado.
-O comando create server cria um servidor. No caso é para ler arquivos CSV,.
-O comando create foreign table cria uma tabela, em que a estrutura deve estar com a do arquivo CSV. No final eu indico o server e as opções de CSV, inclusive o caminho do arquivo. Existem mais opções para o CSV, consulte a documentação do PostgreSQL.


select * from empregado_csv limit 100;
O comando vai abrir o arquivo CSV nas primeiras 100 linhas.



No próximo exemplo, vamos instalar o Oracle Client, o plugin do Oracle e abrir uma tabela de um servidor Oracle no PostgreSQL!!

1-) Instale o Oracle Client, se já não estiver instalado.
2-) Baixe o fonte do oracle_fdw no site https://wiki.postgresql.org/wiki/Foreign_data_wrappers.
3-) Descompacte e make NO_PGXS=1&&make install.

#psql -U postgres teste
#create extension oracle_fdw;

#CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//dbserver.mydomain.com/ORADB');

# GRANT USAGE ON FOREIGN SERVER oradb TO usuariodopg;

# CREATE USER MAPPING FOR usuariodopg SERVER oradb OPTIONS (user 'orauser', password 'orapwd');
#CREATE FOREIGN TABLE oratab ( id integer OPTIONS (key 'true') NOT NULL, 
#text character varying(30), 
#floating double precision NOT NULL 
#) SERVER oradb OPTIONS (schema 'ORAUSER', table 'ORATAB');

-Observe que isso se parece um pouco com o file_fdw, mas deve informar o SID do servidor Oracle no comando create server , e o usuário e senha no comando create user mapping.
-Se você não especificar a chave primária da tabela com OPTIONS (key 'true') não vai poder atualizar registros.


Outra coisa é que é possível copiar uma tabela externa para uma real com o comando create table as:
# create table pgtab as (select * from oratab);


domingo, 15 de junho de 2014

Criando um servidor VNC Linux com tightvnc

O VNC é um protocolo de virtualização de Desktop via rede, no Linux funciona de forma interessante. Não apenas acesso remoto à desktop de um usuário, mas também como servidor de desktop, que é muito mais leve e eficiente que o SSH.

Quando uma conexão quebra, o VNC mantém no lado do servidor ela ativa. Basta se conectar de novo e a tela estará lá, onde estava, sem fechar nenhum aplicativo.

O VNC funciona por usuário e cada conexão é uma porta. A porta 5901 é o canal 1, a porta 5902 é o canal 2 e assim por diante.

Depois de instalar o tightvnc como servidor, você deve ligar o servidor com o mesmo usuário que vai acessar o Desktop Virtual.

O servidor tightvnc funciona via comando:
vncserver :1

  • :1  Indica a porta que ele deve estar escutando. 
  • Pela primeira vez que ele executa, vai pedir a senha para acesso. Se você quiser mudar a senha depois use o comando vncpasswd.
  • Ele vai abrir o twm como gerenciador de janelas default. Para mudar isso, modifique o arquivo .vnc/xstartup.

A parte mais divertida da brincadeira é que ele pode ser acessado via celular com um programa cliente de VNC, como o bCNV ou do AndroidVNC.

Além disso o XFCE funciona muito bem com VNC, mas o KDE é bem pesado por causa da parte gráfica dele.

Instalando multilibs no Slackware64

O melhor modo de funcionar e compilar programas 32 bits no Slackware 64 bits é utilizando o pacote multilib, do Alien Bob, um dos membros do Slackware team.

Os programas 32 bits também vão precisar de dependências, o que o blackpkg pode instalar, a partir da versão 1.2, ele pode usar a opção -m32 para compilar e instalar um pacote como de compatibilidade 32 bits.

Por exemplo:
blackpkg -y -m32 soundtouch
Isto vai instalar o soundtouch como um pacote de compatibilidade de 32 bits no Slackware 64.

  • Instalando multilib no Slackware64:
mkdir 14.1
cd 14.1
lftp http://www.slackware.com/~alien/multilib/14.1/
mirror .
exit
upgradepkg --install-new *.t?z
upgradepkg --install-new slackware64-compat32/*-compat32/*.t?z

Os pacotes estarão instalados e o seu Slackware será mutilib assim que você reiniciar a máquina.

Mais informações: http://www.slackware.com/~alien/multilib/

sábado, 24 de maio de 2014

Compilando o KDE

Como o KDE 4.5 é pesado, mas é possível compilá-lo para melhorar a performance como o Dolphin, que leva um tempão pra abrir.

Para compilar, baixe a pasta KDE dos fontes do Slackware e edite o arquivo KDE.options. Ao final do arquivo e não no começo coloque:

export SLKCFLAGS="-O2 -march=native" #(Se for 32 bits)
export SLKCFLAGS="-O2 -march=native -fPIC" #(Se for 64 bits)

Isso já basta porque os scripts do Slack foram feitos para serem recompilados pelo usuário.
-march=native  vai permitir que o processador seja detectado pelo GCC ao invés de usar instruções genéricas como -march=486 (486).

È óbvio que não vai funcionar estes pacotes em outra máquina, mas é o que queremos: que seja otimizado ao máximo para a máquina atual.

Depois de terminado cada pacote os scripts vão instalar o KDE novo. Se tiver o KDE já instalado, você vai ter que dar upgradepkg --reinstall /tmp/kde-build/*.t?z.


terça-feira, 21 de janeiro de 2014

Compilando o Firebird SQL no Slackware

O banco relacional Firebird é muito usando no mundo Delphi/Lazarus. Ele é de pequeno porte, mas contém funcionalidades como transações, MVCC, stored procedures,  UDFs, etc.

ATENÇÃO: As databases do firebird performam extrememente mal em partição ext4, mas para isso existem algumas opções:
  1. Pôr em uma partição xfs (a melhor performance).
  2. Pôr em uma partição ext3.
  3. Montar a ext4 com a opção barrier=0, o que vai diminiur a segurança do journaling para o nível de uma ext3.

O Firebird possui 3 arquiteturas de servidor: o SuperServer, o SuperClassic e Classic (os dois últimos são compilados juntos, ufa!).

  • O SuperServer é feito para máquinas mais leves, pouco suporte a várias CPUs, mas ele compartilha bem os recursos entre as conexões, tornando-se escalável se o hardware for pequeno. Ele cria um processo fbserver que serve todas as conexões.
  • O Classic é feito para máquinas pesadas e muitos usuários, suporte a várias CPUs, ele não usa recursos compartilhados e sim dedicados a cada conexão. Ele cria um processo fb_inet_server para cada conexão.
  • O SuperClassic surgiu a partir do Firebird 2.5, ele é uma evolução do Classic. Na verdade possui o gerenciamento do Classic, com recursos dedicados (sem memória compartilhada), mas abre apenas um processo fb_smp_server  que serve todas as conexões.

Para compilar baixe os fontes e dê os seguintes comandos:
tar xvf Firebird-xxxx.tar.gx -C /root/
export CFLAGS="-O2 -march=native -mtune=native"
export CPPFLAGS="-O2 -march=native -mtune=native"
export CXXFLAGS="-O2 -march=native -mtune=native"
./autogen.sh --with-system-icu --enable-superserver
make
make install

  1. Note que pôr --prefix=/usr vai dar erro, ele deve ir pra outra pasta mesmo.
  2. Para compilar o Classic/SuperClassic remova o --enable-superserver

Para configurá-lo é matéria pra outro post. Mas geralmente ele não precisa muita complicação.
Crie um usuário e grupo firebird:

groupadd firebird
useradd -g firebird firebird

Depois de compilado vá para /usr/local/firebird/bin e rode su firebird -c "./fbguard"
Depois é só instalar o flamerobin ou o SQuirrel e começar a usar.