Vagrant - Gerencie Máquinas Virtuais no Windows

Mudei do Windows para o Linux por causa de um motivo tremendamente simples: Tudo que usava podia muito bem usar no Linux, então para que deveria ficar com o Windows? Porém existem pessoas que adoram o Windows, MS-Office, MS-SQL e todo M$ que puder encontrar (como existem pessoas que adoram coisas começadas com "i").

Estou publicando uma série de artigos sobre o Docker no qual aquelas pessoas que ainda estão neste sistema não pode aproveitar (a menos que possuia a versão 10 e com o bash). Pensando nessas pessoas resolvi publicar esse artigo sobre o Vagrant, que na minha opinião é a melhor opção em se tratando de Gestão de Virtualização de Ambientes.

Primeiro o Vagrant não gera máquinas virtuais como o VirtualBox, ao contrário, inclusive será necessário ter o VirtualBox para usar o Vagrant. Então para que serve isso? Em condições normais de virtualização de sistemas é necessário baixar o VirtualBox, ter uma ISO do sistema operacional que se deseja virtualizar e realizar um monte de configurações para ter algo aceitável. Vagrant elimina toda essa necessidade, ele baixará, gerenciará e organizará como usaremos o VirtualBox.

Vamos na prática, primeiro é necessário instalar três programas: Vagrant, Oracle VM VirtualBox e Git. Não se preocupe que como tudo no Windows é Next > Next > Next > Vendo minha Alma > Next > Confirma. Baidu instalado com sucesso (não se preocupe pois as chances disso acontecer são de apenas 50%).

Segundo passo, ir na seção de Variáveis de Ambiente e na variável PATH adicionar o seguinte caminho: C:\Program Files\Git\usr\bin.

Agora executar o comando CMD para abrir uma janela de comandos:

a. Criar uma pasta para abrigar o Vagrant:

C:\>mkdir proj

b. Acessar essa pasta:

C:\>cd proj

c. Iniciar o Vagrant:

C:\proj>vagrant init

d. Na pasta será criado um arquivo chamado VagrantFile, adicionar a este arquivo três pequenas mudanças (pode usar seu editor de códigos favorito):

config.vm.box = "ubuntu/xenial64"

config.vm.network "forwarded_port", guest: 8080, host: 8080

config.vm.provision "shell", inline: <<-SHELL 
  passwd -d -u ubuntu
  chage -d0 ubuntu
SHELL

Atenção. Existem seções respectivas para esses dados basta retirar os comentários e modificá-las.

A primeira baixa a imagem do Ubuntu 16.04 (Codinome Xenial Xerus), a segunda informa que será realizado um compartilhamento da porta 8080 entre os sistemas operacionais e por último que no primeiro acesso deve ser definida a senha para o novo sistema. Recomendo que depois olhe com calma esse arquivo pois é ele que controla a máquina disponível no VirtualBox, ou seja, usar o Vagrant é como usar o Apache basta entender como funciona o arquivo de configuração.

e. Obter a máquina virtual

C:\proj>vagrant up

f. Uma vez terminado, basta acessar:

C:\proj>vagrant ssh

Na primeira vez será definido a senha para acessar a máquina, defina-a e digite novamente o mesmo comando.

g. Digitar "exit" se deseja sair da máquina virtual e retornar ao Windows. Para pará-la completamente use o seguinte comando no Windows:

C:\proj>vagrant halt

h. Veja o status do Vagrant com:

C:\proj>vagrant status

Nessa máquina é possível instalar e usar o Docker utilizando todos os comando que já mostrei em publicações anteriores, observe que também associamos a porta 8080 assim será possível subir um site (com o Node.js ou outro servidor) e ver o resultado na máquina Windows.

Infelizmente para este tutorial não gravei nenhum vídeo pelo simples fato de ter abolido completamente o Windows do meu computador pessoal, mas no próximo retomaremos as gravações e agora mesmo com o Windows 7 não existe mais desculpa para não aprender a usar o Docker.

Sei que ficou curioso e está louco para usar o Vagrant com o Docker, mas como? Que tal começar pelo Jenkins? Acesse o blog do Giovanni Nunes e descubra como.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

DevOps - MySQL no Docker

Terceiro artigo da série DevOps, continuação do livro Docker que pode ser acessado através do site Academia.edu.

Entre todas as linguagens que um desenvolvedor possa utilizar, pelo menos um banco de dados é comum a todas elas: MySQL. Utilize PHP, C, Java, Python (talvez não .NET que o pessoal é meio paranoico com Microsoft), ou qualquer outra linguagem o banco de testes será um MySQL.

Então neste artigo veremos como utilizar o MySQL com o Docker (essa mesma técnica pode ser aplicada para o MariaDB ou Postgres - respeitando obviamente a porta deste último). São apenas 3 passos a realizar:

1º) Baixar imagem oficial:

$ docker pull mysql

2º) Rodar o contêiner:

$ docker run --name mybanco -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -d mysql

3º) Chamar o administrativo do banco:

$ docker exec -it mybanco mysql -p

Obviamente que não iremos parar por aqui pois não teria a menor graça. Vamos acessar o banco através de um programa Java, ainda com o administrativo aberto crie uma base de dados com o seguinte comando:

> create database teste;
> use teste;
> show tables;

Agora precisamos de um editor para o Java, para meus testes sempre utilizo o BlueJ e o Conector JDBC do MySQL deve ser disponibilizado, para proceder isso:

1. Baixar o conector JDBC do MySQL no driver oficial ou através desse link.
2. Acessar no menu principal "Tools | Preferences".
3. Ir para a pasta "Libraries".
4. Pressionar o botão "Add" e localizar o conector baixado.

Uma vez adicionado sair e entrar novamente no BlueJ para ativar a biblioteca. Agora é só criar o programa para testar a conexão (através do botão "New Class..."):

import java.sql.*;
import java.text.SimpleDateFormat;

public class Conexao {
    
    private Connection con;

    public static void main(String [] args) {
        new Conexao().executar();
    }
    
    public void executar() {
        try {
            criar();
            selecionar();
        } catch (ClassNotFoundException e) {
            System.out.println(e.getMessage());
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }

    }
    private void conexao() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        con = DriverManager.getConnection(
         "jdbc:mysql://localhost:3306/teste", "root", "root");
    }
         
    private void criar() throws ClassNotFoundException, SQLException {
        conexao();
        // Criar a tabela
        Statement stm = con.createStatement();
        stm.executeUpdate(
            "CREATE TABLE funcionario (" +
            " matricula INT NOT NULL, " +
            " nome VARCHAR(50)," +
            " PRIMARY KEY (matricula))");  
        stm.close();

        // Adicionar 100 funcionarios
        PreparedStatement pstm = con.prepareStatement(
            "INSERT INTO funcionario (matricula, nome) VALUES (?, ?)");
        int tot = 0;
        for (int i = 0; i < 100; i++) {
            pstm.setInt(1, i);
            pstm.setString(2, "Funcionário " + i);
            tot += pstm.executeUpdate();
        }
        System.out.println("Inseridos : " + tot);
        pstm.close();
        con.close();
    }

    private void selecionar() throws ClassNotFoundException, SQLException {
        SimpleDateFormat fdt = new SimpleDateFormat("hh:mm:ss:SSSS");
        conexao();
        // Varrer todos os dados
        Statement stm = con.createStatement();
        ResultSet res = stm.executeQuery(
            "SELECT nome, matricula FROM funcionario");
        int x = 0;
        String nome = null;
        int matricula;
        System.out.println("Tempo Inicial: " + fdt.format(new java.util.Date()));
        while (res.next()) {
            nome = res.getString(1);
            matricula = res.getInt(2);
            x += 1;
        }
        System.out.println("Tempo Final: " + fdt.format(new java.util.Date()));
        System.out.println("O último que li foi " + nome);
        System.out.println("Total de " + x);
    }
}

Na primeira parte deste programa será criada uma tabela na base teste e populada com 100 registros de funcionário, na segunda parte é realizada uma consulta para verificar a existência dos registros e o tempo de performance de leitura.

Assista o vídeo para tirar quaisquer dúvida de como proceder:

Pronto o MySQL está pronto para seus testes, uma boa vantagem é que podemos criar várias instâncias (contêineres) do banco para múltiplos testes ou mesmo destruir sem deixar rastro de quaisquer dados.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

DevOps - MongoDB no Docker

Segundo artigo da série DevOps, continuação do livro Docker que pode ser acessado através do site Academia.edu.

Essa postagem garanto que será um tanto diferente, agora estou unindo som, imagem e texto. Isso mesmo, todos os comandos aqui estão reproduzidos em um vídeo no meu canal do YouTube assim pretendo colocar uma nova dimensão a este blog.

Dando continuidade a nossa série com o DevOps iremos ver como instalar e utilizar o banco de dados MongoDB. Qual a vantagem? Melhor organização, utilizando contêineres podemos facilmente ligar o servidor (ou desligá-lo), criar e remover múltiplas instâncias do banco para projetos diferentes, testar novidades sem atrapalhar o ambiente.

Não se surpreenda para instalar o MongoDB, imagem oficial, através do Docker é necessário um único comando:

$ docker pull mongo

Agora precisamos subir um contêiner:

$ docker run --name some-mongo -p 27017:27017 -d mongo

Onde "some-mongo" é o nome do contêiner criado. Podemos testá-lo através de um navegador através do endereço:

http://localhost:27017

Ou podemos executar o Administrador do MongoDB:

$ docker exec -it some-mongo mongo admin

No administrador podemos executar alguns comandos, por exemplo, verificar os bancos criados:

> show dbs

Utilizar determinado banco:

> use local

Mostrar as coleções existentes deste banco:

> show collections

Para sair do administrador:

> exit

Verificar o estado atual dos contêineres:

$ docker ps -a

Podemos parar o contêiner criado:

$ docker stop some-mongo

Ou iniciá-lo com o comando:

$ docker start some-mongo

Para remover um contêiner executamos:

$ docker rm some-mongo

Agora já temos o MongoDB instalado, em breve iremos utilizá-lo para nossos futuros testes. Confira o vídeo que completa este artigo:

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

DevOps - MSSQL Server no Docker (em Linux)

Primeiro artigo da série DevOps, continuação do livro Docker que pode ser acessado através do site Academia.edu.

Essa será a primeira de uma série de publicações para a montagem de ambientes utilizando o Docker com o Ubuntu 16.10. E, pode pensar que enlouqueci, mas não, vamos realmente instalar o Banco de dados Microsoft SQL Server no Linux e ainda por cima através do Docker.

O primeiro passo é baixar a imagem oficial:

$ sudo docker pull microsoft/mssql-server-linux

O segundo e último passo é executar a imagem para criar um contêiner com o seguinte comando:

$ docker run –e 'ACCEPT_EULA=Y' –e 'SA_PASSWORD=<YourStrong!Passw0rd>' -p 1433:1433 -d microsoft/mssql-server-linux

Não estou brincando o banco já foi instalado e está respondendo na porta 1433. Podemos verificar que a imagem está realmente rodando com o comando:

$ docker ps -a

Podemos utilizar qualquer linguagem para testá-lo porém prefiro instalar um "Administrador" para isso, vamos então proceder mais alguns passos.

1. Entrar em modo super usuário:

$ sudo su

2. Importar do repositório público as chaves GPG:

# curl https://packages.microsoft.com/keys/microsoft.asc | apt-key add -

3. Registrar o repositório Microsoft (não se preocupe com 16.04 para o Ubuntu 16.10):

# curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list > /etc/apt/sources.list.d/msprod.list

4. Sair do modo super usuário:

# exit

5. Atualizar o sistema:

$ sudo apt update

6. Instalar o aplicativo e suas dependências:

$ sudo apt install odbcinst-utf16 odbcinst1debian2-utf16 unixodbc-utf16 msodbcsql mssql-tools

Testar o ambiente

Mais uma vez já poderiamos ter terminado mas aí não teria graça. Vamos testar o ambiente, digitar o seguinte comando para entrar no MSSQL-Tools:

$ sqlcmd -S localhost -U SA -P '<YourStrong!Passw0rd>'

Como resposta obtemos "1>", significa que estamos na linha de comando do MSSQL-Tools, cada comando SQL que digitarmos é necessário terminá-lo com ";" e digitar "GO" na linha de baixo, por exemplo, ver os bancos existentes com o comando:

SELECT name FROM sys.databases;

Pressionar "ENTER" e será mostrado "2>" digitar:

GO

Pressionar "ENTER". Provavelmente nada sera mostrado, pois é um banco limpo de tudo. Vamos criar uma base de dados e uma tabela, siga a sequencia, pressionando "ENTER" em cada linha:

CREATE DATABASE testedb;
GO
USE testedb;
GO
CREATE TABLE funcionario(matricula INT NOT NULL, nome NVARCHAR(50), salario NUMERIC(10,2), PRIMARY KEY(matricula));
GO
INSERT INTO funcionario VALUES (1, 'Fernando', 1200.00);
INSERT INTO funcionario VALUES (2, 'Maria', 1400.20);
INSERT INTO funcionario VALUES (3, 'Manoel', 1100.00);
INSERT INTO funcionario VALUES (4, 'Pedro', 1230.25);
GO

Podemos ver os dados através do comando:

SELECT * FROM funcionario;
GO

Sair do MSSQL-Tools com o seguinte comando:

quit

Digitar:

$ docker ps -a

Parar o servidor com o comando:

$ docker stop [CONTAINER ID]

Tentar acessar novamente o MSSQL-Tools e observar que dessa vez será mostrado um erro informando que não existe o banco ativo. Ativar o servidor novamente com o comando:

$ docker start [CONTAINER ID]

Acessar e verificar que a base testedb está integra e com os dados que foram inseridos corretamente.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

Aprendizado - Instalar o Scratch no Ubuntu

Scratch é um ambiente criado pelo MIT para ensinar Lógica de Programação através de uma estrutura visual de blocos. Sua instalação no Ubuntu requer alguns comandos via terminal que pode ser um pouco complicado para o usuário iniciante mas nada que assuste tanto a ponto de desistir.

A primeira ação a fazer é visitar o site oficial e realizar um download de dois programas, Adobe AIR  e Scratch 2.0 Offline Editor. A partir da versão 2.0 o MIT disponibilizou uma página aonde o Scratch roda online, porém algumas vezes desejamos tê-lo no computador de modo offline.
Para instalar o Adobe AIR (necessário para instalar e rodar o Scratch) seguiremos alguns passos básicos:

1. Abra o terminal com Ctrl+Alt+T.

2. Instalar as bibliotecas i386, que são requeridas para o Adobe AIR.

$ sudo apt-get install libxt6:i386 libnspr4-0d:i386 libgtk2.0-0:i386 libstdc++6:i386 libnss3-1d:i386 libxml2:i386 libxslt1.1:i386 libcanberra-gtk-module:i386 gtk2-engines-murrine:i386

3. Instalar o pacote libgnome-keyring.

$ sudo apt-get install libgnome-keyring0:i386

4. Criar links simbólicos para o gnome-keyring de modo que o Adobe Air possa vê-lo.

$ sudo ln -s /usr/lib/x86_64-linux-gnu/libgnome-keyring.so.0 /usr/lib/libgnome-keyring.so.0
$ sudo ln -s /usr/lib/x86_64-linux-gnu/libgnome-keyring.so.0.2.0 /usr/lib/libgnome-keyring.so.0.2.0

5. Dar permissão para executar o arquivo do Adobe AIR:

$ sudo chmod +x AdobeAIRInstaller.bin

6. Executar o arquivo:

$ sudo ./AdobeAIRInstaller.bin

7. Uma tela gráfica será mostrada para o aceite da licença e continuação do processo de instação. Uma vez concluído, entrar no Nautilus através do SuperUsuário:

$ sudo nautilus

8. Acessar a pasta das aplicações: /usr/share/applications

9. Localizar o aplicativo: Adobe AIR Application Installer

10. Clicar neste e chamar o arquivo baixado do Scratch.

Pronto, agora é só aceitar as licenças necessárias e instalar corretamente o Scratch.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

DIY - Cardboard a custo R$ 0,00

Estava tranquilamente passeando em um Shopping de Brasília e resolvi entrar na loja da Samsung para ver algumas novidades tecnológicas. O vendedor me mostrou o Óculos VR e tomei um verdadeiro choque ao constatar o preço. Fiquei pensando sobre o projeto orignal chamado CardBoard, da Google.

Para quem não conhece a palavra "Cardboard" pode ser traduzida para "Papelão", isso mesmo é um óculos para imersão 3D totalmente feito com papelão e o custo deveria beirar a ZERO. Só que existem 2 custos na sua confecção: as lentes e os imãs. Porém ao ver o seguinte vídeo:

Fiquei pensando se não seria possível criá-lo realmente a custo ZERO. Os imãs poderia tirar de uma caixa de som velha. então meu maior problema realmente seriam as lentes, não sentia muita confiança nesse negócio de cortar uma garrafa PET mas corri atrás. Meu primeiro teste saiu assim:

Cometi 2 erros nessa lente, primeiro tentei colar com cola super-rápida (tipo Superbond) resultado que a lente ficou completamente embaçada - Tentei arrematar com cola quente. Segundo que deixei bolhas de ar. Mas como era apenas para teste até que funcionou bem, a lente original funciona como uma lente de aumento.

Agora já sabia o que fazer para construir as lentes. Esse outro vídeo pode lhe ajudar com algumas dicas bem importantes.

Acabei usando apenas cola quente para selar as lentes, 2 recomendações: primeiro uma pequena camada interna de cola e arremata com uma externa, segundo deixe um pequeno vão e coloque a água por último. De resto, foi apenas questão da trabalheira de cortar o papelão, pintar (pintar? resolvi pintar de preto para melhorar a imersão 3D), montar, baixar o aplicativo para cardboard e testar. Segue o óculos 3D a custo ZERO.

Funcionou muito bem, com 2 detalhes (sempre os malditos): as lentes devem ser manuseadas com o máximo de cuidado e os imãs deve ser pelo menos um superimã.

2 dicas finais (estou pensando em mudar o título dessa postagem):

• Baixe o PDF com os esquemas para o Cardboard V 1.2
• Veja a montagem do Cardboard pelo Manual do Mundo

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

Linguagem de Programação - O faz o Java ser forte?

Tem mais de 10 anos que programo e ministro aulas com a linguagem Java e certa vez ouvi a seguinte pergunta:

O que faz Java ser tão forte no mercado?

Acho que esse é o motivo principal por ministrar aulas, começamos a pensar em algo que sozinho nunca pensaríamos. Realmente, o que tem Java de tão importante assim? Se olharmos a lista do TIOBE a linguagem aparece na liderança com 19,01%, artigos como o JavaWorld mostram que 90% das empresas da revista Fortune 500 usam Java, Rankings de sites como DZone e InfoWorld colocam a linguagem em 1º Lugar na preferência de seus usuários. Será que são esses dados que fazem Java ser forte?

Penso que não isso é uma mera consequência e não o motivo. Vamos dar uma olhada na história de Java para entendermos seu sucesso. Foi lançada em março de 1995 (a versão 1.0 tem a data de janeiro de 1996) e foi algo jamais visto, foram milhares de downloads em um único dia, porém para que servia? Para muita gente era uma forma de programar para Web (nessa data a Internet ainda estava engatinhando). O slogan principal era: "Escreva uma vez e rode em qualquer lugar". Falando francamente a linguagem só atingiu a maturidade em 1998 com a chegada da versão 1.2, até lá era confusa e sem um objetivo definido. Com a Swing a linguagem teve um objetivo construção de aplicativos desktop. Em 2002 veio a versão 1.4 divisora de mundos com os três ambientes conhecidos até hoje JSE, JEE e JME.

Um dia, estava lendo a Exame Informática que tinha uma comparação entre Java e .NET (recém lançada da Microsoft e principal concorrente de Java na época) e chamaram dois especialistas para mostrar os benefícios de cada uma. Achei engraçado que metade do artigo de .NET dissertava sobre "os malefícios de Java" ao invés dos benefícios de se usar essa outra linguagem. Só que um dos malefícios era basicamente o seguinte:

O problema de Java foi a pressa para preencher buracos, o pensamento era: precisamos rodar na Web damos uns tapas no ASP e criamos a JSP, precisamos rodar no desktop criamos a Swing e para acessar banco de dados mudamos a ODBC e criamos a JDBC.

Neste dia entendi um dos fatores para o sucesso de Java, a capacidade em se adaptar rapidamente para qualquer ambiente.

Vejamos um outro detalhe. Quantos amigos conhece que possui um celular com o sistema operacional Java. Esse tipo de celular foi um grande fracasso, mas por adaptação Java entrou nesse mundo dos celulares graças ao Android (que possui por base o sistema Linux mas a linguagem de seus aplicativos é Java). JSF por muito tempo perdeu o espaço para diversos outros Frameworks como Struts, Seam e Spring. Qual a IDE Oficial de Java? Se respondeu Eclipse saiba que é da IBM e foi um pedaço cedido para a comunidade do VisualAge for Java que não alcançou o sucesso desejado (na época os desenvolvedores adoravam o JBuilder - Antiga Borland). A IDE oficial de Java é o NetBeans que nunca atingiu a preferência dos desenvolvedores. De mesma forma o Servidor de Aplicação Glassfish é substituido pelo JBoss (RedHat). O TomCat só foi usado em larga escala quando entrou como parte do Projeto Jakarta da Apache.

E se reparar em toda a história do Java quem fez sucesso foram terceiros que criavam adaptações bem sucedidas porém usando a linguagem Java. Podemos concluir que o segundo fator para o sucesso de Java está em uma comunidade forte para criar/adaptar aplicativos, ferramentas e sistemas que os usuários usem.

Resultado, Java criou um muro de proteção com esses dois pilares (sua capacidade rápida de adaptação e uma comunidade forte) que dificilmente (não acredito que seja impossível) outra linguagem sera capaz de superar. Por esse motivo a linguagem tornou-se um sucesso.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →