Author Archives: Luis Fernando Chaim

Cassandra e Docker – Ubuntu

Este post apresenta a instalação e utilização do Apache Cassandra, usando Docker.

Baixando a Imagem Docker

$ sudo docker pull cassandra

Esse comando efetuará o download da última versão do Cassandra (latest)

Verificando a Imagem

$ sudo docker images

Resultado

REPOSITORY TAG     IMAGE ID      CREATED     SIZE
cassandra latest 8ea89760ce2b 5 weeks ago 323MB

Subindo o Cassandra

$ sudo docker run --name node1 -d cassandra:lastest

Resultado

f451246389a40761b5a70cbb2d665801f3b2356afcd3abf6ee9a7aa4bd1fe064

Baixando o Cassandra

$ sudo docker stop f451246389a40761b5a70cbb2d665801f3b2356afcd3abf6ee9a7aa4bd1fe064

Removendo

$ sudo docker rm node1

Verificando processos

$ docker exec -it node1 nodetool status

Ferramenta shell CQL

Dentro do container é possível executar o cqlsh.

$ docker exec -it node1 cqlsh
Connected to Test Cluster at 127.0.0.1:9042.
[cqlsh 5.0.1 | Cassandra 3.11.0 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh>

Criando Keyspace

cqlsh> CREATE KEYSPACE myspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};

Criando uma tabela

CREATE TABLE myspace.exam (
patient_id int,
id int,
date timeuuid,
details text,
PRIMARY KEY (patient_id, id));

Inserindo dados

INSERT INTO exam (patient_id,id,date,details) values (1,1,now(),'first exam patient 1');
INSERT INTO exam (patient_id,id,date,details) values (1,2,now(),'second exam patient 1');
INSERT INTO exam (patient_id,id,date,details) values (2,1,now(),'first exam patient 2');
INSERT INTO exam (patient_id,id,date,details) values (3,1,now(),'first exam patient 3');

Consultando dados

cqlsh:patient> select * from exam where patient_id=1;

Instalando MySQL no Ubuntu usando Docker

Baixando a Imagem

$ sudo docker pull mysql/mysql-server:latest

Rodando o MySQL

$ sudo docker run -it –name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -d mysql

Verificando Logs

$ sudo docker logs mysql

Parando o MySQL

$ sudo docker stop mysql

Reiniciando o MySQL

$ sudo docker start mysql

Removendo o MySQL

$ sudo docker rm mysql

Forma alternativa

$ sudo docker run -d –name=mysql-server -p 3306:3306 -v mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root mysql

Listando imagens

$ sudo docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
mysql latest ecac195d15af 23 hours ago 516MB
mongo latest 0e120e3fce9a 3 months ago 449MB
amazon/dynamodb-local latest 7984b9b533e7 5 months ago 613MB

$ sudo docker rmi ecac195d15af

Instalando ELK no Ubuntu

Este post apresenta de forma fácil, a instalação do ELK no Ubuntu.

Baixando a imagem Docker

Para baixar a imagem ELK, execute o comando abaixo.

$ sudo docker pull sebp/elk:latest

Subindo a imagem ELK

Para subir a aplicação, execute o comando abaixo.

$ sudo docker run -p 5601:5601 -p 9200:9200 -p 5044:5044 -it --name elk sebp/elk

OBS: Se apresentar erro de memória, execute o comando abaixo.

$ sudo sysctl -w vm.max_map_count=262144

Esse comando é uma solução temporária, ao reiniciar o sistema, volta o valor padrão.

Para configurar a memória de forma definitiva, utilize o comando:

$ sudo gedit /etc/sysctl.conf

Adicionar a linha abaixo e salvar o arquivo.

vm.max_map_count=262144

Após subir a aplicação, pode-se testar os ambientes.

Elasticsearch:

http://localhost:9200

Kibana:

http://localhost:5601

Para a imagem

$ sudo docker ps

Resultado:

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7b1600afd168 sebp/elk “/usr/local/bin/star…” 15 minutes ago Up 14 minutes 0.0.0.0:5044->5044/tcp, 0.0.0.0:5601->5601/tcp, 0.0.0.0:9200->9200/tcp, 9300/tcp elk

Para com o id do container

$ sudo docker stop 7b1600afd168

Remover o nome elk

$ sudo docker rm elk

 

Instalando Docker Compose no Ubuntu

Este post demonstra como instalar o Docker Compose no Ubuntu.

Procedimento via curl

Faça o download conforme o comando abaixo

$ sudo curl -L “https://github.com/docker/compose/releases/download/1.23.1/docker-compose-$(uname -s)-$(uname -m)” -o /usr/bin/docker-compose

Altere as permissões para executar o arquivo

$ sudo chmod +x /usr/bin/docker-compose

Verifique a instalação

$ docker-compose -v

 

Docker – Principais Aplicações

Este post tem por objetivo, demonstrar de forma fácil, as principais aplicações do Docker.

Elasticsearch

Baixando a imagem

$ sudo docker pull docker.elastic.co/elasticsearch/elasticsearch:6.4.3

Rodando a imagem

$ sudo docker run -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” docker.elastic.co/elasticsearch/elasticsearch:6.4.3

Logstash

Baixando a imagem

$ sudo docker pull docker.elastic.co/logstash/logstash:6.4.3

Rodando a imagem

$ sudo docker run –rm -it -v ~/pipeline/:/usr/share/logstash/pipeline/ docker.elastic.co/logstash/logstash:6.4.3

Kibana

Baixando a imagem

$ sudo docker pull docker.elastic.co/kibana/kibana:6.4.3

Rodando a imagem

$ sudo docker run -dt -p 5601:5601 -e “ELASTICSEARCH_URL=http://elastic:9200” –network=elastic docker.elastic.co/kibana/kibana:6.4.3

Informações Adicionais

Docker & Elastic

Fonte: https://www.docker.elastic.co

MongoDB – Principais Comandos

Este post tem objetivo de demonstrar os principais comandos do MongoDB.

Banco de dados

> show dbs

Lista os bancos existentes.

> use [NOME_DO_BANCO]

Define o banco como ativo. Significa que todas as demais operações serão aplicadas no banco ativo.

Collections (Coleções)

> show collections

Lista todas as collections existentes no banco ativo.

> db.[COLLECTION].find()

Lista todos os registros na Collection informada.

> db.getCollectionInfos()

Retorna toda a informação das Collections (nome, tipo, índices, etc).

> db.[COLLECTION].help()

Apresenta todos os métodos permitidos na Collection.

> db.runCommand ( { compact: '[COLLECTION]', paddingFactor: 1.1 } )

Efetua a compressão e defragmentação da Collection. O paddingFactor padrão é 1.0.

Interagindo SpringData com MongoDB

Introdução

Este post apresenta de forma simples, como interarir com MongoDB, usando SpringData.

Pré-requisitos

Para efetuar os testes, é necessario estar com o MongoDB rodando. Veja como instalar e executar o MongoDB aqui.

Interface MongoRepository

O MongoRepository é implementado com muitas APIs para armazenar e recuperar dados. Podemos usar o MongoRepository com operações CRUD genéricas completas da interface CrudRepository, e métodos adicionais da interface PagingAndSortingRepository para paginação e ordenação. O MongoRepository também estende o QueryByExampleExecutor para permitir a execução da consulta por exemplo.

Criar projeto SpringBoot

Criar o projeto usando Spring Initializr ou STS (SpringSource Tool Suite)

Arquivo Maven e Dependências

O arquivo de configuração (pom.xml) deve ter a configuração do SpringBoot e dependência do spring-boot-starter-data-mongodb.

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.7.RELEASE</version>
</parent>

<groupId>br.com.whs.springmongodb</groupId>
<artifactId>spring-mongodb</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

<name>spring-mongodb</name>

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-mongodb</artifactId>
   </dependency>
</dependencies>

Classes do Projeto

Classe de Entidade

São as classes responsáveis pelo mapeamento da persistência no banco de dados.

Utilizam 2 anotações:

  • @Document – identifica o objeto de domínio da persistência no MongoDB
  • @Id – determina o Identificador do documento (neste caso da collection)

Classe Repository

As classes deve estender (extends) a classe MongoRepository.

Classe Service

Possuem função de fachada entre as classes Web e o Repository.

Classe Controller

Neste caso, utilizamos essas classes para atender as chamadas REST.

Classe Application

Esta é a classe responsável pelo funcionamento do SpringBoot. Como os valores de configuração foram mantidos, ele rodará sob o Tomcat (embedded) na porta 8080.

Rodando a aplicação

Pode rodar a aplicação de 2 formas:

  • Rodando a classe SpringMongoDBApplication (Run / Run As / Java Application)
  • Executando o comando $ mvn tomcat:run

Postman

Para rodar os testes, utilizamos o Postman, uma poderosa ferramenta para testar endpoints e APIs.

Adicionar User

Configurar o Postman, da seguinte forma:

  • Method: POST
  • URL: http://localhost:8080/user
  • Body: raw
  • Tipo: JSON (application/json)
  • Exemplo:
{
  "name": "lfchaim",
  "profile": [
    {
      "name": "admin"
    },
    {
      "name": "dev"
    }
  ],
  "age": 36,
  "email": "lfchaim@gmail.com"
}

Listar User

A listagem, sem parâmetros, retornará todos os registros do banco (collection: user).

Configuração:

  • Method: GET
  • URL: http://localhost:8080/user

O projeto completo pode ser baixado no Github.

MongoDB – Docker – Ubuntu

Introdução

Neste post, vamos instalar e rodar o MongoDB, usando Docker no Ubuntu.

Pré-requisitos

Ter o Docker instalado no Ubuntu. Veja como instalar aqui.

Pesquisando bibliotecas MongoDB

Aqui, vamos verificar quais bibliotecas MongoDB estão disponíveis para download no Ubuntu.

# docker search mongodb

Resultado:

No nosso exemplo, vamos utilizar a versão oficial “mongo”.

Baixar a biblioteca

Vamos baixar a biblioteca “mongo”

# docker pull mongo

Aguarde o processo de instalação concluir.

Verificar imagem baixada

# docker images

Rodar a imagem

# docker run --name testemongo -p 27017:27017 -d mongo

Parar a imagem

# docker stop testemongo

Reiniciar a imagem

# docker start testemongo

Entrar no container

Agora, vamos entrar no container para subir o MongoDB do container.

# docker exec -it testemongo /bin/bash

Subir o MongoDB

Dentro do container, vamos iniciar o MongoDB.

# mongo

Resultado:

Pronto! O MongoDB está disponível para utilização.

Comandos do Docker

Docker info

docker info

Quando nós acabamos de subir o Docker Engine, nós utilizamos esse comando para verificarmos as informações do nosso Docker Host.

Docker version

docker version

Com o version nós conseguimos ver a versão do nosso Client, para esse artigo estou utilizando o Windows e o Server que para esse exemplo estamos utilizar o Linux. Quanto ao OS/Arch do server nós podemos trabalhar com Windows ou Linux, caso você esteja utilizando o Docker for Windows basta clicar em Swith to Windows Containers que ele irá realizar essa alteração.

Docker images

docker images

Nós utilizamos ele para listarmos as imagens que nós temos no nosso host, como eu acabei de instalar o Docker no meu Windows a lista está vazia como podemos ver na imagem a baixo:

  • Repository: repositório;
  • TAG: tag utilizada no repositório;
  • IMAGE ID: o id na nossa imagem;
  • Created: data de quando nós criamos a nossa imagem;
  • Size: tamanho da imagem;

Docker search

docker search (parametro)

Para que possamos procurar uma imagem, nós podemos utilizar o comando a baixo com o parâmetro nome Ex.: ubuntu, dotnetcore, node … etc, assim ele irá buscar as imagens que são compatíveis com o nosso server que para esse exemplo estamos utilizando o Linux.

Docker pull

docker pull (parametro)

Quando encontrarmos a imagem que precisamos para a nossa aplicação, nós precisamos baixar ela para o nosso host.

Docker run

docker pull (nome da imagem)

Para que nós possamos criar um contêiner, nós precisamos de uma imagem. Caso você não tenha essa imagem no seu host ainda ele irá até o repositório central e irá baixar ela para o seu host, em seguida ele irá criar o contêiner.

Docker ps

docker ps 

Agora vamos verificar o status do nosso contêiner, execute o comando acima no seu terminal.

Docker status

docker stats (id ou apelido do container)

Para que possamos ter informações sobre um contêiner nos executamos o comando acima, ele nos retorna dados como:

  • CONTAINER — ID do Container;
  • CPU % — uso de CPU em porcentagem;
  • MEM USAGE / LIMIT — Memória usada/Limite que você pode ter setado;
  • MEM — uso de memória em porcentagem;
  • NET I/O — I/O de Internet;
  • BLOCK IO — Outros processos de I/O;

Docker inspect

docker inspect (id da imagem ou container)

Caso você precise de mais detalhes sobre a sua imagem ou o seu contêiner, podemos utilizar o comando inspect. Ele irá retornar um json com todas as informações relacionadas a nossa busca.

Docker rmi

docker rmi (nome da imagem)

Caso você tenha baixado uma imagem errada ou queira deletar alguma por um outro motivo, basta executar o comando a cima que ele deleta ela do seu host.

Docker rm e ps

Você pode excluir todos os containers criados

$ sudo docker rm ($ sudo docker ps -a)

Ou remover os criados e parados

$ sudo docker rm ($ sudo docker ps -a -q)

Docker exec

docker exec (id_container ou nome_container) 

Com o exec nós podemos executar qualquer comando nos nossos contêineres sem precisarmos estar na console deles.

Vejamos a baixo alguns dos parâmetros que podemos utilizar com ele:

  • -i permite interagir com o container
  • -t associa o seu terminal ao terminal do container
  • -it é apenas uma forma reduzida de escrever -i -t
  • --name algum-nome permite atribuir um nome ao container em execução
  • -p 8080:80 mapeia a porta 80 do container para a porta 8080 do host
  • -d executa o container em background
  • -v /pasta/host:/pasta/container cria um volume ‘/pasta/container’ dentro do container com o conteúdo da pasta ‘/pasta/host’ do host

Docker attach

docker attach (id_container ou nome_container)

Vamos agora entrar dentro do nosso contêiner e verificar o nosso novo arquivo criado. Para isso execute o comando acima + o nome do ou id do seu contêiner, podemos observar que a execução dele irá nos dar acesso de root no nosso contêiner.

Docker start

docker start (id do container)

Quando nós saimos do nosso container com o comando exit, ele mata o nosso processo.

Para que possamos dar um dettach ou em outras palavras sair sem fecharmos ele, nós precisamos dos comandos: Ctrl+p + Ctrl+q. Para que possamos subir ele novamente vamos utilizar o comando start.

Agora execute o comando attach novamente para entrar no seu contêiner e depois os comandos : Ctrl+p + Ctrl+q, em seguida podemos verificar que o nosso contêiner ainda está em execução.

Docker stop

docker stop (id ou nome container)

Para que possamos parar um contêiner que esteja sendo executado, nós utilizamos o comando stop. Sua execução é bem simples, nós passamos o mesmos parâmetros que utilizamos no start.

Mapeamento de Portas

-p host:container

Para que possamos testar o mapeamento de portas iremos baixar a imagem do ngnix e passarmos para ele a porta 80. Para isso execute o comando a baixo no seu terminal:

docker run -it -p 8080:80 nginx

Ele irá baixar a imagem do nginx para o seu host e abrir ele na porta 8080 do seu host. Para testar assim que ele finalizar a execução do comando acima, abra no seu navegador o endereço: http://localhost:8080/, podemos ver o seu retorno na imagem a baixo.

Mas executando ele dessa forma nós ficamos com o nosso console travado.

Para que possamos ter um contêiner sendo executado em background, nós podemos utilizar eles em segundo plano. Para isso, só precisamos passar o comando -d. Caso ainda esteja o seu contêiner ainda esteja sendo executado, execute o comando control c para sair dele, em seguida execute o mesmo comando anterior só que agora com o parâmetro -d:

docker run -it -d -p 8080:80 nginx

Instalando MongoDB no Ubuntu em 4 passos

Introdução

Este post tem por objetivo demonstrar como instalar o MongoDB no Ubuntu, de forma fácil. O procedimento foi executado no Ubuntu 16.04 LTS e funcionou perfeitamente.

Configurando o Repositório

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 9DA31620334BD75D9DCB49F368818C72E52529D4

Adicionar o Repositório

Ubuntu 18.04 LTS

$ echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb.list

Ubuntu 16.04 LTS

$ echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/4.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb.list

Atualizar biblioteca

$ sudo apt update

Instalar o MongoDB

$ sudo apt install mongodb-org

Pronto! A etapa de instalação esta concluída. Agora veremos como utilizar o MongoDB.

Gerenciando MongoDB Service

Habilitando o MongoDB

$ sudo systemctl enable mongod

Iniciando o MongoDB

$ sudo systemctl start mongod

Parando o MongoDB

$ sudo systemctl stop mongod

Verificando a versao

$ mongod --version

Fonte: https://tecadmin.net/install-mongodb-on-ubuntu/