Dockerfile: principais comandos e instruções
Tags: docker, dockerfile, infraestrutura, comandos
Published: 2020-06-24 23:29:48

O Dockerfile é o meio que utilizamos para construir uma imagem.

Ele funciona como uma receita, em que vamos passando uma imagem base, comandos e todo o passo a passo.

Ao construir este Dockerfile, criamos nossa imagem, e a partir desta imagem, criamos nosso container.

## Comandos mais úteis no Dockerfile

## FROM

```docker
FROM debian
```

Deve ser o primeiro comando de um Dockerfile, com ele configuramos qual a imagem que queremos utilizar como base na nossa imagem.

## ADD

```docker
ADD opa.txt /diretorio/
```

Para mover um arquivo para dentro de um diretório do container, podendo ser arquivos `.tar` .

## CMD

```docker
CMD ["sh, "-c", "echo", "$HOME"]
```

Define um comando para ser executado quando um container com esta imagem inicializar.

Pode haver apenas uma instrução CMD em um Dockerfile. Se você adicionar mais de um, apenas o último entrará em vigor.

Ele pode ser sobrescrito se passarmos outro comando na linha de comando, como:

```bash
docker run -d minha-imagem /bin/bash
```

## LABEL

```docker
LABEL Description="Bla bla bla giropops"
```

Para adicionar uma descrição ao container e ficar mais fácil de gerenciar os containers.

## COPY

```docker
COPY opa.txt /diretorio/
```

Semelhante ao ADD, porém vc pode copiar arquivos normais e diretórios.

## ENTRYPOINT

```docker
ENTRYPOINT ["npm", "run", "dev"]
```

É bem parecido com o `CMD`, mas este não pode ser sobrescrito, ele sempre será executado e o container irá rodar como um executável.

Quando este comando "morrer", o container morrerá também.

## ENV

```docker
ENV API_KEY="Igor Souto"
```

Para configurar variáveis de ambiente para o container.

## EXPOSE

```docker
EXPOSE 80
```

Configura portas que o container irá expor, e então o container será acessível por essas portas.

## RUN

```docker
RUN apt-get update && apt-get install apache2 && apt-get clean
```

Usado para executar comandos no contêiner, geralmente usado para instalar pacotes.
Cada RUN cria uma nova camada em nosso contêiner, portanto, precisamos evitar criar `RUN`s demais, criar menos camadas e não deixar tudo muito confuso, afinal, só temos acesso read-write na última camada, dependendo sobre o que queremos fazer, não podemos (por exemplo, apt-get clean rodando em outro RUN).
Para entender melhor como funcionam as camadas da imagem, acesse [aqui](https://dev.to/soutoigor/docker-imagens-containers-e-seus-principais-comandos-23p6) o post sobre Docker.

## USER

```docker
USER igor
```

Para definirmos qual será o usuário dentro do container, por padrão ele é o usuário ROOT.

## WORKDIR

```docker
WORKDIR /catota
```

Para definirmos qual o diretório de trabalho. Assim que o container for executado, este diretório será o que iremos cair dentro ao acessar o container.

## VOLUME

```docker
VOLUME /diretorio
```

Passamos o caminho em que o Docker irá criar um **volume**, ou seja, um diretório que terá uma cópia em nossa máquina local e que se alterarmos algo neste diretório, será alterado dentro do container também e vice-versa.

## MAINTAINER

```docker
MAINTAINER Igor igor@email.com
```

Passamos quem é o dono do container.

## Build container

```bash
docker build -t primeira_imagem:1.0 .
```

Agora para buildar a imagem, usamos o comando `build` do Docker. passamos o parametro `-t`para nomear esta imagem, dois pontos e uma versão. E utilizamos o " . ", para dizer que nosso Dockerfile se encontra neste mesmo nível de diretório. Não apontamos o Dockerfile, e sim o diretório que ele se encontra.