Trabalhando com API parte I

Olá pessoal!

Hoje vamos mostrar como realizar as operações mais básicas do Docker através da API dele. Vamos ver como iniciar, parar, criar, excluir e coletar informações de containers através da API. Estarei utilizando a distribuição CentOS 7 em meu host onde vou criar os containers.

– Como habilito a API?

vim /etc/systemd/system/docker.service 

//Vamos alterar a linha que contém ExecStart=/usr/local/bin/docker -d -H fd:// por essa

ExecStart=/usr/local/bin/docker -d -H fd:// -H 0.0.0.0:4243

service docker restart

Agora estamos com nossa API habilitada e escutando na porta 4243.

– Iniciar

curl -X POST http://IPHost:4243/containers/IDContainer/start

– Parar

curl -X POST http://IPHost:4243/containers/IDContainer/stop

– Excluir

curl -X DELETE http://IPHost:4243/containers/IDContainer

– Criar

curl -X POST -H "Content-Type: application/json" http://IpHost:4243/containers/create -d '{
"Hostname":"",
   "User":"",
   "Memory":0,
   "MemorySwap":0,
   "AttachStdin":false,
   "AttachStdout":true,
   "AttachStderr":true,
   "PortSpecs":null,
   "Privileged":false,
   "Tty":false,
   "OpenStdin":false,
   "StdinOnce":false,
   "Env":null,
   "Dns":null,
   "Image":"busybox",
   "WorkingDir":""
}'

– Renomear

curl -X GET http://IPHost:4243/containers/IDContainer/rename?name=novo_nome

– Exibir containers que estão iniciado

curl -X GET http://IPHost:4243/containers/json

– Exibir todos os containers

curl -X GET http://IPHost:4243/containers/json?all=1

– Top

curl -X GET http://IPHost:4243/containers/IDContainer/top

– Stats

curl -X GET http://IPHost:4243/containers/IDContainer/stats

– Images

curl -X GET http://IPHost:4243/images/json?all=0

Por hoje era isso, fiquem atentos para as novidades e ajude divulgando o mundodocker.com.br!

Primeiros passos – Criando uma imagem

Olá pessoal,

Anteriormente vimos o que era uma imagem e o que era um Dockerfile, agora vamos descobrir como criar uma imagem a partir da interação com um container. Vamos trabalhar da seguinte maneira:

Vamos criar uma imagem com apache com interação com o container.

Vamos começar criando o container com docker run -it centos /bin/bash agora que estamos dentro dele, vamos executar os seguintes comandos:

yum install wget -y
wget http://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-5.noarch.rpm
rpm -ivh epel-release-7-5.noarch.rpm

yum install httpd -y,

Instalamos o apache dentro do container, mas quando iniciarmos o container novamente, o serviço do apache não irá iniciar, pois o container não possui os serviços de inicialização então vamos usar um serviço chamado Supervisord que faz com que sempre que eu reiniciar o container eu possa já iniciar alguns serviços.

sudo yum install python-setuptools
sudo easy_install pip
sudo pip install supervisor
echo_supervisord_conf > supervisord.conf
sudo cp supervisord.conf /etc/supervisord.conf
sudo mkdir /etc/supervisord.d/
sudo vi /etc/supervisord.conf

Com o arquivo de configurações do supervisord aberto vamos alterar e adicionar algumas linhas:

Altere a linha que tenha

[include]
files =
[include]
files = /etc/supervisord.d/*.conf

Agora vamos criar o arquivo: vi /etc/rc.d/init.d/supervisord

Coloque esse código dentro do arquivo:

#!/bin/sh
#
# /etc/rc.d/init.d/supervisord
#
# Supervisor is a client/server system that
# allows its users to monitor and control a
# number of processes on UNIX-like operating
# systems.
#
# chkconfig: - 64 36
# description: Supervisor Server
# processname: supervisord

# Source init functions
. /etc/rc.d/init.d/functions

prog="supervisord"

prefix="/usr/"
exec_prefix="${prefix}"
prog_bin="${exec_prefix}/bin/supervisord"
PIDFILE="/var/run/$prog.pid"

start()
{
       echo -n $"Starting $prog: "
       daemon $prog_bin --pidfile $PIDFILE
       [ -f $PIDFILE ] && success $"$prog startup" || failure $"$prog startup"
       echo
}

stop()
{
       echo -n $"Shutting down $prog: "
       [ -f $PIDFILE ] && killproc $prog || success $"$prog shutdown"
       echo
}

case "$1" in

 start)
   start
 ;;

 stop)
   stop
 ;;

 status)
       status $prog
 ;;

 restart)
   stop
   start
 ;;

 *)
   echo "Usage: $0 {start|stop|restart|status}"
 ;;

esac
sudo chmod +x /etc/rc.d/init.d/supervisord
sudo chkconfig --add supervisord
sudo chkconfig supervisord on
supervisord

Agora já podemos adicionar nosso serviço até o supervisord. Abra novamente o arquivo: /etc/supervisord.conf
Adicione ao final do arquivo as seguintes linhas.

[program:httpd]
command=/usr/sbin/httpd -D FOREGROUND -k start
environment=APACHE_LOG_DIR=/var/log/httpd
redirect_stderr=true

Após isso vamos executar supervisorctl update e supervisorctl você poderá ver que foi adicionado o serviço httpd ao supervisord.
Vamos criar o arquivo vi /run.sh e dentro dele colocar as linhas seguintes:

#!/bin/bash
supervisord &
sleep 2

/bin/bash

chmod +x /run.sh

Agora vamos criar a imagem, pressione CTRL + P + Q . Agora estamos no console do Host, para criar a imagem vamos executar docker commit id_container nome_imagem. Agora é só colocar docker run -it nome_imagem /run.sh e você estará iniciando seu Servidor Web.

Obrigado pessoal, por hoje é isso.

Coleta de recursos

Olá pessoal,

Hoje vamos ver como mostrar os recursos sendo utilizado por cada container, como: Rede, Memória, Disco e CPU.

Vamos mostrar quatro maneiras de coletar os recursos. São elas:

– Docker stats

– API

– Cadvisor

– Cgroups

Docker stats: o comando docker stats foi adicionado nas ultimas versões do Docker, com ele agora podemos verificar as métricas de cada container em tempo real, porém não temos acesso ao histórico desses containers. Para usar este comando basta colocar docker stats id_container.

API: Em cada distribuição Linux o modo de habilitar a API é de uma maneira diferente. Vou mostrar aqui como fazer no CentOS 7. Abra o arquivo /etc/sysconfig/docker e altere a linha que tem OPTIONS= por OPTIONS=--selinux-enabled -H fd:// -H tcp://0.0.0.0:4243. Após isso reinicie o serviço do docker para que a porta da API seja aberta no host. Isso quer dizer que a porta 4243 deste servidor estará acessível de qualquer outro computador. Executando o seguinte comando podemos ver os containers que estão iniciados:

curl -X GET http://ipservidor:4243/containers/json

Esse comando retorna o JSON com as informações dos containers que estão iniciado.

Cadvisor: Fornece aos usuários a visualização de consumo por processo no host e também do container em tempo real. Com ele podemos verificar os recursos de Rede, Memória, CPU e informações do sistema. Para tudo isso basta executar o seguinte comando:
docker run \
--volume=/:/rootfs:ro \
--volume=/var/run:/var/run:rw \
--volume=/sys:/sys:ro \
--volume=/var/lib/docker/:/var/lib/docker:ro \
--publish=8080:8080 \
--detach=true \
--name=cadvisor \
google/cadvisor:latest

Agora vá até o seu navegador coloque o seguinte endereço http://ip:8080

Cgroups: O Docker cria a limitação de seu containers através de CGROUPS (Acesse Aqui para saber mais sobre o que é CGROUPS) com ele podemos visualizar quanto de recursos aquele processo está usando. Dentro de /sys/fs/cgroup estão os recursos que podemos limitar no Docker. Podemos acessar o diretório memory/system.slice/docker-xxxxxxx.scope e dentro dele dar um cat memory.usage_in_bytes que nos mostra a quantidade de memória que o container xxxxxxx está usando. Dentro desse diretório temos outras contadores também que nos próximos posts apresentaremos.

Bom pessoal, por hoje foi isso então, em nossos próximos posts estaremos trabalhando outros tópicos avançados dentro do ambiente Docker, então fique atento, e tendo dúvidas já sabe, nos mande uma mensagem, abraço!

O que é uma imagem?

Olá pessoal,

Hoje vamos falar a sobre images, mas a final o que são images no Docker?

Images Docker são compostas por sistemas de arquivos de camadas que ficam uma sobre as outras. Ela é a nossa base para construção de uma aplicação, ela pode ser desde o base do CentOS como também um CentOS com Apache, PHP e MySQL.

Em uma Image temos o que chamamos de base que é um sistema de arquivos de inicialização bootfs, que é muito parecido com o sistema de boot do Linux / Unix. Nessa parte é onde temos toda a criação dos cgroups para fazer todo o controle e limitações de processos, namespace para blindar o container. O Docker nunca irá interagir com o sistema de arquivos de inicialização, pois quando o recipiente é iniciado ele é movido para a memória e o boot do sistema de arquivos é desmontado para liberar a memória RAM usada pela imagem de disco initrd. Isso parece muito com a pilha de virtualização típica do Linux. A próxima camada de uma imagem é a raiz na qual trabalha o rootfs, na parte superior do sistema de arquivos de inicialização, este rootfs pode ser um ou mais sistemas operacionais (Ex: Ubuntu, CentOS).

No momento do boot o sistema de arquivos raiz é montado somente leitura e depois de uma checagem de integridade é alterado para leitura e gravação. Isso no começo pode ser muito confuso, mas com a imagem abaixo vocês devem entender melhor como funciona.

docker-filesystems-busyboxrw

Como podemos ver na imagem, temos a parte dobootfs que é a parte do Kernel e a também a camada do rootfs que é a do Debian. Mais acima temos algumas adições de features na imagem que são add emacs e add apache. Todas essas camadas abaixo são somente leitura então nada será alterado nessas partes, a camada de escrita é apenas a que está acima dessas outras quatro camadas, é nessa camada que o usuário ou administrador do container irá interagir e poderá criar novas imagens, por exemplo adicionando um serviço php e dai criará uma nova imagem com mais uma camada somente leitura e assim vamos criando nossas imagens.

Por hoje é isso pessoal, em breve vamos estar mostrando como criar uma imagem, então fique ligado em nossos posts.

Primeiros passos – Instalação

Olá pessoal,

Hoje vamos ver como damos o pontapé inicial com Docker, vamos começar com a instalação e depois algumas informações básicas sobre alguns comandos.

Usuários que tem o seu sistema baseado em Debian podem usar o apt-get ou o aptitude:

sudo apt-get update
sudo apt-get install docker.io

Usuários que tem o seu sistema baseado em RedHat podem usar o yum:

yum install docker

A versão de Docker que estou utilizando é a versão 1.6.2 que é a versão mais nova até hoje. Na instalação default de ambiente de Docker as configurações principais de seus contêineres ficam em /var/lib/docker aqui você pode encontrar o .json de todos os seus containers com suas respectivas configurações, em nossos próximos posts estaremos mostrando o que significa cada parâmetro e como podemos melhorar a performance de nosso ambiente. Agora vou mostrar para vocês os comandos que temos no Docker:

docker attach  – Acessar dentro do container e trabalhar a partir dele.
docker build   – A partir de instruções de um arquivo Dockerfile eu possa criar uma imagem.
docker commit  – Cria uma imagem a partir de um container.
docker cp      – Copia arquivos ou diretórios do container para o host.
docker create  – Cria um novo container.
docker diff    – Exibe as alterações feitas no filesystem do container.
docker events  – Exibe os eventos do container em tempo real.
docker exec    – Executa uma instrução dentro do container que está rodando sem precisar atachar nele.
docker export  – Exporta um container para um arquivo .tar.
docker history – Exibe o histórico de comandos que foram executados dentro do container.
docker images  – Lista as imagens disponíveis no host.
docker import  – Importa uma imagem .tar para o host.
docker info    – Exibe as informações sobre o host.
docker inspect – Exibe r o json com todas as configurações do container.
docker kill    – Da Poweroff no container.
docker load    – Carrega a imagem de um arquivo .tar.
docker login   – Registra ou faz o login em um servidor de registry.
docker logout  – Faz o logout de um servidor de registry.
docker logs    – Exibe os logs de um container.
docker port    – Abre uma porta do host e do container.
docker pause   – Pausa o container.
docker ps      – Lista todos os containers.
docker pull    – Faz o pull de uma imagem a partir de um servidor de registry.
docker push    – Faz o push de uma imagem a partir de um servidor de registry.
docker rename  – Renomeia um container existente.
docker restart – Restarta um container que está rodando ou parado.
docker rm      – Remove um ou mais containeres.
docker rmi     – Remove uma ou mais imagens.
docker run     – Executa um comando em um novo container.
docker save    – Salva a imagem em um arquivo .tar.
docker search  – Procura por uma imagem no Docker Hub.
docker start   – Inicia um container que esteja parado.
docker stats   – Exibe informações de uso de CPU, memória e rede.
docker stop    – Para um container que esteja rodando.
docker tag        – Coloca tag em uma imagem para o repositorio.
docker top        – Exibe os processos rodando em um container.
docker unpause – Inicia um container que está em pause.
docker version – Exibe as versões de API, Client e Server do host.
docker wait   – Aguarda o retorno da execução de um container para iniciar esse container.

Esses são todos os comandos que possuímos na versão 1.6.2 do Docker. Nos próximos posts estaremos mostrando como utilizar todos esses comandos e em qual momento devemos escolher entre um e outro.

Ficou com dúvida? Gostaria de saber mais? Algum feedback a nos dar? Deixe sua mensagem e vamos conversando.

Abraço!