# CMD e ENTRYPOINT no Docker

No Docker, tanto o `CMD` quanto o `ENTRYPOINT` são usados para definir o processo principal que será executado dentro de um container. Ambos têm funções semelhantes, mas são utilizados de maneira diferente dependendo do comportamento que você deseja que o container tenha.

#### O que é CMD?

O `CMD` no Dockerfile é utilizado para especificar o comando padrão a ser executado quando um container é iniciado. No entanto, ele pode ser substituído por argumentos passados na linha de comando ao executar o container. O Docker permite definir o `CMD` de duas formas:

* **Forma shell**: `CMD comando param1 param2`
    
* **Forma exec**: `CMD ["executable", "param1", "param2"]`
    

##### Exemplo de CMD:

```Dockerfile
FROM ubuntu:latest
CMD ["echo", "Hello, World!"]
```

Neste exemplo, o comando `echo` é o comando padrão executado quando o container é iniciado. Se quisermos substituir esse comando durante a execução do container, podemos fazer isso assim:

```bash
docker run <container_id> echo "Outro comando"
```

O `CMD` será sobrescrito pelo novo comando passado na linha de comando.

#### O que é ENTRYPOINT?

Já o `ENTRYPOINT` define um comando que será sempre executado e não pode ser sobrescrito facilmente. Ele é útil quando você deseja garantir que um determinado comando será sempre executado, independentemente de argumentos adicionais fornecidos ao container. O `ENTRYPOINT` também pode ser definido de duas formas:

* **Forma shell**: `ENTRYPOINT comando param1 param2`
    
* **Forma exec**: `ENTRYPOINT ["executable", "param1", "param2"]`
    

##### Exemplo de ENTRYPOINT:

```Dockerfile
FROM ubuntu:latest
ENTRYPOINT ["echo", "Mensagem fixa:"]
```

Se você executar o container com:

```bash
docker run <container_id> "Este é o argumento"
```

O resultado será:

```bash
Mensagem fixa: Este é o argumento
```

Aqui, o `ENTRYPOINT` é sempre executado, mas você pode adicionar argumentos na execução do container.

#### CMD vs ENTRYPOINT

Embora os dois sejam usados para definir o comando que será executado, eles diferem em como interagem com os argumentos fornecidos durante a execução do container. Algumas diferenças importantes:

**Substituição**:

O `CMD` pode ser facilmente sobrescrito ao passar um comando na execução do container.

O `ENTRYPOINT`, por outro lado, não é sobrescrito. Ele sempre será executado, e qualquer argumento adicional será passado como argumento do `ENTRYPOINT`.

**Combinando os dois**: Você pode usar o `CMD` e o `ENTRYPOINT` juntos. Neste caso, o `ENTRYPOINT` define o executável que será sempre rodado, enquanto o `CMD` define os parâmetros padrão que podem ser sobrescritos.

##### Exemplo combinando ENTRYPOINT e CMD:

```Dockerfile
FROM ubuntu:latest
ENTRYPOINT ["echo"]
CMD ["Argumento padrão"]
```

Ao executar o container sem passar argumentos:

```bash
docker run <container_id>
```

O resultado será:

```bash
Argumento padrão
```

Mas, se você passar um argumento durante a execução:

```bash
docker run <container_id> "Outro argumento"
```

O resultado será:

```bash
Outro argumento
```

#### Considerações adicionais

**Script como ENTRYPOINT**: Uma prática comum é usar um script como `ENTRYPOINT` para garantir que o container sempre execute o script desejado, mas ainda permita passar argumentos adicionais.

**Execução de serviços**: O `ENTRYPOINT` é mais adequado para containers que são configurados para rodar como serviços, enquanto o `CMD` é útil para containers que podem ter comandos mais dinâmicos dependendo da situação.

#### Em Resumo:

* Use `CMD` quando quiser fornecer um comando padrão que pode ser sobrescrito.
    
* Use `ENTRYPOINT` quando quiser garantir que um comando específico sempre será executado.
    
* Combine `CMD` e `ENTRYPOINT` para fornecer flexibilidade ao seu container.