Docker - Primeiro uso (Conhecendo)

Prévia do material em texto

Página 1 de 6 
Docker 
 
LABORATÓRIO 
 
Figura 1 – Visão do que é um Docker 
Fonte: https://www.slideshare.net/abhishekchawla12/buildwithaws-70400062 
 
 
1 CONTATO 
(Elaborado pelo Prof. José Humberto Cruvinel) 
 
Este laboratório, tem como S.O base (host) o Windows 2010 e para isso foi solicitado a instalação do 
Docker Toolbox. Verifique se esse recurso está corretamente instalado, basta procurar o programa 
abaixo: 
 
 
 
 
Página 2 de 6 
1. EXECUTANDO COMANDOS BÁSICOS COM DOCKER 
1.1. Baixando e executando uma imagem 
 Vamos agora baixar uma imagem do Alpine, uma distribuição Linux de apenas 4,5MB. Execute o 
comando abaixo para pesquisar por essa imagem: 
docker search alpine 
 
Para baixar uma imagem digite o comando abaixo: 
docker pull alpine 
 
Para listar as imagens já baixadas localmente, digite o comando abaixo: 
docker images 
 
Localize a imagem que foi baixada (exemplo) 
alpine latest 3fd9065eaf02 3 months ago 4.15MB 
 
Outra forma de pesquisar é acessando o site https://hub.docker.com/. Entre nesse site e pesquise 
pelo Alpine. Em seguida clique no link do Alpine conforme a tela abaixo: 
 
 
Clique na aba Tags e veja as versões disponíveis para o Alpine 
 
 
 
 
Estamos interessados na versão 3.5 e não na última versão. Para baixá-la basta utilizar o comando 
abaixo: 
https://hub.docker.com/
https://hub.docker.com/
 
 
Página 3 de 6 
docker pull alpine:3.5 
 
Como não vamos mais utilizar a versão alpine:latest, podemos removê-la com o comando abaixo: 
docker rmi alpine:latest 
 
Para verificar que a imagem foi removida, vamos digitar o comando abaixo: 
docker images 
 
Agora vamos executar um container tendo como base essa imagem do Alpine que foi baixada. Para 
isso, execute o comando abaixo: 
docker run --name alpine_c1 -it alpine:3.5 /bin/sh 
 
Pronto! Você estará rodando um Linux super pequeno e já pode executar comando tais como “ls la”, 
“cal”, “date” e demais comandos básicos de um sistema Linux. Porém deve se lembrar que essa á 
uma imagem mínima de um Linux, com apenas 4MB de tamanho, logo, vários comandos conhecidos 
do Linux não estarão disponíveis. 
1.2. INSTALANDO PACOTES EM UM CONTAINER 
 Vamos agora adicionar um pacote neste Linux, o py2-pip. Para isso, execute o comando abaixo no 
prompt do Alpine que foi aberto dentro do docker: 
# apk add --update py2-pip 
# pip install --upgrade pip 
 
Veja que o python2 e o gerenciador de pacotes pip para Python foram instalados no container, o 
que pode ser verificado digitando o comando abaixo: 
# python -V 
 # pip -V 
 
Veja que este container já não é mais idêntico à imagem que o gerou. 
 
Para verificar o funcionamento desse container, abra um novo terminal 
 
Digite nesse novo terminal o comando 
abaixo para listar os containers em execução 
ou parados: 
docker ps -a 
 
Exemplo de um container em execução: 
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 
1122771f3669 alpine:3.5 "/bin/sh" 2 minutes ago Up 12 minutes alpine_c1 
 
1.3. PARANDO E RESTAURANDO UM CONTAINER 
Volte ao primeiro terminal, onde estava executando o Linux Alpine, e digite “exit” 
 
Digite novamente o comando abaixo no segundo terminal: 
docker ps -a 
 
Página 4 de 6 
 
Vai ver que o status mudou para “Exited”: 
Quando o container está neste estado, isso significa que ele está parado. Para executá-lo novamente, 
voltando ao estado em que estava, execute o comando abaixo no primeiro terminal: 
docker start -ai alpine_c1 
 
Execute os comandos abaixo para verificar que acessou o container correto: 
 # python -V 
# pip -V 
 
Obs: Caso queira abrir um novo terminal e acessar o Alpine em execução. Basta executar o comando 
abaixo. Faça isso no segundo terminal 
Docker attach alpine_c1 
ou 
docker exec -it alpine_c1 /bin/sh 
Saia do Linux digitando “exit” e feche este segundo terminal digitando “exit” novamente. 
 
Vimos até então como é fácil instanciar um novo container, instalar pacotes, parar, restaurar e 
acessar novamente. 
 
1.4. CRIANDO UMA IMAGEM A PARTIR DE UM CONTAINER 
Agora vamos aprender a criar uma nova imagem a partir de um container existente. 
Criamos um container baseado no Alpine 3.5 e adicionamos os pacotes python e pip. Vamos criar 
uma nova imagem a partir desse container com o nome alpine_py2. 
Para isso, volte ao primeiro terminal, digite “exit” para sair do container, o que fará que ele fique 
com status “Exited”. Confira isso digitando: 
 docker ps -a 
Em seguida, vamos executar um comando para poder criar uma imagem a partir desse container: 
 
docker commit --author "digite seu @ email aqui" --message "alpine com python 2.7 e pip 10" alpine_c1 alpine_py2 
 
Para verificar que a nova imagem foi gerada com sucesso, execute om comando abaixo: 
docker images 
Poderá ver a nova imagem criada: 
REPOSITORY TAG IMAGE ID CREATED SIZE 
alpine_py2 latest 10c71a9b1450 6 minutes ago 55.1MB 
 
Perceba que o tamanho da nossa imagem cresceu para 55MB, uma vez que instalamos novos 
pacotes no Alpine. Agora poderemos utilizar essa nova imagem para criar novos containers. 
 
1.5. CRIANDO UMA IMAGEM A PARTIR DE UM DOCKERFILE 
 Um uso mais comum do Docker é a criação de um Dockerfile, o qual contém os passos para a 
montagem e execução de um container com a aplicação instalada e executando. No nosso exemplo 
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 
1122771f3669 alpine:3.5 "/bin/sh" 2 minutes ago Exited (0) 11 seconds ago alpine_c1 
 
 
Página 5 de 6 
vamos utilizar a aplicação flask-app, que consiste em uma aplicação simples que roda no servidor 
python Flask na porta 5000 em um microcontainer Alpine com Python 2. 
 
Para criar uma imagem com suas customizações é necessário existir no mínimo um diretório e um 
arquivo com o nome dockfile. Ex.: c:\dockerbuild\dockerfile 
Pegue com o professor o arquivo flask-app.zip e descompacte em uma pasta à sua escolha. Abra o 
arquivo dockerfile que está dentro desta pasta e avalie o seu conteúdo: 
# our base image 
FROM alpine:3.5 
 
# Install python and pip 
RUN apk add --update py2-pip 
 
# upgrade pip 
RUN pip install --upgrade pip 
 
# install Python modules needed by the Python app 
COPY requirements.txt /usr/src/app/ 
RUN pip install --no-cache-dir -r /usr/src/app/requirements.txt 
# copy files required for the app to run 
COPY app.py /usr/src/app/ 
COPY templates/index.html /usr/src/app/templates/ 
# tell the port number the container should expose 
EXPOSE 5000 
 
# run the application 
CMD ["python", "/usr/src/app/app.py"] 
 
Veja no arquivo que estamos 
utilizando como base a 
imagem alpine:3.5 e que 
estamos instalando o python 2 
e pip assim como fizemos 
manualmente. 
Em seguida, são instaladas 
algumas dependências, 
copiadas os arquivos da 
aplicação, exposta a porta 
5000 e executada a aplicação 
app.py com o programa 
python. 
 
Os arquivos necessários à montagem dessa aplicação também estão na mesma pasta do arquivo 
Dockerfile. 
 
Para compilar a imagem tendo como base o 
Dockerfile, abra o terminal. Navegue até a 
pasta onde está o arquivo Dockerfile e 
execute o comando abaixo: 
docker build -t flask_<digite seu primeiro nome> . 
 Se você não passar o parâmetro -t sua imagem ficará sem nome no repositório. 
 
Execute o comando abaixo para verificar a imagem gerada: 
docker images 
 
REPOSITORY TAGIMAGE ID CREATED SIZE 
alpine_py2 latest 10c71a9b1450 26 minutes ago 55.1MB 
 flask_cruvinel latest d33c7be7b230 2 days ago 65.8MB 
 
Vamos inspecionar a imagem através do comando abaixo: 
docker image inspect flask_cruvinel 
 
Agora basta rodar o container, mas antes vamos descobrir qual o IP_DOCKER (IP local do Docker) 
com o comando abaixo: 
 
Página 6 de 6 
docker-machine ip default 
 
Em seguida, execute o container a partir da imagem gerada com o comando abaixo: 
docker run -p 8888:5000 --name minhaaplicacao flask_cruvinel 
O comando acima executa um container com o nome “MinhaAplicacao” a partir da imagem gerada 
“flask_cruvinel” fazendo a tradução da porta 5000 (que roda a aplicação) para a porta 8888. 
 
A saída será a seguinte: 
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit) 
 
Agora abra o seu navegador de preferência em sua máquina host e acesse a aplicação pelo endereço 
http://IP_DOCKER:8888 
 
 
 
 Finalmente, poderá parar sua aplicação 
docker stop MinhaAplicacao 
 
 Para iniciar o container contendo a aplicação com os comandos abaixo: 
docker start MinhaAplicacao 
 
 Para remover sua imagem recentemente criada use o comando 
docker rm MinhaAplicacao 
Lembre-se apenas de parar seu container antes de remover a imagem 
 
 Exportando sua imagem para um diretório no seu computador 
docker save -o c:\images\ MinhaAplicacao.tar MinhaAplicacao 
 
 Importando a imagem para seu docker 
docker load -i c:\images\ MinhaAplicacao.tar 
 
http://ip_docker:8888/
http://ip_docker:8888/