EXPOSE

A instrução EXPOSE em um Dockerfile é usada para documentar quais portas o contêiner está escutando em tempo de execução. Isso informa aos usuários da imagem (e ao Docker) quais portas devem ser abertas para permitir a comunicação com o contêiner. É importante notar que EXPOSE não publica ou abre realmente essas portas fora do contêiner; ele apenas documenta as portas para referência.

Sintaxe Básica

EXPOSE <porta> [<porta>/<protocolo>...]

porta: O número da porta que o contêiner escutará.
protocolo (opcional): O protocolo utilizado pela porta, como tcp ou udp. O padrão é tcp se não especificado.

Funcionalidades do `EXPOSE`

Documentação Interna: EXPOSE serve como uma maneira de documentar quais portas um serviço no contêiner usa. Isso pode ser útil para outros desenvolvedores ou para o gerenciamento da imagem.
Integração com Docker: Quando docker run é usado com a flag -P (ou --publish-all), o Docker publica todas as portas expostas no contêiner, mapeando-as para portas disponíveis no host.

Exemplos de Uso

Expor uma Porta Simples

FROM nginx:alpine
EXPOSE 80

Neste exemplo, a porta 80 é exposta, indicando que o servidor NGINX dentro do contêiner estará escutando nessa porta.

Expor Múltiplas Portas

FROM node:14
EXPOSE 3000 8080

Aqui, as portas 3000 e 8080 são expostas, o que indica que a aplicação Node.js pode escutar em ambas as portas.

Especificando o Protocolo

FROM ubuntu:20.04
EXPOSE 1234/udp

Neste exemplo, a porta 1234 é exposta usando o protocolo UDP, que é diferente do padrão TCP.

Usando `EXPOSE` em Execução

Embora EXPOSE declare quais portas um contêiner está escutando, ele não publica essas portas para o host. Para acessar essas portas externamente, você deve usar a flag -p (ou --publish) ou -P (ou --publish-all) no comando docker run:

Mapear uma Porta Específica:
```
docker run -p 8080:80 nome_da_imagem
```
Esse comando mapeia a porta 80 do contêiner para a porta 8080 no host, tornando o serviço acessível através do host na porta 8080.
Publicar Todas as Portas Expostas:
```
docker run -P nome_da_imagem
```
O Docker mapeará automaticamente todas as portas expostas pelo contêiner para portas aleatórias disponíveis no host.

Boas Práticas e Considerações

Documentação: Use EXPOSE para documentar as portas que seus serviços utilizam, mesmo que você não planeje publicá-las externamente. Isso ajuda outros desenvolvedores e ferramentas a entender como interagir com o contêiner.
Segurança: Lembre-se de que EXPOSE não abre as portas para o mundo exterior; ele apenas documenta. Para publicar portas de maneira segura, combine EXPOSE com a flag -p ao executar o contêiner.
Protocolo Correto: Especifique o protocolo correto (TCP ou UDP) quando necessário. Embora o TCP seja o padrão, algumas aplicações, como DNS e outras que dependem de UDP, exigem a especificação do protocolo.
Flexibilidade: Considere deixar a decisão de quais portas publicar para o comando docker run, o que oferece mais flexibilidade para o usuário da imagem.

Exemplo Avançado

Expondo e Publicando Portas para um Servidor Web

FROM python:3.10
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt
EXPOSE 5000

CMD ["python", "app.py"]

Aqui, a aplicação Python escuta na porta 5000. A instrução EXPOSE 5000 documenta essa porta. Para acessar a aplicação externamente, o usuário pode usar:

docker run -p 5000:5000 nome_da_imagem

Isso mapeia a porta 5000 do host para a porta 5000 do contêiner.

Resumo

EXPOSE documenta as portas que um contêiner está escutando, sem publicá-las automaticamente.
Flexibilidade e Segurança: Combine EXPOSE com as opções de mapeamento de porta no comando docker run para publicar as portas conforme necessário.
Documentação: É uma prática recomendada usar EXPOSE para tornar explícito quais portas os serviços dentro do contêiner utilizam.

Laboratório

Exposição da porta na construção do container

FROM ubuntu
RUN apt update && apt install nginx --yes

$ docker build -t ubuntu-curl .
[+] Building 12.6s (6/6) FINISHED                            docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 91B                                    0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => CACHED [1/2] FROM docker.io/library/ubuntu:latest                  0.0s
 => [2/2] RUN apt update && apt install nginx --yes                   12.3s
 => exporting to image                                                 0.2s
 => => exporting layers                                                0.2s
 => => writing image sha256:8edfa0b82e4f70e11588db20a3fc90f0feac0761b  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
$ docker container run -it -p 8080:80 ubuntu-curl /bin/bash
root@37cb79dfe76b:/# /usr/sbin/nginx -g "daemon off;"

$ docker container ls
CONTAINER ID   IMAGE         COMMAND       CREATED              STATUS              PORTS                                   NAMES
37cb79dfe76b   ubuntu-curl   "/bin/bash"   About a minute ago   Up About a minute   0.0.0.0:8080->80/tcp, :::8080->80/tcp   modest_greider

Destaque para:

PORTS
0.0.0.0:8080->80/tcp, :::8080->80/tcp

Execução do container sem o portbind

$ doccontainer run -it ubuntu-curl /bin/bash
root@a95b0a059049:/#

$ docker container ls
CONTAINER ID   IMAGE         COMMAND       CREATED         STATUS         PORTS     NAMES
a95b0a059049   ubuntu-curl   "/bin/bash"   4 seconds ago   Up 4 seconds             gifted_mclean

Destaque para a porta não especificada:

PORTS

Exposição da porta do container

FROM ubuntu
EXPOSE 80
RUN apt update && apt install nginx --yes

$ docker build -t ubuntu-curl .
[+] Building 0.1s (6/6) FINISHED                             docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 101B                                   0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [1/2] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/2] RUN apt update && apt install nginx --yes             0.0s
 => exporting to image                                                 0.0s
 => => exporting layers                                                0.0s
 => => writing image sha256:d3b0bc104c38cdc052a771bf0f0bc0b764edc6cca  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
marcelo@Latitude5440:~$ docker container run -it ubuntu-curl /bin/bash
root@17569155e027:/#

$ docker container ls
CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS          PORTS     NAMES
17569155e027   ubuntu-curl   "/bin/bash"   10 seconds ago   Up 10 seconds   80/tcp    sweet_curran

Destaque para a porta exposta:

PORTS
80/tcp

EXPOSE não constrói uma camada no filesystem. Ele é um metadado da imagem:

$ docker image inspect ubuntu-curl
...
            "ExposedPorts": {
                "80/tcp": {}
            },
...

Publish Automático de Portas

$ docker container run -it -P ubuntu-curl /bin/bash
root@9d5a71d68bdb:/#

$ docker container ls
CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS
PORTS                                     NAMES
9d5a71d68bdb   ubuntu-curl   "/bin/bash"   17 seconds ago   Up 16 seconds   0.0.0.0:32768->80/tcp, :::32768->80/tcp   hardcore_jackson