Usando o Dockerfile para expor as portas
Neste artigo, mostrarei a você como expor portas usando Dockerfile com um exemplo do mundo real. Vamos começar.
Criando um diretório de projeto:
Primeiro, temos que criar um diretório de projeto. Neste diretório, você deve manter todos os arquivos do projeto e um Dockerfile.
Execute o seguinte comando para criar um diretório de projeto myApp/ no diretório inicial de seus usuários e navegue até ele:
$ mkdir ~/myApp && CD ~/myApp
Preparando o aplicativo da web:
Agora crie um diretório src/ dentro de ~/myApp/ Diretório com o seguinte comando:
$ mkdir src
No src/ Diretório, todo o código -fonte do meu aplicativo NodeJS será mantido.
Vou apenas criar um simples aplicativo.JS arquivo no src/ diretório e execute um servidor web simples na porta 8080 Apenas para demonstração.
O src/app.JS O arquivo contém as seguintes linhas de códigos:
Escrevendo Dockerfile e expondo portas:
Agora crie um Dockerfile no ~/myApp Diretório com o seguinte comando:
$ touch dockerfile
Agora digite as seguintes linhas para o Dockerfile e salve. Vou discutir o que essas linhas significam mais tarde.
Aqui, De Alpine: 3.8 significa usar o Alpine: 3.8 Imagem do docker como a base da nova imagem que estaremos construindo a partir disso Dockerfile.
Execute a atualização APK significa que execute o Atualização APK comando na imagem do docker base Alpine: 3.8.
Execute APK Add -No -Cache NodeJS significa que execute o APK Add comando para instalar a linguagem de programação do NodeJS no Alpine: 3.8 Imagem base do docker.
CÓPIA DE ./src /aplicativo significa copiar todos os arquivos do ~/myApp/src diretório para o /aplicativo diretório da nova imagem do Docker que iremos construir usando o Dockerfile.
CMD [“/usr/bin/node”, “/app/app.JS ”] significa que execute o /aplicativo/aplicativo.JS arquivo do novo contêiner usando nó binário localizado em /usr/bin/nó.
Finalmente, para Exponha 8080/TCP significa, expor ou abrir a porta TCP 8080 para o computador host.
Criando imagem de docker personalizada usando o Dockerfile:
Agora vamos fazer uma imagem personalizada do Docker Nó alpino: v1 usando o Dockerfile que acabamos de criar.
Primeiro, verifique se você está no ~/myApp/ diretório e execute o seguinte comando para criar sua imagem personalizada do Docker Nó alpino: v1:
$ docker build -t alpine -node: v1 .
Como você pode ver, a imagem personalizada do Docker Nó alpino: v1 está sendo criado. A imagem e os pacotes do Docker de base necessários estão sendo retirados da Internet.
Como você pode ver, a imagem personalizada do Docker Nó alpino: v1 é criado com sucesso.
Testando a imagem personalizada do Docker:
Agora podemos testar a imagem do Docker personalizada Nó alpino: v1 muito facilmente. Tudo o que precisamos fazer é criar um contêiner fora de Nó alpino: v1 imagem.
Execute o seguinte comando para criar um contêiner do Docker www de Nó alpino: v1 Imagem do Docker:
$ docker run -d -it - -name www alpine -node: v1
O contêiner www é criado.
Agora vamos descobrir o endereço IP do www Docker Container com o seguinte comando:
$ Docker Inspecione www | Endereço Grep
Como você pode ver, no meu caso, o endereço IP é 172.17.0.3. Portanto, o aplicativo NodeJS que escrevi deve estar acessível no navegador da web na porta 8080 deste endereço IP.
Pronto! Eu posso acessar a porta 8080 do meu www Docker Container.
É basicamente assim que você expõe certas portas em suas imagens personalizadas do Docker que você estará construindo usando Dockerfile.
Expondo portas TCP e UDP usando o Dockerfile:
Na seção anterior deste artigo, mostrei como expor uma porta TCP usando um Dockerfile.
Você pode expor facilmente uma porta TCP (digamos a porta TCP 53) na tua Dockerfile Com a seguinte linha:
Exponha 53/TCP
Você também pode expor uma porta UDP (digamos a porta UDP 53) com a seguinte linha em seu Dockerfile:
Exponha 53/UDP
Você pode expor a porta TCP e UDP ao mesmo tempo com as seguintes linhas em seu Dockerfile:
Exponha 53/TCP
Exponha 53/UDP
Se você não especificar qual protocolo (TCP ou UDP) usar, o TCP será usado por padrão. Por exemplo, se você escrever a seguinte linha em seu Dockerfile:
Expor 53
Em seguida, o Docker assumirá que você deseja usar a porta TCP 53.
Expondo várias portas usando o Dockerfile:
Digamos que você queira criar uma imagem de pilha média personalizada. Nesse caso, você estará executando um servidor HTTP em alguma porta (digamos a porta TCP 80 ou 8080), um servidor FTP que é executado na porta TCP 21, um servidor de banco de dados SQL (digamos MySQL) que é executado na porta TCP 3306, Ou o NOSQL Database Server (digamos MongoDB), que é executado na porta TCP 27017 ou 27018, um servidor SSH que é executado na porta TCP 22. Isso é muitas portas!
A boa notícia é; Você pode expor quantas portas necessárias em sua imagem personalizada do Docker criada usando Dockerfile.
As portas no exemplo acima podem ser expostas com as seguintes linhas em seu Dockerfile:
Exponha 80/TCP
Exponha 8080/TCP
Expor 21/tcp
Exponha 22/TCP
Exponha 3306/TCP
Expor 27017/tcp
Expor 27018/tcp
Se você quiser, você pode deixar a especificação do protocolo, pois o Docker usa o TCP por padrão e fazer a mesma coisa com as seguintes linhas em seu Dockerfile:
Expor 80
Exponha 8080
Expor 21
Expor 22
Exponha 3306
Exponha 27017
Exponha 27018
Se precisar, você pode misturar portas TCP e UDP em seu Dockerfile. Por exemplo, se você executar o servidor DNS (que é executado na porta UDP 53), junto com o exemplo acima, você adicionaria as seguintes linhas ao seu Dockerfile.
Expor 80
Exponha 8080
Expor 21
Expor 22
Exponha 53/UDP
Exponha 3306
Exponha 27017
Exponha 27018
Então é assim que você expõe as portas usando Dockerfile. Para aprender mais sobre Dockerfile e expondo portas usando Dockerfile, Leia o Dockerfile Guia de referência em https: // docs.Docker.com/mecanismo/referência/construtor/#exponha
Obrigado por ler este artigo.