Shell script para backup de Wal Files!

Esse é um simples shell script que eu utilizo juntamente com o crontab para realizar meus backups de arquivos wal. Para que não sabe do que se trata depois eu posto como se configura!!!

PS: Eu agendo uma fez por semana!

#!/bin/bash

#### Diretório de dados do postgresql ######
PGDATA=/data
SAVE_BASE_DIR=/home/postgres/arquivosbase
data=$(date +’%d%m%y’)

#### Diretorio setado para o Wal Files no postgresql.conf ####
WAL_DIR=/wallfiles

### A cada novo backup ele remove Diretorio $WAL_DIR/anterior ###
rm $WAL_DIR/wal_anterior/*

### Move os Wal gerados anterior e salva para caso de falha #####
mv /$WAL_DIR/* /$WAL_DIR/wal_anterior

export PGPASSWORD=”password”
psql -U postgres -h localhost -c ‘select pg_start_backup(‘$data’);’ template1 && \
tar -czvf $SAVE_BASE_DIR/$data.tar.gz $PGDATA && psql -U postgres -h localhost -c ‘select pg_stop_backup();’ template1

Anúncios

Tricks on BASH!

É aquela velha história, vivendo e aprendendo!!!!

Ontem em um dos meus estudos em busca da tão tardia LPI, me deparei com uma muito funcionalidade interessante( não sei se bem exclusiva do bash, confesso que nunca mechi Intensamente em outros shells (sh,ksh….) )
Bem… Todo mundo cansa de utilzar os recursos de history do bash usando as teclas para cima e para baixo para acessar os ultimos comandos digitados. O que ocorre que digitei uma determinada linha de comando e gostaria de executar novamente ,somente mudando alguma string.
Então utilizo a seta para cima , e com a seta <- -> vou navegando no comando até onde desejo modificar a string e depois mando um belo <ENTER>:

ex: psql -U postgres -h servidor1 bd_producao

Essa foi uma linha que eu havia digitado anteriormente e gostaria de utilizar o mesmo comando , modificando a string postgres por usuario1
então usaria a tecla para cima ,as teclas de <- até a palavra postgres e backspace para apagar a palavra e digitar usuario1

Beleza!!

é bem mais simples utilizar

^postgres^usuario1

Parece tolice mas economiza um tempo considerável!!!

Rapidinhas do pg_dump + SED

Hoje um desenvolvedor pediu que eu copiasse uma determinada tabela de um banco de dados ,criasse a bendita em outro banco de dados com outro nome . Tarefa simples, principalmente quando utilizamos o poderoso SED.

pg_dump -U usuario -h servidor1 -t tabela banco1 | sed ‘s/tabela/tabela_temp/g’ | psql -U usuario -h servidor2 banco2

🙂

Uma pequena introdução sobre Buffer Cache!

O nível mais baixo de software na arquitetura do banco de dados é chamado gerenciador de espaço de disco, ele gerencia o espaço em disco. Asbtraindo, o gerenciador de espaço de disco suporta o conceito de página como unidade de dados, e prove comandos para alocar ou desalocar uma página quando é lida ou escrita. O tamanho de uma página é escolhido para ser o mesmo tamanho de um bloco, e as páginas são gravadas como blocos de maneira que uma leitura ou escrita de uma página é feita em uma operação de I/O de disco.

A grande maioria das vezes é útil alocar páginas em sequencias de blocos, dados que são acessados sequencialmente. Essa caracteristica e muito explorada como vantagens de um acesso sequencial nos blocos do disco. O gerenciador de espaço de disco esconde os detalhes mais baixos do hardware e possivelmente do sistema operacional e possibilita as aplicações de alto nivel pensar como um dado uma colecao de paginas.

Mapeando os blocos vazios

O banco de dados cresce , registros sao inseridos e deletados ao longo do tempo. O gerenciador de espaço de disco gerencia quais blocos estão em uso, e quais páginas estão em quais blocos. Inicialmente todos os blocos sao alocados sequencialmente no disco, com alocações e desalocações são criados buracos no disco.

Uma maneira de gerenciar os blocos e manter uma lista de blocos livres. Quando os blocos sao desalocados eles sao adicionados na lista de blocos livres para uso futuro. Um ponteiro para o primeiro bloco da lista de blocos livres e armazenado em uma localidade conhecida do disco.
Uma segunda maneira e manter um mapa de bits. um bit para cada bloco de disco indicando quais os bloco estao em uso e quais nao estao.

Buffer mananger

Para entender o papel do gerenciador de buffer, considere o seguinte exemplo: Suponha que um banco de dados contém 1.000.00 de paginas, mas somente 1.000 paginas da memoria principal está disponivel para cache dos dados. Considere uma query que requer um scan em todo um arquivo. Como ele nao pode ser deslocado para a memoria principal de uma so vez, o SGBD deve trazer as páginas dentro da memoria principal a medida que elas sao necessitadas, e nesse processo, decide quais páginas existentes na memoria principal irá sair para as novas páginas que foram solicitadas entrarem. A politica usada para decidir qual página irá sair da memoria principal e chamado de politica de substituição.
O gerenciador de buffer é uma camada de software que é responsável por trazer páginas do disco para a memória principal quando necessário. O gerenciador de buffer gerencia a memoria principal disponivel particionando ela em coleções de páginas, coletivamente chamadas de buffer pool. As páginas da memória principal que fazem parte do buffer pool sao chamados de frames, é mais fácil imagina-las como slots que contém as páginas,que usualmente residem no disco.
As aplicações de alto nivel sao escritas sem se preocupar se as páginas estão ou não em memória, elas perguntam ao gerenciador de buffer pela página, e ele se encarrega do resto, se a página nao está no buffer pool o gerenciador solicita a página e a coloca no buffer pool.
Obiviamente as aplicações de alto nível que fazem a requisição das páginas devem descartar a página quando nao mais necessário, informando o gerenciador de buffer, para que ela possa ser reutilizada. Também devem-ser informada ao gerenciador de buffer se a página requisitada foi alterada, entao o gerenciador propagara as mudanças copiando a página para os discos

———————————————–
|||||||||||||X|X|X|X||||||||||||||||||||||||X| | | páginas livres
———————————————–
||||||||||||||||||||||X|X|X|X|X|X|X|||||||| |X| |X| páginas ocupadas
———————————————–
||||X|X|X|X|X|X|X|X|||||||||||||||||||||||||||
_______________________________________________

Se uma página requisitada nao se encontra no buffer pool
e o buffer pool esta cheio, o buffer deve executar a politica
de realocação de paginas para serem realocadas.

|
Banco de dados

O gerenciador de buffer mantem duas varivaeis para cada frame no buffer pool: pin_count e dirty
pin count: número de vezes que uma página é requisitada concorrentemente.
Dirty indica se a página sofreu modificações desde que ela foi trazida do disco para o buffer pool.
Inicialmente o pin_count para todos os frames é 0 e o dirt bit está off. Se a página nao esta no pool o gerenciador do buffer age do seguinte modo:

Escolhe um frame para ser substituido, usando a a politica de substituição, e incrementa o pin_count
Se o dirty bit do frame a ser substituido estiver on, escrever a página no disco.(Substituir a página que esta no disco pela página
que esta no buffer)
Ler a página requisitaca dentro do buffer pool no lugar da outra.
Retonanar o endereço do frame que contém a página requisitada.

Aumentar o pin_count é chamado de pinning. Quando uma determinada página do buffer é solicitada e depois ela e devolvida ao buffer o pin_count do frame e decrementado. Isso é chamado unpining. Se a página solicitada e alterada, quando a página e devolvida ao buffer ocorre o unpining e o dirty bit e setado para on. O gerenciados do buffer nao irá colocar uma página no disco em lugar de outro no buffer até que o pin_count seja != 0, ou seja ate que todos as requisições de determinada página tenham devolvidos.

Se uma determinada página não se encontra no buffer pool,e se não existem frames livros no buffer pool, um frame com pin_count =0 é escolhido para substituição, segundo a política de realocação do gerenciamento de buffer.Quando uma página e eventulmente escolhida para set substituida, e se o seu dirt bit não esta setado, isso significa que a página não foi modificada desde que foi trazida do disco para a memória principal. Entao nao há a necessidade de escrever a página novamente no disco. Se o dirty bit estiver setado entao e necessário copia-lo ao disco novamente.
Se nao existir nenhuma pagina no buffer pool com pin_count =0 e a pagina requisitada nao estiver no pool, o gerenciador do buffer pool ira esperar ate que uma página e desalocada.Na pratica a transação é abortada. Entao as paginas requisitadas tem que ser desalocadas o mais rápido possível

Politica de substituicao do gerenciador de buffer

A politica usada para escolher uma página para ser substituida pode afetar o tempo de um banco de dados consideravelmente. Algumas alternativas de politicas podem existir, e cada uma cabe em uma situação diferente.
A policia mais conhecida e a LRU (lest recently used). Isso pode ser implementada no buffer mananger usando uma fila de ponteiros apontando para frames com pin_count 0.Um frame é adicionado ao final da fila quando ele se torna candidato para ser substituido.(quando o pin_count vai a 0). A página escolhida para ser substituida esta na cabeça da fila.
Outra variante chamada clock.

Gerenciador de buffer X Sistema operacional

Obiviamente existem similiaridades entre memoria virtual nos SO e o gerenciador de buffer em SGBDs. Nos dois casos o objetivo e prover acesso a mais dados que cabem na memoria, e a ideia basica e trazer as paginas de disco para a memoria principal quando solicitado.Porque o banco de dados nao utiliza o sistema de memoria virtual do SO? O SGBD pode prever a ordem em que as paginas vao ser acessadas, definidos por padroes melhor do que o gerenciamento de memoria virtual
do SO.SGBD necessita de mais controle sobre as paginas do que o Proprio SO.
O SGBD pode as vezes prever baseado em padrões, quais páginas futuras vão ser requisitadas, podendo usar uma estrategia chamada como prefetching. o gerenciador de buffer pode antecipar as proximas paginas e coloca-las no buffer antes de serem requisitadas. Isso tem dois beneficios:
As paginas disponiveis no buffer pool quando requisitadas
Ler blocos continuos de paginas e muito mais rapido do que ler a mesma pagina em tempos diferentes.