Docker

Docker é uma plataforma, desenvolvida em GO, de código aberto para a execução de programas utilizando a técnica de containers.

Caso já tenha ouvido falar de Docker, deve ter observado que o assunto é bem extenso e isso pode ocasionar algum mal entendidos sobre a forma que o Docker trabalha. Para evitar algumas confusões com todas essas informações, vamos falar um pouco sobre o que o Docker não é! Para início, o Docker não é um virtualizador comum, ele não trabalha com Virtualização Total e Paravirtualização. Muitos tentam associar o Docker a estes termos assim que passam a ter um primeiro contato com a ferramenta.

A Virtualização Total simula um hardware completo e dedicado a VM, o S.O não sabe que está sendo virtualizado. Já na Paravirtualização ocorre o oposto, não há hardware completo e dedicado emulado, o S.O tem consciência de que está sendo virtualizado e o seu Kernel já é voltado para trabalhar desta forma, interagindo de forma harmoniosa com a camada Hypervisor.

O Hypervisor pode ser visto como uma camada de software em cima do hardware ou em cima de um S.O que está sobre o hardware. Ele é o responsável pelo gerenciamento das VMs, também controla o acesso aos recursos do Hardware real solicitados pelos S.Os residentes nas VMs.

Passada essas informações iniciais, vamos entender a diferença entre a virtualização comum e a utilização de containers. Na virtualização comum, o S.O convidado possui seu próprio Kernel. Isso não acontece no Docker, pois ele utiliza o Kernel do S.O instalado na máquina física. O Docker utiliza a técnica de containers e estes só carregam aquilo que é necessário para o seu funcionamento. Eles não são Máquinas Virtuais, eles são, simplesmente, containers.

Como forma de exemplo, podemos associar um container a um envelope, onde dentro desse envelope está o espaço de trabalho. Um container é o espaço de trabalho, onde se dá a execução de uma aplicação, por exemplo. A grosso modo, o container isola o processo e as suas dependências dentro de um espaço sem a necessidade de um novo sistema operacional completo para a execução desse processo.

Essa ideia de container não é nova, porém ganhou mais notoriedade com a popularização do Docker em 2015. Essa ideia, de forma bem simples, começou no Unix com o chroot e aos poucos foi se atualizando, passando pelo Jails no Freebsd e Solaris Zones da Sun, por exemplo. Antes do Docker, a plataforma mais conhecida era a LXC, criada em 2008, que era uma melhoria do chroot.

A imagem acima exemplifica bem essa ideia. Na esquerda, um exemplo de Infraestrutura baseada em virtualização comum utilizando a camada Hypervisor. Para a execução das aplicações é necessário um sistema operacional, depois a camada Hypervisor, um outro sistema operacional, porém virtualizado com as bibliotecas e dependências instaladas e só depois a execução da aplicação.

Com o Docker, algumas dessas camadas são eliminadas. Há o sistema operacional base, a Docker Engine, as bibliotecas e dependências, e o container com a aplicação. A camada Hypervisor dá lugar ao Docker Engine que permite que o Kernel seja acessado diretamente pelas aplicações, assim eliminando a necessidade de um sistema operacional para cada aplicação e compartilhando um único Kernel.
Resumindo: com o Hypervisor um sistema operacional completo é virtualizado para poder executar a aplicação. Já o Docker executa a aplicação sem a necessidade de um sistema operacional completo e aproveitando o Kernel do sistema operacional já instalado, sem a necessidade de criar outro sistema operacional de forma virtualizada. Ou seja, com container é possível virtualizar a nível de S.O, iniciando-o como um “processo”.

 

Esse foi o primeiro post sobre Docker e como você pode observar, tem muita informação nova e muitos conceitos. Os próximos posts serão mais práticos
Para uma leitura complementar recomendo a documentação do Site Oficial do Docker, o Mundo Docker e o Canal Linux Tips.
Agradecimento ao Will de Souza pela co-participação do post.

Ao som de Death – Symbolic

Dica rápida sobre fazer uma conexão ssh sem senha.
Nesse cenário há dois “PCs”:
O primeiro, um cliente que vai ser conectar ao servidor via SSH.
O segundo, é o servidor que vai receber a conexão ssh do cliente.
Ex: Seu Debian 8 (PC01) vai se conectar ao servidor CentOs7 (PC02) utilizando SSH.

Serão utilizadas duas chaves: uma pública e uma privada.
Essas chaves serão geradas no CLIENTE (Debian8 PC01 no nosso exemplo)!
Observação importante: A CHAVE PRIVADA NUNCA DEVE SER COMPARTILHADA! A Chave pública, como o nome diz, pode ser compartilhada normalmente.

Para gerar a chave no cliente (PC01) basta executar o seguinte comando:

ssh-keygen -t rsa

Após isso, o terminal vai exibir algumas informações, sendo que você pode deixá-las todas em branco apenas apertando ENTER em todas as opções.
Uma das informações que serão exibidas é o local onde essas chaves serão armazenadas. Caso esteja utilizando o usuário ROOT, o diretório será “/root/.ssh/”. Caso esteja usando outro usuário, procurar na HOME desse usuário “~/.ssh/”
Agora já temos as duas chaves. A chave privada que foi gerada está no arquivo “id_rsa“. A chave pública que foi gerada está no arquivo “id_rsa.pub

O próximo passo é transferir a chave PÚBLICA para o nosso servidor (Centos7, PC02) utilizando o scp. A transferência será para o diretório “/tmp”

scp /root/.ssh/id_rsa.pub root@ipdoservidor:/tmp/

será exigida a senha

 
Agora acesse o servidor (Centos7, PC02). Pode ser utilizando o ssh também

ssh root@ipdoservidor

será exigida a senha

 
A chave pública está no diretório /tmp que foi transferido anteriormente usando scp.
No diretório /root/.ssh há um arquivo chamado authorized_keys. Esse arquivo contém as chaves públicas autorizadas para a conexão com esse servidor. No nosso caso, vamos copiar o conteúdo da chave pública do cliente (Debian 8, PC02) para dentro desse arquivo.
Pode ser feito abrindo o arquivo onde tem a chave pública, copiando o seu conteúdo, e colando em authorized_keys, porém vamos utilizado o cat para ser mais rápido e prático.

cat /tmp/id_rsa.pub >> /root/.ssh/authorized_keys

o comando “cat” acima leu o conteúdo do arquivo id_rsa.pub e jogou ele para o final do arquivo authorized_keys utilizando o >>, assim não apagando as outras chaves que possam haver já registradas.

Após esses procedimentos, o CLIENTE já conseguirá se conectar utilizando o SSH.

Espero ter ajudado. Qualquer dúvida e sugestão só deixar nos comentários.
Abraços e até mais.

Script que fiz juntamente com o Will de Souza para realizar o backup do banco de dados MYSQL em um servidor CentOs6.
O script vai, na ordem, verificar se o diretório de destino do backup existe, depois realizar o backup, fazer a retenção local de 7 dias, sincronizar com servidor de backup e por último enviar um e-mail com o log  com o procedimento que foi realizado.
Não existe (ainda) tratamento de erro para o script. A compactação foi realizada utitlizando o gzip. Para realizar o sincronização, é necessário autenticação sem senha utilizando certificados. Para saber como é feito, veja o post sobre o assunto: http://161.35.238.43/linux-conexao-ssh-sem-senha/
O envio do e-mail é feito utilizando o servidor postfix instalado localmente.
Para ser executado automaticamente, basta criar um arquivo e adicioná-lo ao Cron do servidor onde está o seu banco de dados.

Fiquem à vontade para modificar o script de acordo com a necessidade do seu servidor. Qualquer dúvida, sugestão e colaboração pode ser feita através dos comentários do blog.
Abraços e até a próxima.

#!/bin/bash
 
### Script para realizar o backup do banco de dados, compactar com gzip, reter os arquivos locais por de 7 dias, sincronizar com o servidor Storage e enviar um e-mail ao final ###
 
### Definindo as Variáveis ###
 
data=`date +%Y-%m-%d`
logbkp="/etc/bancos/backup/mysql/$data.log"             # Local onde o log ficará armazenado.
dircopy="/etc/bancos/backup/mysql/$data"                   # Diretório onde ficará armazenado o backup.
MySQLUser=root                                                                    # Usuário do banco de dados.
MySQLUserPW='senha123'                                                  # Senha do usuário do banco de dados.
listardbs=`mysql -S /var/lib/bancos/mysql/mysql.sock -N -s -u "${MySQLUser}" -p"${MySQLUserPW}" -e 'show databases;'`                         # Caminho do banco de dados e autenticação.
argumentos="--ignore-table=mysql.event --single-transaction -S /var/lib/bancos/mysql/mysql.sock"
email="usuariodoemail@email.com.br"                              # Endereço do e-mail para ser enviado o log.
echo "----------------------------------------------------" >> $logbkp
echo "[$data `date +%Hh:%Mm:%Ss`] Início do script de Backup do MySQL" | tee -a $logbkp
 
### Verificando o Diretório ###
 
if [ -d "$dircopy" ]; then
echo "[$data `date +%Hh:%Mm:%Ss`] Diretório $dircopy já existe" | tee -a $logbkp
else
echo "[$data `date +%Hh:%Mm:%Ss`] Criando diretório $dircopy" | tee -a $logbkp
mkdir $dircopy
fi
 
### Iniciando o Backup e Compactando com gzip ###
 
echo "[$data `date +%Hh:%Mm:%Ss`] Iniciando o Backup da Base de dados!" | tee -a $logbkp
 
for bancodedados in $listardbs; do
if [ $bancodedados != 'performance_schema' ] ; then
echo "[$data `date +%Hh:%Mm:%Ss`] Backup do $bancodedados" | tee -a $logbkp
mysqldump $argumentos -u "${MySQLUser}" -p"${MySQLUserPW}" $bancodedados > $dircopy/$bancodedados.sql
echo "[$data `date +%Hh:%Mm:%Ss`] Compactando o $bancodedados" | tee -a $logbkp
gzip -9 -f "$dircopy/$bancodedados.sql"
fi
done
 
echo "[$data `date +%Hh:%Mm:%Ss`] Fim do Backup!" | tee -a $logbkp
 
### Retenção e Sincronização ###
 
find $dircopy -iname '$data*' -type d -mtime +7 -exec rm -rf '{}' ';'
 
rsync -AagoPprzqe 'ssh -p 22' /etc/bancos/backup/mysql/* root@192.168.1.1:/BACKUP/BANCOS/MYSQL/  # Aqui coloca-se o endereço do servidor remoto de backup.
 
echo "[$data `date +%Hh:%Mm:%Ss`] Fim do script de Backup do MySQL." | tee -a $logbkp
echo "----------------------------------------------------" >> $logbkp
 
### Enviando o E-mail ###
 
lerlogbkp=`cat $logbkp`
echo "$lerlogbkp" | sendmail -F mysqlbackup-$data $email
echo "[$data `date +%Hh:%Mm:%Ss`] E-mail para $email enviado!"

Download do Script