Docker: Imagens, Containers, e seus principais comandos
Tags: container, imagens, docker, ambientes
Published: 2020-06-20 16:17:01

O Docker veio para facilitar a criação e gerenciamento de ambientes, para usos perssoais, de empresas e comunidades open-source. Rodando apenas um comando, agora podemos ter o ambiente inteiro em que um projeto foi construido, com suas versões e aplicações instaladas e rodando.

E agora a frase "Mas na minha máquina funciona" já não é mais necessária, porque sempre teremos o mesmo ambiente, independente de onde a aplicação esteja rodando. :D

Vamos ver um pouco de como o Docker funciona e o que podemos fazer com ele!

## Container

Um container é onde as dependências serão instaladas, as aplicações e tudo para nosso projeto poder rodar. Ele utiliza de imagens (como pequenos SOs como base) para rodar a aplicação. Quando a aplicação precisar utilizar o Kernel, ela não utilizará o Kernel do container, porque ele não possui um. Ele utilizará o Kernel do **host docker** (máquina física).

Este único Kernel irá gerenciar todos os container em execução.

Um container **não** é uma VM, como muitas pessoas dizem. Em uma VM todo o SO é virtualizado, um SO completo com um kernel e muitas camadas até a aplicação, consumindo muito mais recursos.

Um container é pequeno, a aplicação fica muito mais perto da infraestrutura e SO.

Uma VM emula uma *máquina* , um container emula uma *aplicação.*

![Container and VM structure](https://dev-to-uploads.s3.amazonaws.com/i/ivn5l5ocva3olxg1emc6.png)

Um container também é portável, você facilmente consegue pegar os binários que o Docker cria e passar para uma outra máquina/servidor, funcionará perfeitamente.

## Imagens

Uma imagem é como se fôsse um container em um ponto no tempo ou como um container parado.

Quando você constrói um container, usa imagens que foram um container e compartilhado no **Dockerhub** (ou você pode construir a sua própria do zero).

Se você constrói um container, para ele e compartilha, outras pessoas poderão usar ele como uma imagem dentro de seus containers.

Usando o conceito de POO, é como se a imagem fosse uma classe e o container uma instância desta imagem.

### Camadas

O **file system** do Docker trabalha com camadas.

Quando se está construindo uma imagem, cada passo cria uma camada, e todas as camadas são **read-only,** exceto a última, que será sempre **read-write.**

![Image Layers](https://dev-to-uploads.s3.amazonaws.com/i/44yb46wjcd3o9vxomz7n.png)

![Image layers with an application](https://dev-to-uploads.s3.amazonaws.com/i/4n7ceozlbadvf7ak3m7t.png)

### Copy on Write

Quando é preciso modificar uma camada read-only, esta camada será copiada para a camada **read-write** e então poderá ser modificada.

Esta ação é chamada de **Copy on Write.**

É como se fosse um livro, que você pode ler, mas quando você for alterar uma página, no momento em que você encosta a caneta na folha está folha é copiada e você modifica esta folha copiada, que criará uma nova folha, preservando a folha antiga.

## Comando da CLI do Docker

### RUN

```bash
docker run hello-world
```

É o comando que inicializa um container, passando o nome da imagem que o container irá utilizar.

Se o Docker não encontrar esta imagem localmente, ele autmaticamente ira tentar encontrar esta imagem no **Dockerhub** irá começar a fazer seu download e em seguida rodar o container.

### PS

```bash
docker ps
```

Lista todos os containers em execução.

Passando o parâmetro `-a` depois de `ps` irá listar todos os containers, incluindo os que estão parados.

### IMAGES

```bash
docker images
```

Vai listar todas as imagens que estão na sua máquina.

### CREATE

```bash
docker create ubuntu
```

Irá criar um container, mas não irá executá-lo.

### STOP

```bash
docker stop container-id
```

Para um container.

### START

```bash
docker start container-id
```

Inicia um container parado.

### STATS

```bash
docker stats container-id
```

Mostra os status que um container está utilizando, como memória, rede e CPU.

### RM

```bash
docker rm container-id
```

Remove um container, se um container estiver em execução, use o parâmetro  `-f` para forçar.

## Parâmetros importantes do comando RUN

## -ti

```bash
docker run -ti image-name /bin/bash
```

O *t* é de *terminal*, e *i* de *interativo*, então estamos dizendo que queremos utilizar o terminar e que seja interativo para utilizar o container.

### -d

```bash
docker -d image-name
```

É para todar um container em modo daemon (em background).

É útil para containers "data-only", que não precisará de interação.

### ATTACH

```bash
docker attach container-id
```

Retorna para um container fechado (mas não parado).

## Commandos para o Bash

### CTRL + D

Vai fechar o container, matando o bash, e se o bash for o job principal do container, irá matar o container também.

### CTRL + P + Q

Irá sair do container sem matar ele, apenas fechado. Você pode voltar para este container utilizando o comando`attach`.

## Bônus: liberando memória

```bash
docker rm $(docker ps -a -q); docker rmi $(docker images -a -q) -f
```

```bash
docker system prune --volumes
```

## Conclusão

O Docker veio para ajudar muito em nossas vidas, com apenas algumas configurações, nós podemos desenvolver um grande ambiente, em que qualquer um com Docker poderá utilizar também.