Como restaurar backups em uma tabela PostgreSQL

De tempos em tempos eu preciso restaurar um backup de alguma tabela para outra ou preencher a tabela de um novo ambiente de desenvolvimento local com dados reais para testes. Como não é uma tarefa diária, nem sempre me lembro como faz, então resolvi juntar aqui o passo a passo até pra facilitar nas próximas vezes e talvez possa também ajudar alguém.

Antes de poder restaurar algum backup, precisamos fazê-lo! O comando utilizado para isso é o pg_dump que já nos devolve um dump da tabela inteira – se quiser saber mais clique aqui para ler a documentação.

pg_dump dbname > backupfile.sql

No comando acima, extraímos todos os dados do banco (troque dbname pelo nome da sua tabela) e jogamos em um arquivo .sql. Pronto, já temos o backup salvo. Dica: esse é um jeito bem fácil de manter backup de seus bancos. Recomendo criar um comando que faça esse backup e utilizar o Cron para fazer isso automaticamente sempre.

Para restaurar o backup num banco, o postegres também nos permite fazer isso de um jeito bem simples, mas tem alguns detalhes:

1) o banco precisa existir com o mesmo nome do banco que foi extraído.
2) o banco não pode ter as tabelas criadas, senão vai dar conflito e a restauração não vai dar certo.

Nesse caso, se o banco já existir primeiro eu dou dropdb db_name que vai deletar o banco (IMPORTANTE, eu só faço isso em bancos locais, porque isso apaga todos os dados do banco, então NUNCA faça isso em produção a menos que você saiba exatamente o que está fazendo. Dá justa causa, hein? Deus tá vendo). Depois de deletar, precisamos recriá-la senão a restauração não vai funcionar por não encontrar o banco. Para recriá-lo: createdb db_name

Por fim, para restaurar os dados, jogamos o arquivo no novo banco:

psql dbname < infile

Pronto, temos um banco restaurado! Para mim esse processo é fundamental em dois momentos: quando por algum motivo – normalmente tenso – eu preciso restaurar o banco em produção ou quando vou começar um novo ambiente de desenvolvimento e preciso de dados para testar o app e as mudanças que estou fazendo.

Como gravar sua tela em gifs animados no Linux

UPDATE 26/06/2017: Encontrei uma opção bem mais interessante, o Peek que tem uma interface gráfica simples, mas que nos permite selecionar com o mouse a área que será gravada, além de controlar visualmente o início e fim da gravação. Testei no Fedora 25 e rodou tranquilamente, vale a pena dar uma olhada: https://github.com/phw/peek

Todo mundo que me conhece sabe que sou fã incondicional de gifs animados. Ultimamente fui surpreendida pela popularização da utilização de gifs em tutoriais e documentações técnicas, algo que eu ainda não havia pensado sobre mas que achei genial pela simplicidade e eficiência dessa prática. Além de tornar documentações e tutoriais muito mais envolvente. Veja um exemplo que estamos usando na Escola Mupi (aqui tem uns legais também):

Existem várias formas de se fazer isso. Você pode, por exemplo, gravar sua tela em video e depois editar exportando para gif (o Adobe Premiere faz isso, Camtasia também, e existem alguns programas só para este fim). Mas como uso Linux, precisei aprender como fazer isso sem esses programas que só rodam no Windows ou Mac OS, e encontrei o Byzanz, que você pode ver seu código aqui.
O Byzanz permite gravar a tela diretamente em um gif animado. Como não encontrei muitas informações sobre ele (parece que seu site está fora do ar), resolvi criar esse tutorial para ensinar como utilizá-lo, já que o achei super simples e soluciona muito bem essa necessidade.
Spoiler: é tudo pela linha de comando então se você, assim como eu, tem muito apego visual, recomendo um pouquinho de paciência que no fim das contas é simples de usar e é possível que você vicie e queira gravar tudo! 🙂

1 – Instalar o Byzanz Abra o seu terminal e execute os passos abaixo para instalar o Byzanz.
Se você usa Fedora e Gnome, o byzanz já está no repositório do Fedora então basta instalar:

$ sudo yum install byzanz

No Ubuntu 14.04:

$ sudo add-apt-repository ppa:fossfreedom/byzanz
$ sudo apt-get update
$ sudo apt-get install byzanz

2 – [Opcional] Instalar o Wmctrl
Esse passo é mais uma dica, ele não é necessário. Mas através do Wmctrl (um comando que permite você gerenciar suas janelas) a gente consegue experimentar tamanhos e posicionamentos de janelas para definir a área a ser gravada antes de usar o Byzanz.
Para instalar é igual ao passo 1:
– Para Fedora:

$ sudo yum install wmctrl

– Para Ubuntu:

$ sudo apt-get install wmctrl

Se não achar o Wmctrl, leia este tutorial.

3 – Definindo o tamanho da janela que você quer gravar.
Com o Wmctrl fica bem mais fácil essa etapa, por isso o passo dois. A linha abaixo está dizendo para posicionar a janela atual (no caso sua janela do terminal) se posicionar 500 pixels à direita (eixo x), 100 pixels abaixo (eixo y), com a largura (width) de 800 pixels e altura de 600 (altura) pixels. A opção -e significa que ele vai redimensionar a janela com os parâmetros definidos.

$ wmctrl -r :ACTIVE: -e 0,500,100,800,600

E é só isso que precisamos do Wmctrl, se quiser ver mais opções é só ver o help do Wmctrl com o comando $ wmctrl --help. Agora você pode ficar experimentando os valores até achar o que quer:
terminal

4 – Gravando a tela com o byzanz
Com os valores de tela definido, você posiciona a janela que vai ser gravada, seu navegador por exemplo, no local que ficou sua janela do terminal do passo três.
O uso do byzanz usa os seguintes parâmetros: byzanz-record [opções] nomedoarquivo.gif. No caso do meu exemplo usei o comando abaixo, onde -d 10 se refere à duração da gravação e -c que vai gravar o cursor:

$ byzanz-record -d 10 -c --x=500 --y=100 --width=800 --height=600 terminal.gif

Para conferir o resultado é só ir na pasta onde você salvou e abrir o gif no seu navegador 🙂
Para mais opções do byzanz basta acessar seu manual: byzanz-record --help

E seu gif está pronto! Simples, não? Eu particularmente achei muito melhor do que depender de editores de videos pesados que demoram pra renderizar e são difíceis de mexer.
Agora é experimentar, boas gravações!
Ah, e se for gravar pra web só cuidado com o tamanho final dos gifs, afinal cada frame é uma imagem que podem custar caro pra sua performance.

Preciso modificar um commit passado, como faz?

Nas últimas duas semanas tenho tido um intensivão de aprendizado de git por causa da reformulação do site da Escola Mupi. O projeto usa como base uma plataforma que se chama Timtec, mas que ainda está sendo desenvolvida, logo muitos bugs, features faltando e muitos merge conflicts… Eu que ainda estou descobrindo as magias do git, tenho uma relacionamento de amor e ódio, pois já fiz muita besteira e perdi muitas horas de trabalho por não saber como ele funciona direito, assim como ele já me salvou muitas vezes <3

Esses dias, precisei adicionar alguns arquivos num commit antigo para manter minha árvore organizada e coerente. Para isso, @padovan me ensinou a resolver esse problema usando fixup + rebase interactive [que eu particularmente achei incrível]. Vamos lá:

Antes de iniciar, você precisa copiar um pedaço inicial do hash do commit que você deseja modificar. O hash é o código de identificação do commit, exemplo: 636bf2643e67bf34f67691333b916e292571a469. No caso os 6 primeiros caracteres já são suficientes. Você pode achar o hash com o comando git log.

Tendo isso copiado, deve-se fazer um “fake” commit. Ou seja, criamos um commit que servirá apenas como um repositório temporário das novas modificações que serão acrescentadas ao commit desejado. Para isso usamos o seguinte comando:

$ git commit --fixup=636bf26

Isso cria um commit com a mensagem “fixup! + msg do commit selecionado”. Isso ajuda a identificar que esse não é um commit convencional, mas que precisa ser “fixed up”. Feito isso, agora vem a magia: git rebase --interactive ou git rebase -i. O rebase interactive dá muito mais flexibilidade para modificar os commits. Para usá-lo precisamos indicar a quantidade de últimos commits a serem mostrados a partir do HEAD. No meu caso, os 4 últimos commits foram suficientes:

$ git rebase -i HEAD~4

que nos dá no editor padrão do terminal a quantidade indicada de commits em ordem do mais antigo ao mais novo, assim como todas as opções do rebase interactive. Nesse exemplo só vamos utilizar fixup (note que existem outras opções pra rebase interativo que podem ser muito úteis em outras situações):

Para a magia acontecer, é preciso escrever f no lugar de pick na frente do commit de fixup e modificar a ordem dos commits, colocando-o logo abaixo do commit desejado:

Agora é só salvar e voi lá! o “fake” commit é fundido no commit de cima =) é só dar um checada se deu tudo certo com git log.

UPDATE: Como pode se ver na primeira imagem, existem outras opções bem interessantes para se usar no rebase interativo, como o reword, que permite modificar apenas a mensagem de algum commit, e o squash que permite juntar dois ou mais commits em um só. Para quem lê em inglês, sugiro este artigo do github a respeito e dou um quote de alerta (tradução livre minha): “É considerada uma má prática dar rebase em commits que já foram submetidos ao repositório remoto. Ao fazer isso, você poderá invocar a ira dos deuses do git”.

obs.: Para modificar o último commit feito, git commit --amend é a melhor opção, já que “reabre” o último commit para edição.