domingo, 24 de julho de 2016


Hoje vou trazer um cookbook bem bacana para migrar o sistema operacional do raspberry de um cartão de memória para outro sem perder absolutamente nada. O processo só é um pouquinho demorado, então pega um café, abre o chat do Telegram com seus amigos e vamos nessa.

Primeiramente, através de um adaptador USB ou leitor de cartão de seu computado, insira o cartão SD atual e espere o mesmo montar no sistema. O procedimento que iremos realizar, se consiste basicamente em clonar uma imagem do cartão de memória e depois sobrescrever outro cartão de memória maior com ela, e redimensionar o espaço restante manualmente.

O procedimento é bem fácil, só que talvez demore um pouco dependendo do tamanho e da velocidade dos seus Cartões SD no momento.


1 :: Criando uma cópia do cartão atual.

Para criar uma cópia exata, Post Mordem, do cartão SD antigo, iremos utilizar o nosso amigo DD para fazer essa cópia e mais tarde a sobrescrita. Como eu disse, o procedimento é demorado, e o DD não te mostra nenhum status de andamento do job. Para isso, eu gosto de usar a ferramenta PV (Pipe Viewer) que me da a porcentagem de dados enviados entre os pipes dos comandos. Já falei dessa ferramenta neste post.

Liste os discos disponíveis no seu sistema.

Como já foi dito, insira o seu cartão SD por meio de uma leitora ou adaptador, e em seguida utilize o comando fdisk para listar os dispositivos montados. No meu caso estarei migrando de um cartão de 8 GB para um de 16 GB.
 # fdisk -l   


O meu disco é o /dev/sdb, de 7,3 GB.


Criando uma imagem do cartão 

Criando uma imagem com o DD e o PV para medir o progresso da cópia

O PV é um utilitário bem bacana, e está disponível nos repositórios da maioria das distribuições. Basta procurar por ele que com certeza ele vai estar por lá
 # sudo apt-get install pv  # Debian Like
 # sudo yum install pv # CentOS/RHEL 7 

Para fazer uma cópia do disco é simples:
 # dd if=/dev/sdb | pv | dd of=imagem_temporaria.img  

Criando uma imagem do disco com o DD e sem o PV
 # dd if=/dev/sdb of=imagem_temporaria.img  



2 :: Sobrescrevendo o novo cartão com a imagem do antigo. 

Remova o cartão antigo e coloque o novo cartão maior. Novamente, liste todos os dispositivos alocados em seu sistema. Meu novo cartão, possui um tamanho total de 14,9 GB.
 # fdisk -l   

Agora, vamos pegar a imagem temporária que criamos e jogar ela novamente com o DD para o novo cartão de memória, porém vamos "inverter os polos" desta vez.

Restaurando a cópia com o DD e PV
 # dd if=imagem_temporaria.img | pv | dd of=/dev/sdb  

Restaurando a cópia com o DD e sem o PV
 # dd if=imagem_temporaria.img | pv | dd of=/dev/sdb  



3 :: Redimensionando a partição

Coloque o novo SD Card no no Raspberry e espere o Boot do sistema.
Quando ele terminar, logue como Root e entre no menu de gerenciamento do Raspberry Pi
 # sudo su   
 # raspi-config  

No menu de configurações, selecione a opção Expand Filesystem


A opção de expand é automática e o Raspberry faz todo o procedimento, caso não dê certo, te aconselho a realizar manualmente via Diskpart e alocar o redimensionamento você mesmo. Ele demora um poquinho por conta do processamento limitado do processador, mas depois é só sair e reiniciar a plaquinha.

Espero ter ajudado

:)

Raspberry Pi :: Migrando o sistema para um cartão SD maior

domingo, 17 de julho de 2016



Tip mega rápida que eu peguei lá no blog do Linux, Dicas e Suporte do Ricardo. Eu sempre uso essa paradinha e sempre preciso ficar por aí caçando pra lembrar como faz. Espero que esse repost seja bem legal aí pra vocês.

A Imagem do Grub é aquela que aparece quando antes do boot do sistema, quando você está escolhendo o Kernel e/ou Sistema que você vai realizar o Boot. Essa imagenzinha é definida por um parâmetro dentro dos arquivos de configuração do Grub. Para editá-lo basta:
 # vim /etc/default/grub  

Caso não exista, crie o parâmetro GRUB_BACKGROUND dentro do arquivo:
 GRUB_BACKGROUND=/caminho/para/a/imagem.png 

Logo após, basta atualizar o arquivo novo do Grub:
 # update-grub  

Espero ter ajudado :)





Grub :: Alterando a Imagem de Fundo do Grub2 Manualmente


Fala galera, tudo bem? Vim aqui só pra postar o link desse hangout que eu fiz pelo GDG Cabreúva falando sobre Containers Docker e sua utilização dentro do ambiente de desenvolvimento e DevOps. A palestra é level mais "Easy" possível, só pra dar um overview sobre como a ferramenta funciona na unha, sem facilidades como o Dockerfile (Que por um acaso, tem uma demonstração também no final) e o Docker Compose. Toda a apresentação está logo a seguir em vídeo e compartilhamento de tela e os slides estão todos aí também.


Video do Hangout:



Slideshare completo com as referências e Cookbooks



Link com todos os exemplos mostrados

Segue um repositório com todos os exemplos e códigos mostrados na palestra:

https://github.com/msfidelis/GDG-IntroducaoAosContainers


Como continuo a estudar Docker??

Segue uma listinha de fontes pra você se entreter na ferramenta. Usei elas pra aprender também :)



Quem quiser, pode seguir o GDG nos links abaixo, é bem legal, a gente se reúne quase todo mês juntando muita galera e faz coisas bem bacanas pra comunidade utilizando Tecnologias Google. Pra quem quiser conhecer mais sobre a iniciativa, e quiser colar lá qualquer dia, são todos muito bem vindos!
Desafio/Exercício 

Pra seguir os padrões de sempre relacionar algo sobre tecnologias Google, lancei um desafio pra quem assistiu. Dentro do repositório do Git tem alguns arquivos relacionados a um ambiente Web utilizando o AngularJS que vocês vão ter que subir na unha ou direto na Dockerfile. 

Fica ai o desafio.... 


Valeu quem acompanhou Online no dia via Hangout ou Periscope!!

Webinar :: Introdução a Containers com Docker

terça-feira, 12 de julho de 2016


O GNUPG é um utilitário de criptografia simétrica e assimétrica que possui a licença GPL e funciona em multiplataforma, como Linux, Windows, MacOS e BSD que utiliza em seu escopo o padrão RSA para criptografia assimétrica, TripleDES, AES e Blowfish para criptografia simétrica.

De um modo geral, o GNUPG tem suporte para os seguintes algoritmos:

Criptografia Assimétrica:

  • RSA
  • RSA-E
  • ESA-S
  • ELG-E
  • DSA
Criptografia assimétrica:
  • IDEA
  • 3DES
  • CAST5
  • BLOWFISH
  • AES
  • AES192
  • AES256
  • TWOFISH
  • CAMElLIA128
  • CAMELLIA192
  • CAMELLIA256
Algoritmos de Dispersão e Hashing:
  • MD5
  • SHA1
  • SHA256
  • SHA384
  • SHA512
  • SHA224
  • RIPEMD160

Algoritmos de Compressão:
  • ZIP
  • ZLIB
  • BZIP

Instalando o GNUPG

Por default o GNUPG já vem instalado na maioria das distribuições. Mas caso não esteja, ele com certeza está no repositório default da sua distro. Para instalar, é bem simples:
 # sudo apt-get install gnupg  # Debian Like
 # sudo yum install gnupg  # CentOS/RHEL/Fedora
 root@webserver:/home/matheus# gpg --version  
 gpg (GnuPG) 1.4.18  
 Copyright (C) 2014 Free Software Foundation, Inc.  
 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>  
 This is free software: you are free to change and redistribute it.  
 There is NO WARRANTY, to the extent permitted by law.  
 Home: ~/.gnupg  
 Algoritmos suportados:  
 Chave pública: RSA, RSA-E, RSA-S, ELG-E, DSA  
 Cifra: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,  
     CAMELLIA128, CAMELLIA192, CAMELLIA256  
 Dispersão: MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224  
 Compressão: Uncompressed, ZIP, ZLIB, BZIP2  
 root@webserver:/home/matheus#   


Gerando um par de Chaves GPG

O funcionamento do GPG e dos pares de chaves assimétricas em geral garantem a autenticidade e privacidade entre os usuários, uma vez que a chave privada gerada deve pertencer somente ao dono, e a mensagem do remetente autenticado com a chave pública confere a autenticidade entre ambas as partes, garantindo que somente o dono leia a mensagem e vice versa.

O tamanho da chave em bits impacta diretamente entre dois cenários, sendo eles o da performance e usabilidade e da segurança e privacidade, pois quanto maior o numero de bits da chave,mais segura será a mesma, porém vai exigir muito mais processamento. Claro, há casos e casos, basta adaptar para o seu tipo de situação. Mas em geral, eu não recomendaria chaves com menos de  1024 bits para gerar o par, e não recomendaria chaves muito maiores que 2048, e nem a chave de 4096 para não impactar tanto na performance.

Para gerar as chaves, o sistema usa uma série de dados aleatórios embasados na entropia do sistema. E as vezes ele irá sugerir que você faça algumas atividades aleatórias para gerar essa entropia, como atualizar o sistema, mover e deletar arquivos e etc.

Para gerar a chave, basta:
 root@webserver:/home/matheus# gpg --gen-key  
 gpg (GnuPG) 1.4.18; Copyright (C) 2014 Free Software Foundation, Inc.  
 This is free software: you are free to change and redistribute it.  
 There is NO WARRANTY, to the extent permitted by law.  
   
 gpg: directory `/root/.gnupg' created  
 gpg: criado um novo ficheiro de configuração `/root/.gnupg/gpg.conf'  
 gpg: AVISO: opções em `/root/.gnupg/gpg.conf' ainda não estão activas nesta execução  
 gpg: porta-chaves `/root/.gnupg/secring.gpg' criado  
 gpg: porta-chaves `/root/.gnupg/pubring.gpg' criado  
 Por favor selecione o tipo de chave desejado:  
   (1) RSA and RSA (default)  [RECOMENDADO ESTE]
   (2) DSA and Elgamal  
   (3) DSA (apenas assinatura)  
   (4) RSA (apenas assinatura)  
 Sua opção? 1  
 RSA keys may be between 1024 and 4096 bits long.  
 What keysize do you want? (2048)   
 O tamanho de chave pedido é 2048 bits  [AQUI USEI O DEFAULT DE 2048 bits mesmo]
 Por favor especifique por quanto tempo a chave deve ser válida.  
      0 = chave não expira  
    <n> = chave expira em n dias  
    <n>w = chave expira em n semanas  
    <n>m = chave expira em n meses  
    <n>y = chave expira em n anos  
 A chave é valida por? (0) 0  [CHAVE SEM DATA DE EXPIRAÇÃO. ADAPTE PARA O SEU CASO]
 Key does not expire at all  
 Is this correct? (y/N) y  
   
 You need a user ID to identify your key; the software constructs the user ID  
 from the Real Name, Comment and Email Address in this form:  
   "Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"  
   
 Nome completo: Matheus Fidelis  
 Endereço de correio eletrônico: matheus.fidelis@protonmail.com  
 Comentário: Meu par de chaves!  
 Você selecionou este identificador de usuário:  
   "Matheus Scarpato Fidelis (Meu par de chaves!) <matheus.fidelis@protonmail.com>"  
   
 Muda (N)ome, (C)omentário, (E)ndereço ou (O)k/(S)air? o  
 Você precisa de uma frase secreta para proteger sua chave.  
   
 Precisamos gerar muitos bytes aleatórios. É uma boa idéia realizar outra  
 atividade (digitar no teclado, mover o mouse, usar os discos) durante a  
 geração dos números primos; isso dá ao gerador de números aleatórios  
 uma chance melhor de conseguir entropia suficiente.  
   
 Não há bytes aleatórios suficientes. Por favor, faça algum outro trabalho  
 para que o sistema possa coletar mais entropia!  
 (São necessários mais 108 bytes)  
     
                                    
 ....+++++  
 .+++++  
 Precisamos gerar muitos bytes aleatórios. É uma boa idéia realizar outra  
 atividade (digitar no teclado, mover o mouse, usar os discos) durante a  
 geração dos números primos; isso dá ao gerador de números aleatórios  
 uma chance melhor de conseguir entropia suficiente.  
 .......+++++  
 ...........+++++  
 gpg: /root/.gnupg/trustdb.gpg: banco de dados de confiabilidade criado  
 gpg: key 270F136D marked as ultimately trusted  
 chaves pública e privada criadas e assinadas.  
   
 gpg: a verificar a base de dados de confiança  
 gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model  
 gpg: depth: 0 valid:  1 signed:  0 trust: 0-, 0q, 0n, 0m, 0f, 1u  
 pub  2048R/270F136D 2016-07-07  
    Key fingerprint = BCB1 F20A D5D8 C721 2092 2AE4 DF15 9555 270F 136D  
 uid         Matheus Scarpato Fidelis (Meu par de chaves!) <matheus.fidelis@protonmail.com>  
 sub  2048R/CFBFC7BD 2016-07-07  
   


Exportando a Chave Pública

Podemos utilizar o próprio gpg para exportar nossa chave para um arquivo, e assim disponibilizarmos para quem desejarmos. Usemos o comando a seguir para exportar tudo para um arquivo chamado minha_chave_publica.txt. Lembrando que a chave é uma linha só bem grande. Portanto evite quebrar linhas dentro dele, pode acabar com todo o processo.
 root@webserver:/home/matheus# gpg --armor --output "minha_chave_publica.txt" --export  
 root@webserver:/home/matheus# cat minha_chave_publica.txt   
 -----BEGIN PGP PUBLIC KEY BLOCK-----  
 Version: GnuPG v1  
   
 mQENBFd+TlYBCAC9H55ugiL+SB63CZt/ege5k+IQq6+So72axRD/zSlMtQDiYNWC  
 211BT8fFC6KslA5jSBMZ2ySb07x+6s3KHYZ/zKvoWeyjqIxcVnYdMr/pznMNBVv/  
 jLuXve6m79YFX+XFt8MA1T3SXVg25N6FmHlKyVnHmXtMS42kPabn1oM1JBojJzEl  
 XjH+Gl0sN0uWbzn069l2kwrLZtuOkti9eRXHvMwBFojoaZpvAgom/QIBmDHMyOrE  
 6ovnfs4e1zp/iSfTTd170DpnJKX5Z6Fby/5r2WyYz+6LKnsRtpumvUMX55n9epL2  
 +7ID9XJAmIaqywJ9zq7a+SBS8ZwDg7lFvd6TABEBAAG0Tk1hdGhldXMgU2NhcnBh  
 dG8gRmlkZWxpcyAoTWV1IHBhciBkZSBjaGF2ZXMhKSA8bWF0aGV1cy5maWRlbGlz  
 QHByb3Rvbm1haWwuY29tPokBOAQTAQIAIgUCV35OVgIbAwYLCQgHAwIGFQgCCQoL  
 BBYCAwECHgECF4AACgkQ3xWVVScPE21RswgAs3NesGBWq8lIQLs8rYOugFxVq3pc  
 wWugEcs91e+iXxY+PdGu6x60TXzgq+y5M9r2gkLpu6g3QknZlWDIjCqB25GY8DoS  
 Lw3gMT8AjXBh/UlWwG3JEyKalfuQ0P615YAyUBjSo9+uVtEGk1q+65m1KF9YaKfr  
 BeS2Prhqq/IX7UXeCpAQo+CiBM79SNp8ayL/nzVe5QQmSFPGcOUw2exhpU+VTQWT  
 JpwqS9tWurXa6b2FQxlr0gJSmLy/u3W14bIIIp7qKFLgy2keq+Z/GLJf3U1cgjfV  
 /2kkrHD3ksfaoGkKdE9K5mGwQ31KmrD3Z9rS/KRWmp6NPOtdWZnO2JwovrkBDQRX  
 fk5WAQgA07/BEHtNV6OpmBgsw3RKXq82U28MreaRcglIXTwgQd/tMJlyPpNwrhzS  
 fEuGf8rxpBu/y6VwYelYySui0edo6V0vzEFxmydnXrD11PFfhIVHBpZlXIzPd7YZ  
 G306rT5wJhs14JOmJFUKMPNrrlp6zLZ713G3tC1+5eagIHzT6wt7WoA6HtCJG4pv  
 h2VNXtmGn8+U2FoPP+Qnijqh8X9179IupfNm0+YTt0vJbOjQzr3z1MMrfRO/xsKn  
 1ya3dLU1QrwN1rLYiB9jVnsV6rK3hhE2WYykry66lh4UsWHY1Jtbd3OigNOsWYLR  
 CAeaseMuptkpb1v/T9dssMABUczH+wARAQABiQEfBBgBAgAJBQJXfk5WAhsMAAoJ  
 EN8VlVUnDxNt348H/3FYIZm8OX3ohJ0qXEmCuLvxNWBILJTASUbzgGWv/QbJvrJm  
 lBia8OE1hvzVmgqRgDI4Pgdg62AEdBpfNPyP/pLfJnR5RPQlVxo00AN/0bY4/9C/  
 EUjPE7KDKwsKmFffJBXW3LZc/0NU3VpuVqUFSqn/mS/7Pc/rkmElKMjw/PwqsYHW  
 dUkyB4M35i//dePRnCCs5kKxaBDapebXufDzPZL5KZdH+tgIMGP5rjmPPxHzCWvj  
 oqBShQCFDWDpdjApkmMmQ/jRHz9zzZ6pQZXmLMkANO0cTrtU2X44eyf1zv1xwgXP  
 AbV3TFQEySkhuhXLnmV68lVIvYl3+xHMrMI+F8M=  
 =LFmZ  
 -----END PGP PUBLIC KEY BLOCK-----  
 root@webserver:/home/matheus#   
   

Importando a Chave Pública 

Para importar um certificado de confiança de uma máquina, você deverá possuir a chave pública da mesma. Sendo assim, logue em uma segunda máquina repita o passo de criação da chave com outro usuário alterando os dados como nome, e-mail e etc. Vo

 matheus@webserver:~$ gpg --import minha_chave_publica.txt   
 gpg: key 270F136D: public key "Matheus Fidelis (Meu par de chaves!) <matheus.fidelis@protonmail.com>" imported  
 gpg: Número total processado: 1  
 gpg:        importados: 1 (RSA: 1)  
 matheus@webserver:~$ gpg --list-keys  
 /home/matheus/.gnupg/pubring.gpg  
 --------------------------------  
 pub  2048R/F54151E9 2016-07-07  
 uid         Harmando  
 sub  2048R/D7448235 2016-07-07  

pub   2048R/270F136D 2016-07-07
uid                  Matheus Scarpato Fidelis (Meu par de chaves!) <matheus.fidelis@protonmail.com>
sub   2048R/CFBFC7BD 2016-07-07


Agora vamos editar a chave e informar o grau de confiança da mesma
 matheus@webserver:~$ gpg --edit-key "Matheus Scarpato Fidelis"  
 Command > trust





GNUPG :: Gerando Chaves de Criptografia Manualmente com o Linux

quinta-feira, 7 de julho de 2016


Uma forma muito bacana, porém não tão amigável para o usuário de criptografar conexões e qualquer tipo de comunicação com qualquer tipo de protocolo é utilizando uma conexão SSH para criar um túnel seguro entre sua máquina e o host em questão.

Por exemplo: Você possui na sua empresa algum serviço de rede de storage, database, consulta ou qualquer que seja rodando em um servidor interno, ou você possui algum painel ou serviço acessível somente dentro da VPN do seu cluster em cloud, porém esses serviços não são liberados para acesso direto a internet por motivos óbvios, e você precisa acessá-los de forma segura mesmo assim. Estranho, não? Pois é...Mas isso é possível.

Porém é possível utilizar um servidor SSH para rotear essa conexão do serviço para uma porta da máquina local, fazendo com que todos os requests e sockets passem antes de qualquer coisa pela conexão encriptada do SSH que você criou com a máquina servidor.

Vamos ao exemplo prático:

Dentro de um ambiente de teste, eu tenho um serviço de Owncloud hospedado em um servidor Web. Por enquanto, esse serviço está somente dentro da minha rede interna e eu posso acessá-lo pelo Browser tranquilamente através do IP http://192.168.0.200/owncloud quando estou na minha rede interna, porém esse mesmo servidor foi aberto externamente somente a porta 22 referente ao serviço SSH.


Para realizar o roteamento pela conexão SSH, basta realizar a seguinte sintaxe:
  # ssh -p [PORTA DO SSH] -L[PORTA DE LISTENING]:[IP/HOST]:[PORTA A SER MAPEADA] [USUARIO]@[HOST]
  # ssh -p 22 -L666:192.168.0.200:80 matheus@192.168.0.200   

Neste caso eu estou criando um LISTENING na porta '666' da MINHA máquina para a porta '80' do HOST '192.168.0.200' utilizando minhas credenciais de usuário 'matheus'. Ou seja, após a autenticação bem sucedida, o conteúdo da porta 80 do host estará disponível na porta '666' da minha máquina, com toda a comunicação sendo encriptada por meio da conexão segura do SSH, como podemos ver a seguir:

http://localhost:666/owncloud



Espero ter ajudado :)

Tunelamento SSH :: Tunelamento de Protocolos e Serviços utilizando o SSH

segunda-feira, 4 de julho de 2016



o XFS é um sistema de arquivos muito interessantes Open Source, criado principalmente para suportar storages que demandem uma grande quantidade de arquivos grandes. Caso você gerencie algum storage usando ou não o Samba Server, que necessite de armazenar grande quantidade de arquivos gigantescos compactados, ou backups de sistemas, o XFS é uma solução muito viável para esse trabalho. Já para arquivos pequenos, o XFS pode apresentar um desempenho não tão satisfatório como ext4. Além dessa feature bacana, o XFS possui bastante estabilidade e segurança no armazenamento, uma vez que eu já passei por muitas quedas de energia, onde vários discos que eu utilizava o XFS foram reerguidas sem problema e perda nenhuma.

O mais legal do XFS o sistema de journaling lógico, que realiza a gestão de do arquivo por meio de metadados, garantindo a estabilidade e integridade dos dados em caso de desligamento do sistema, evitando que o mesmo seja corrompido, além de possuir um utilitário integrado de desfragmentação do sistema de arquivos e o utilitário 'xfs_growfs', que permite o aumento (não a diminuição, infelizmente) de sistemas de arquivos XFS sob demanda, similar aos volumes LVM e o 'xfsprogs', que permite a checagem do sistema de arquivos, ajustes e correções preventivas no mesmo.

Mais uma vez: O XFS só é performático de verdade em sistemas que trabalhem com arquivos realmente grandes, pois ele é otimizado para trabalhar com blocos de maior porte. Caso esteja trabalhando com um sistema que utilize uma grande quantidade de arquivos pequenos, eu recomendo um outro tipo de filesystem.

Main Page do projeto: http://xfs.org/index.php/Main_Page


Instalando o XFS Utils:
 # apt-get install xfsprogs  #Debian
 # yum install xfsprogs #CentOS/RHEL

Vamos listar todos os volumes montados e/ou disponíveis no nosso sistema
 # fdisk -l  

Formatando a partição com o XFS
 # mkfs.xfs -L media /dev/sdc1  

Montando a partição
 # mount -t xfs /dev/sdc1 /mnt/part  

Enlarge em Partições XFS

Para realizar o enlarge em partições que estejam utilizando o XFS, basta passar no novo numero de blocos apontando para o device
 # sudo xfs_growfs /dev/sdc1 -D 1986208  

Veja também:



Espero ter ajudado :)

Instalando e Criando Partições com XFS, um sistema de arquivos otimizado para storages de grande porte

 
Nanoshots | Open Source Security, Linux e Tutoriais © 2015 - Designed by Templateism.com