por ·0 comentários

Até agora explicamos como o Docker funciona, como instalar, criar um container e administrá-lo. Agora veremos como colocar todas as informações de uma imagem em um único arquivo chamado Dockerfile.

 

Vamos fazer uma imagem para subir um container com o Debian 8.7 e instalar o NGINX.
Primeiramente devemos criar, no host Docker, um diretório onde ficará esse Dockerfile.

cd ~

mkdir Docker && cd Docker && mkdir Nginx && cd Nginx


Após isso, vamos criar um arquivo chamado Dockerfile. Atentar para a grafia com a primeira letra maiúscula. Dentro desse arquivo, vamos colocar as seguintes informações:

 

FROM debian:8.7

MAINTAINER contato@161.35.238.43

RUN apt-get update && apt-get install -y nginx

EXPOSE 80

 

Ao colocar essa informação, salve e feche o arquivo. Feito isso, vamos agora executar o Dockerfile com o seguinte comando:

# docker build .

O Docker Build não trabalha com o caminho do arquivo, apenas com o seu diretório, então é necessário informar o caminho do diretório ou, no nosso caso, como estamos no diretório onde se localiza o Dockerfile, apenas um ponto para identificar que o Dockerfile está no diretório atual.

Caso todas as informações estejam corretas, sua imagem será criada e podemos atestar isso com o “docker images”.

 

 

A imagem está criada, mas sem o REPOSITORY e a TAG, pois não repassamos essa informação. Caso queira preencher os campos, basta usar o parâmetro “-t”.

# docker build -t brunoizidorio/nginx:1.0

Utilizamos a nomenclatura repositório/nome e tag. Agora vamos detalhar o nosso primeiro Dockerfile:

  • O Dockerfile funciona no formato: INSTRUÇÃO argumento.
  • O campo FROM é o nome da imagem que utilizamos, nesse caso o Debian 8.7.
  • MAINTAINER é a informação de quem criou o Dockerfile.
  • RUN são os comandos que queremos executar na imagem que escolhemos. Aqui informamos a instalação do Nginx. Lembre-se de sempre colocar o parâmetro para aceitar automaticamente a instalação, caso contrário o Dockerfile apresentará erro, pois estará esperando uma interação.
  • Como o Nginx funciona na porta 80, vamos expor essa porta do container usando o EXPOSE.

 

O primeiro argumento do Dockerfile deve ser sempre o FROM, seguido da imagem e versão que será utilizada. Caso não seja informada a versão, o Docker vai procurar a mais atual do seu repositório oficial. Abaixo, outros argumento utilizados no Dockerfile:

  • MAINTAINER: quem escreve o dockerfile;
    Ex: MAINTAINER contato@161.35.238.43
  • RUN: executa os comandos dentro do container;
    Ex: apt-get update && apt-get install -y nginx
  • ADD: adiciona arquivos, diretórios do host ou de uma url para dentro de um diretório do container, mas não funciona com arquivos compactados;
    Ex: ADD arquivo.txt /home/bruno/
  • CMD: informa os parâmetros que serão usados no ENTRYPOINT. Também pode ser utilizado para informar qual comando será executado após a criação do container, mas pode ser sobrescrito caso seja passada algum parâmetro de execução de algum comando na hora de executar o container;
    Ex: CMD [“nginx”, “-g”, “daemon off;”]
  • LABEL: coloca um metadado para o container;
    Ex: LABEL description=”Container do Nginx”
  • COPY: copia arquivos e diretórios do host para dentro de um diretório do container. Funciona com com arquivos compactados;
    Ex: COPY arquivo.txt /home/bruno/
  • ENTRYPOINT: informa qual será a aplicação principal do container, sendo executada após a inicialização do container. Diferente do CMD, não será sobrescrita. Caso a seja finalizada a execução do programa definido no ENTRYPOINT, o container será encerrado;
    Ex: ENTRYPOINT [“nginx”, “-D”, “FOREGROUND”]
  • ENV: cria uma variável de ambiente;
    Ex: meunome=”Bruno Izidório”
  • EXPOSE: expõe a porta informada do container;
    Ex: EXPOSE 80
  • USER: define qual será o usuário padrão para o container. Caso não seja definido, o padrão é o usuário root;
    Ex: USER bruno
  • WORKDIR: determina qual diretório será o padrão ao fazer o login;
    Ex: WORKDIR /home/bruno/downloads
  • VOLUME: permite a criação de um diretório no host onde fica armazenado os dados do container;
    Ex: VOLUME /home/docker/nginx:/usr/share/nginx/html

 

Ao som de The Neal Morse Band – So Far Gone

por ·0 comentários

Esse post é uma continuação direta do anterior, onde foi criado um container baseado em um imagem. Nesse post vamos detalhar mais a utilização das imagens.
Caso não tenha lido, clique aqui: http://161.35.238.43/docker-instalando-o-docker/

 

Para ver as imagens contidas no Docker da sua máquina, basta digitar:

# docker images

 

Irá aparecer uma tela com 5 campos: REPOSITORY, TAG, IMAGE ID, CREATED e SIZE.

  • REPOSITORY é correspondente ao nome da imagem;
  • TAG é a versão da imagem criada;
  • IMAGE ID é o número de identificação que o Docker cria para a sua imagem. Mais a frente iremos ver outros comando onde poderemos informar tanto o nome quanto a ID da imagem;
  • CREATED é a data da criação da imagem;
  • SIZE é o tamanho total da imagem que foi criada.

 

Como dito anteriormente, foi realizado o download de uma imagem para a execução de uma aplicação, hello-world, dentro de um container. Já vimos a imagem, agora é hora de ver o container com o comando:

# docker ps

 

No nosso caso, não irá aparecer nenhum container, apenas os 7 campos de identificação dos containers: CONTAINER ID, IMAGE, COMMAND, CREATED, STATUS, PORTS e NAMES.

  • CONTAINER ID é o número de identificação do container, equivalente ao IMAGE ID do “docker images”;
  • IMAGE informa qual imagem foi utilizada para a criação do container;
  • COMMAND mostra qual é o comando que está em execução no container. Veremos mais informações a frente;
  • CREATED é a data de criação do container;
  • STATUS exibe o status atual do container;
  • PORTS informa as portas do host e do container que foram utilizadas. Também será tratado mais a frente;
  • NAMES informa o nome do container.

Você deve estar se perguntando por que não tem nenhum container se você executou o Hello World. Se ele é um container, ele era para aparecer quando digitou o comando docker ps ou não?


Para responder essa dúvida, vamos utilizar o parâmetro “-a” no comando anterior. Ficará assim:

# docker ps -a

 

Com a inserção do parâmetro “-a”, o docker exibe todos os containers, incluindo os que estão parados ou que já foram finalizados. Com este comando, o container “hello-world” irá aparecer. O que aconteceu é que o container “hello-world” foi criado e logo em seguida, finalizado. Nesse caso específico, esse container serve apenas como teste para ver se o docker está criando os containers normalmente. Então, o docker fez o download da imagem, criou o container, exibiu a tela da nossa primeira imagem e depois foi finalizado.

Para exemplo de como criar um container e deixá-lo funcionando, vamos criar um novo container com o conteúdo do Ubuntu 14.04.

O comando para criação é esse:

# docker run -ti ubuntu:14.04 /bin/bash

 

O docker run já havíamos visto anteriormente, mas há novos argumentos. O “-t” diz ao container que vamos precisar de um terminal. O “-i” que este container será interativo, ou seja, o STDIN ficará ativo. Também identificamos qual imagem e versão utilizamos com o argumento, o ubuntu:14.04. No último argumento estamos informando qual processo queremos que o container inicie, no caso, o Bash.

Assim que digitar o comando, o docker inicialmente vai procurar a imagem localmente, no nosso caso, Ubuntu 14.04. Como não vai encontrar, ele fará o download da imagem oficial no seu repositório (https://hub.docker.com/explore/) e irá criar o container baseado nessa imagem.

Ao terminar a criação do container, o docker já permite interação direta dentro do container. Para verificar a veracidade dessa informação, basta digitar um comando que identifique qual a versão instalada. No caso do Ubuntu 14.04 vamos exibir o arquivo issue.

 

# cat /etc/issue

 

Nesse ponto é importante que você se atente a infraestrutura que foi montada até agora. Caso você esteja executando seu Docker em uma máquina Debian 8, por exemplo, há um outro sistema operacional, o Ubuntu 14.04, funcionando dentro de um container.

Temos um Ubuntu 14.04 funcionando dentro de um container. Este container está sendo executado dentro do Debian 8 e os dois sistemas estão utilizando o mesmo Kernel, neste caso é Kernel do Debian 8 que é onde o Docker está instalado e gerenciando os containers.

Como estamos atualmente dentro do container do Ubuntu, digite “uname -r” e verá que o resultado vai ser o mesmo obtido anteriormente, no momento da verificação da versão do kernel do host.

Para sair do container sem finalizá-lo, segure a tecla Ctrl e digite na ordem a letra P e depois a Q, só aí você pode soltar o Ctrl. Há uma segunda maneira de sair do container, porém essa finaliza o bash, assim, finalizando o container também. O segundo comando é o Ctrl+D. Isso acontece, pois quando informamos o bash na hora da criação da imagem, estamos passando para o Docker que o Bash será o processo principal do container, chamado de entrypoint. Caso o entrypoint seja finalizado, o container também é finalizado.

 

No nosso exemplo, vamos usar o primeiro comando para manter o container ativo. Agora, executar o comando docker ps para ver se o container criado com a imagem do Ubuntu 14.04 está ativo.

# docker ps

 

Caso queira acessar novamente um container, basta usar o attach e o seu ID para acessá-lo. Lembre-se, como o número do ID é único, ele irá aparecer diferente no seu ambiente.

# docker attach 5c595a8d4237

 

Na versão 1.13 (hoje renomeada para 17.03) foi foram realizadas mudanças que trouxeram mais organização ao Docker. Esse mesmo “docker attach” pode ser feito através do “docker container attach”. Isso porque foi implementado um submenu para cada função. Abaixo, alguns comandos do submenu container:

  • attach (container ID): Acessa um container ativo;
  • commit: Cria uma imagem baseado no container ativo;
  • create: Cria um novo container, mas sem acessá-lo;
  • exec (container ID): Executa um comando no container sem acessá-lo;
  • inspect (container ID): Mostra todas as informações do container;
  • kill (container ID): Finaliza um ou mais container;
  • ls: Lista todos os containers;
  • pause (container ID): Pausa o container (sério?);
  • port (container ID): Lista as portas usadas no momento da criação do container. Será visto mais a frente;
  • prune: Finaliza todos os containers que não estão sendo usados.
  • rm (container ID): Remove um ou mais container;
  • start (container ID): Inicia um ou mais container;
  • stats (container ID): Mostra o status do container;
  • stop (container ID): Para um ou mais container;

Para ver a lista completa:

# docker container –help

 

No próximo post vou abordar o Dockerfile!

Ao som de: Emerson, Lake & Palmer – Tarkus

por ·0 comentários

No primeiro post falei um pouco sobre o que o Docker é (e o que não é também) e como ele funciona. Recomendo a leitura para não ficar perdido em alguns conceitos que apareceram nesse post e nos seguintes. Clique aqui para ir ao post “O que é Docker?”.

Nesse segundo post, como prometido, um pouco de prática. Vamos fazer a instalação do Docker em um Debian!

Primeiramente, vamos verificar os requisitos de instalação:

  1. O processador deve ser 64bits;
  2. O Kernel do sistema operacional base deve ser igual ou superior a versão 3.10 estável;
  3. O Kernel deve ter suporte à AUFS, Device Mapper, OverlayFS, Cgroups e Namespaces.

 

Caso não saiba qual versão do Kernel do seu sistema, basta digitar o comando no terminal:

# uname -r

 

Em algumas distribuições, o Docker já está no repositório. No nosso caso, vamos usar o Debian como Sistema Operacional Base para fazer a instalação do Docker.

 

Se não souber qual o Debian está usando, digite o comando lsb_release -cs que retornará uma das palavras: Wheezy (para o Debian 7), Jessie (para o Debian 8) ou Stretch (para o Debian 9).

 

Se o retorno que obteve foi Jessie ou Stretch, digite o seguinte comando:

# sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

 

Caso tenha aparecido Wheezy:

# sudo apt-get -y install apt-transport-https ca-certificates curl python-software-properties

 

Para as duas situações acima, os próximos comandos são os mesmos:

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –
# sudo add-apt-repository \
“deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable”
# sudo apt-get update

 

Esses comandos irão instalar as dependências necessárias para fazer o download, a adição dos repositórios oficiais e atualização desses repositórios.

Observação: Se estiver usando o Wheezy e apresentar erro quando for atualizar o repositório, altere o arquivo /etc/apt/sources.list apagando a linha que contém essa informação:
deb-src [arch=amd64] https://download.docker.com/linux/debian wheezy stable

 

Agora basta fazer a instalação do docker-ce (O Docker CE, Community Edition, é a versão gratuita do docker) utilizando nosso querido APT-GET:

# sudo apt-get -y install docker-ce

 

O sistema operacional irá instalar a versão mais nova do docker. No momento dessa postagem o Docker está contando as versões pelo Ano.Mês, no caso a versão atual é a 17.05.

 

Agora vamos verificar se já foi feita a instalação normalmente e se é possível criar um container. Após o término da instalação, vamos digitar no terminal:

# docker run hello-world

 

Esse comando irá criar um container, com uma imagem personalizada, com a frase mais conhecida pelos estudantes de programação (com uma pequena variação): Hello World.

 

 

Caso tenha aparecido um texto igual a da imagem acima, você já criou o seu primeiro container!

Com esse comando o Docker verificou se já existia o container Hello-world. Como não existia, pois acabamos de fazer a instalação, o próprio Docker fez o download da imagem e depois criou o container utilizando, automaticamente, essa imagem. Mágico, não?

 

O objetivo desse post era abordar apenas a instalação do Docker-ce e verificar se a instalação ocorreu normalmente. Caso queira fazer a instalação do Docker em outros sistemas operacionais, vá a página oficial do Docker para as instruções de cada sistema operacional. Clique aqui para ir direto à pagina.

 

Ao som de Dream Theater – In The Name of God