# Estrutura Docker Image

Uma imagem é um elemento estático e somente leitura com o intuito de ser um

template para a execução de um container.

Os containers são construídos a partir de imagens montadas uma em cima das outras
de maneira recursiva.

Veja uma ilustação de como funciona esses containers


Percebam que na figura acima, temos dois containers do Widfly 8 rodando, porém o
que dá suporte para a sua execução é as duas imagens "intermediárias" contendo uma
imagem do Widfly e outra do Java. Mas a sua base está calcada na imagem do DEBIAN 8
que denominados de base image.

Podemos dividir essas imagens em duas camadas como vista na imagem abaixo

As camadas são:
**Layer Writable**: É quando as nossas camadas realmente estão em execução, ou
podemos dizer que são os containers propriamente ditos. Eles são capazes de fazer
manipulação de dados, armazenar informações, mas só até o ciclo de vida desse
container.
**Layer Read-Only**: Quando um container está em execução, as camadas que dão
suporte para ele passam a estar apenas em leitura. Elas também dão suporte para
UnionFS e Copy on Write(CoW)

Um overview dos containers ficaria assim. Onde todo container tem um base image.

## Consumo de Imagens ou Executando Containers

Vamos lá para alguns containers

`docker run _image_`: Aqui é onde executamos um container. É apartir desse comando
que vamos ter o nosso container funcionando. Um aviso importante é que se somente
executarmos uma imagem dessa forma sem passar nenhum parâmentros para executar
algo, o nosso container morrerá.

`docker images`: Lista todas as imagens que nós temos em nosso computador
vinculadas ao docker, trazendo algumas informações sobre cada imagem como: qual o
repositório que ela foi criada, tag, ID, quando ela foi feita e seu tamanho.

`docker ps`: Ela lista os containers em execução ou que estão rodando. Se passarmos
a flag, `-a` , ela lista todos os containers que já foram executados alguma vez.

### Trabalhando com elementos adicionais no docker run

Para vermos alguns conceitos dentro do docker run, podemos dividir esse comando da
seguinte forma:


Onde temos que:

- `docker run`: o comando propriamente dito
- `options`: São as possibilidades de interações que podemos ter ao iniciar um
container. Elas podem ser:
- i: Solicita interação com o container ou inicia interação com o container
 - t: inicia um terminal
- d: para iniciar um terminal em segundo plano.
- rm: Após o término da execução do container, mata ele.
- `image`: È base image que desejamos fazer o download do repositório do docker.
- `commands`: Podemos adicionar comandos na inicialização do container. Então,
vamos supor que depois de baixar e executar o container, eu gostaria que ele
fizesse um ping para algum local. Isso acrescentaria uma tempo de execução para o
container, mas isso, ele irá para de funcionar. Ex: `docker run -itd
debian:bullseye ping 127.0.0.1`. A gente precisa entender que esse comando tem que
ter suporte dentro do container.

Outro parâmetro interessante ao fazer a criar e executar um contaneiner é passar o

`--name` para nomear esse container de alguma forma.

`docker run -it`: Comando para rodar o docker de maneira interativa e do um

terminal

### Referências externas sobre imagens em docker

http://edu.delestra.com/docker-slides/

http://pointful.github.io/docker-intro/

https://docs.docker.com/engine/reference/run/

https://docs.docker.com/engine/reference/commandline/run/

https://www.aquasec.com/wiki/display/containers/Docker+Images+101

https://docs.docker.com/config/containers/resource_constraints/

https://docs.docker.com/samples/

https://www.docker.com/resources