sábado, 26 de novembro de 2016

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

sábado, 19 de novembro de 2016

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

quarta-feira, 16 de novembro de 2016

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