Gerenciando múltiplas chaves SSH no Linux

Gerenciando múltiplas chaves SSH no Linux

Quem trabalha com desenvolvimento web provavelmente já deve ter ficado louco em algum momento com tantas chaves SSH para gerenciar. É chave para Github, chave para servidor de teste, chave para servidor de produção… O SSH config é uma mão na roda nessas horas.
Alias
Quando eu comecei a trabalhar com SSH, tinha apenas duas chaves para gerenciar eeu simplesmente chamava assim:

$ ssh -i ~/.ssh/chave_privada usuario@servidor

O problema com esse comando é que são muitas coisas pra digitar e é muito fácil de esquecê-las. Foi então que alguém me falou: “- Ei! Usa um Alias no Shell e para de sofrer…”. Como faz isso? Você precisa abrir seu .bashrc e adicionar o seguinte:

alias ssh_server1=’ssh -i ~/.ssh/chave_privada usuario@servidor’

Agora, sempre que eu quiser acessar o servidor em questão, abro o meu terminal e digito

$ ssh_server1

Config file
Eu costumo ser bem chato com organização. Hoje tenho cerca de cinco chaves para gerenciar e utilizar Alias para todas não parecia ser o mais legal. Na verdade, estava bem feio. Foi aí que descobri que o próprio open-ssh disponibiliza um arquivo de configuração para gerenciar as chaves.
Veja como é fácil converter o exemplo anterior para o arquivo de configurações:

O primeiro passo é acessar o diretório ~/.ssh e criar o arquivo config:

$ cd ~/.ssh
$ touch config

Agora você deve definir os parâmetros de sua conexão ssh:

Host server1
User usuario
HostName server1.com
IdentityFile ~/.ssh/chave_privada_do_server1

Agora, para acessar o server1 por ssh, rode o comando:

$ ssh server1

Simples assim!
Você também pode gerenciar as chaves utilizadas em repositórios GIT. Digamos que o seu repositório esteja hospedado sob o endereço repositorios.com. Então, ao invés de utilizar o ssh-agent para configurar a chave privada a ser utilizada, você pode criar uma nova entrada no arquivo de configuração ~/.ssh/config

Host repos
HostName repositorios.com
IdentityFile ~/.ssh/chave_privada_do_repositório
IdentitiesOnly yes

e utilizar o seguinte comando para clonar o repositório

$ git clone git@repos:seu_repositorio.git

O IdentitiesOnly yes serve para dar prioridade à chave privada definida em IdentityFile. Sem essa opção, a primeira tentativa de chave a ser utilizada seria a chave id_rsa
Essa dica é bem simples e vai ajudar bastante na organização de suas chaves. Outras dicas podem ser encontradas na documentação oficial do open-ssh, ou aqui no blog em um próximo post!
Até a próxima!
O post Gerenciando múltiplas chaves SSH no Linux apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Gerenciando múltiplas chaves SSH no Linux
Fonte: Locaweb

Instalando Node.js 6.x e npm no Ubuntu 16.04

Instalando Node.js 6.x e npm no Ubuntu 16.04

Node.js é uma plataforma Javascript que permite que os desenvolvedores criem aplicações de rede escaláveis e de maneira rápida. É utilizada no mundo todo e mantida por uma grande comunidade.
Outro importante elemento é o gerenciador de pacotes npm (node package manager). Com o npm é possível ter acesso a um repositório online onde existem milhares de projetos de código-aberto para o Node e, claro, gerenciar todas as dependências e versões que precisarmos. Dito isso, vou mostrar duas maneiras de instalar o node e também como instalar o npm no seu Ubuntu 16.04. Vamos lá?
Utilizando os repositórios do Ubuntu
A maneira mais simples de instalar o node no Ubuntu é obtendo-o dos repositórios padrões do sistema operacional. Geralmente não será a última versão, mas será uma versão estável. Primeiro, precisamos ter certeza que nossos repositórios e os pacotes do sistema estão atualizados

$ sudo apt update
$ sudo apt upgrade

E logo então podemos instalar o node (aqui precisei de sudo)

$ sudo apt install nodejs

E por último o npm (também precisei de sudo)

$ sudo apt install npm

Para verificar que tudo foi instalado corretamente, vamos conferir as versões que foram instaladas (pode ser que você já tenha instalado uma versão mais atual)

$ node -v
v6.9.4
$ npm -v
3.10.10

Utilizando um PPA
PPA (Personal Package Archives) são pacotes pessoais que não pertencem as atualizações ou softwares padrões do Ubuntu; criados e mantidos pela comunidade. Geralmente são utilizadas para manter as versões mais atualizadas dos softwares, que não estão nos repositórios padrões. Eu não vou entrar aqui no assunto se PPAs são seguros ou não, porque nesse caso o PPA que vou indicar para vocês é indicado pelo site oficial do node.
Primeiro precisamos instalar uma dependência do pacote python-software-properties caso você ainda não o tenha

$ sudo apt install python-software-properties

e agora basta adicionar o PPA

$ curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -

Feito isso

$ sudo apt install nodejs

Utilizando o PPA, o npm é instalado automaticamente junto com o node. Novamente testando a instalação

$ node -v
v6.9.4
$ npm -v
3.10.10

No momento em que escrevi este artigo, a versão mais atual do Node.js é a v7.4.0, mas ela ainda não estava com LTS (Long Term Support), o que não impede você de testá-la ou usá-la. Se quiser fazer isso, simplesmente repita a instalação via PPA, mas com o seguinte repositório

$ curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -

Verá que as versões foram atualizadas

$ node -v
v7.4.0
$ npm -v
4.0.5

É isso ai pessoal! Tem alguma dúvida? Me deixe uma mensagem nos comentários. Até a próxima!

O post Instalando Node.js 6.x e npm no Ubuntu 16.04 apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Instalando Node.js 6.x e npm no Ubuntu 16.04
Fonte: Locaweb

Instalando o Cordova 6.x no Ubuntu e Mac OS X

Instalando o Cordova 6.x no Ubuntu e Mac OS X

Instalar o Cordova no Ubuntu e no Mac OS X é uma tarefa bem simples se já tivermos com o Node.js e npm instalados. Caso você ainda não tenha essas dependências, você pode instalá-las utilizando um destes dois guias, para Ubuntu ou para Mac OS X.
Bom, agora que você já tem as dependências necessárias, vamos utilizar o npm para instalar o Cordova. Neste guia, eu estou utilizando o Ubuntu 16.04, mas os mesmos comandos podem ser utilizados para instalar no Mac OS X também. Para instalar o framework, simplesmente digite em seu terminal

$ npm install -g cordova

Aqui eu precisei de sudo, por conta de algumas permissões de pastas do meu computador. A saída desse comando, deve ser mais ou menos a seguinte (pode mudar dependendo de quantas dependências do cordova você já tiver instaladas)

Para ter certeza que tudo está certo, vamos então criar uma aplicação de teste bem simples. Todos os comandos que vamos precisar para criar essa aplicação serão feitos através da CLI (command-line interface) do Cordova.
Entre em um diretório de sua preferência onde deseja criar a aplicação. No meu caso

$ pwd
/home/pablo
$ cd repos

Uma vez no diretório, digite

$ cordova create appTest
Creating a new cordova project.

Se nenhum erro apareceu, a aplicação inicial foi criada. Aqui não estamos falando de nenhuma plataforma, simplesmente estamos testando nosso framework. Por isso, vamos utilizar o nosso navegador mesmo para testar nossa aplicação, pois não vamos precisar instalar nenhuma dependência de plataforma. Com a aplicação criada, entre no diretório em que ela está

$ cd appTest

Agora vamos adicionar uma plataforma ao nosso projeto, neste caso como disse o próprio navegador (é possível que ele instale algumas dependências automaticamente)

$ cordova platform add browser
Adding browser project…
Running command: /home/phsil/.cordova/lib/npm_cache/cordova-browser/4.1.0/package/bin/create /home/phsil/repos/MyApp/platforms/browser io.cordova.hellocordova HelloCordova
Creating Browser project. Path: platforms/browser
Discovered plugin “cordova-plugin-whitelist” in config.xml. Adding it to the project
Fetching plugin “cordova-plugin-whitelist@1” via npm
Installing “cordova-plugin-whitelist” for browser

Uma vez que o nosso projeto agora tem suporte para o navegador, vamos então rodar nossa aplicação para confirmar que tudo deu certo

$ cordova run browser
Running command: /home/phsil/repos/MyApp/platforms/browser/cordova/build
Cleaning Browser project
Running command: /home/phsil/repos/MyApp/platforms/browser/cordova/run –nobuild
Static file server running @ http://localhost:8000/index.html
CTRL + C to shut down

Como você pode ver, foi criado um servidor estático no endereço http://localhost:8000/index.html. Abra seu navegador (se ele não foi aberto automaticamente) e digite o endereço do servidor.
Se tudo deu certo, você verá a seguinte tela:

Parabéns, você criou sua primeira aplicação utilizando o Cordova.
Você pode saber muito mais sobre o framework, olhando sua documentação neste link. É uma documentação bem completa que vai te ajudar a entender melhor os aspectos do framework e começar a desenvolver para outras plataformas, como Android e iOS.
Ficou alguma dúvida? Escreva aí nos comentários! Até a próxima!
O post Instalando o Cordova 6.x no Ubuntu e Mac OS X apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Instalando o Cordova 6.x no Ubuntu e Mac OS X
Fonte: Locaweb

Conheça a arte do SOLID

Conheça a arte do SOLID

Quando escuto ou leio a palavra SOLID me vem logo o Snake, do game Metal Gear Solid na cabeça e isso acontece há muito tempo. Não sou nenhum fã do jogo, mas também não sou hater, apenas não joguei o suficiente para entrar em um dos lados da força.
Agora, voltando ao tal do SOLID – que não é jogo -, você já ouviu falar dele? Já o usou? Sabe para que serve? Neste artigo vamos fazer um overview e ver a melhor forma de usar esse cara…
Primeiro precisamos saber que SOLID é uma sigla para Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion.
Para facilitar, o SOLID é um acrônimo para os cinco primeiros princípios da programação orientada para objetos, nós buscamos segui-los para que um projeto seja realmente orientado a objetos e não um fruto da nossa linda e maravilhosa criatividade.
Vamos ver o que cada um desses princípios tratam; só para facilitar o entendimento dos conceitos, utilizaremos alguns exemplos em JAVA e outros em Ruby:
– Single Responsibility
O Single responsibility está ligado diretamente ao objetivo que a cada classe possui, sendo que uma classe deve ter sempre um único objetivo. Se o sistema está crescendo e uma classe passou a ter duas responsabilidades é hora de dividi-la em duas classes, cada uma com uma responsabilidade. Exemplo:
class Client
def save(args)
super
ExecuteDepencencies.execute(args[:dependencies])
end
end

class ExecuteDepencencies
def self.execute(dependencies)
dependencies.each do |dependency|
dependency[:module].execute(dependency[:arg])
end
end
end

class UploadFile
def self.execute(file)
#Do the upload
end
end

class Sendmail
def self.execute(email)
#Send email
end
end

Imagine um formulário de cadastro onde o usuário ao submeter os dados já faz o upload do arquivo anexo e envia um e-mail para o mesmo confirmando o cadastro. A responsabilidade de salvar ficou na classe do cliente enquanto fazer o upload e enviar o e-mail ficaram em classes separadas, podendo ser utilizados em outros lugares do sistema em que seja necessário novamente fazer o upload de um arquivo como no cadastro de produtos ou enviar um e-mail como no fechamento de uma compra.
– Open-closed
O princípio de aberto e fechado nos traz o conceito de que devemos sempre deixar nossas classes abertas para serem expandidas, porém fechadas para serem modificadas. Ou seja, você deve isolar a regra para que assim outras classes possam usar ela. Exemplo:
public class User {
public void executeRole(String role){
if(role == ‘Admin’){
// Do Something
}

if(role == ‘Client’){
// Do Something
}
}
}

No exemplo acima sempre que implementarmos alguma regra nova, por exemplo um Fornecedor (Provider), iremos colocar um if a mais no código e esses ifs tendem ao infinito.
A ideia do princípio é colocar a role em uma interface para retirar esses ifs. Exemplo:
public interface Role {
void executeRole(String role);
}

public class Admin implements Role {}
public class Client implements Role {}
public class Provider implements Role {}

Desta forma dentro das classes iremos implementar o método executeRole sem nenhum if, apenas executando o que cada um deveria fazer. A ideia nesse caso é que a interface Role seja pouco modificada (o ideal é que ela não seja modificada) e apenas a sua implementação nas classes que irão utilizá-la sejam alteradas conforme a necessidade da classe.
 
– Liskov substitution
Esse princípio está relacionado a herança e diz que se você tem um objeto B que herda A, em qualquer lugar que você tenha A você pode substituir por B sem precisar alterar o programa. Exemplo:
class Gadget
def call(number)
true
end
end

class Smartphone < Gadget
end

class Psp < Gadget
def call(number)
raise “This gadget do not make calls”
end
end

Basicamente temos uma classe Gadget e ela possui um método de call (ligar), sendo que Smartphone e PSP são Gadgets, logo herdam ela e trazem consigo o método call. Porém, o PSP não faz ligações, por isso mesmo faremos o método retornar uma exception. Com isso ferimos o princípio de Liskov.
Se tivéssemos uma instância de Gadget e a mesma fosse substituída por Smartphone funcionaria normalmente. O método call, ao invés de ter um retorno booleano, como o método da classe pai fazia, acaba retornando uma exception (claro que poderíamos fazer o método call no PSP, mas queria deixar dessa forma, como um exemplo).
 
– Interface segregation
O Princípio da Segregação de Interface trata da coesão de interfaces e diz que classes não devem ser forçadas a depender de métodos que não usam. Exemplo:
public interface Activity {
void buy(Order order);
}

public class ShopOwner implements Activity {}
public class Client implements Activity {}
public class Provider implements Activity {}

Esse exemplo está ferindo o princípio, pois o dono da loja pode comprar do fornecedor e o cliente comprar do dono da loja, mas o fornecedor não compra de ninguém e, nesse caso, você seria obrigado a implementar o método buy no fornecedor, mesmo o método não servindo para ele.
– Dependency inversion
O princípio de inversão de dependência nos diz que SE devemos acoplar alguma classe em outra, devemos fazer esse acoplamento em classes estáveis. De forma mais simples o princípio quer dizer:

Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações.
Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.

Exemplo:
public interface ActionAfterBuy {
void execute(User user);
}

public class Cart implements ActionAfterBuy {}

Nesse exemplo o carrinho é um módulo de alto nível e o ActionAfterBuy (Ação depois de comprar) é uma abstração. Perceba que o ActionAfterBuy é uma classe estável, pelo fato de que ela pouco vai ser alterada ao longo do tempo (a ideia de classes estáveis é justamente essa, não alterá-la durante o ciclo de vida do software); além disso, ela não conhece detalhes de sua própria implementação.
Esse é apenas um resumo do que é o SOLID, caso queira se aprofundar no assunto, recomendo fortemente o livro “Orientação a Objetos e SOLID para ninjas” do Maurício Aniche. Outro bom artigo é o “The Principles of OOD”.

Gostou do que falamos? Ficou com alguma dúvida? Deixe nos comentários!
O post Conheça a arte do SOLID apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..

Conheça a arte do SOLID
Fonte: Locaweb