¿Cómo organiza los Dockerfiles que pertenecen a un proyecto cuando tiene un Dockerfile para la base de datos, uno para el servidor de aplicaciones, etc.? ¿Creas algún tipo de jerarquía en la fuente? ¿Un gran proyecto empresarial no puede consistir en un solo Dockerfile?

Nota del autor

Esta respuesta está desactualizada. Fig ya no existe y ha sido reemplazado por Docker compose . Las respuestas aceptadas no se pueden eliminar ...

Docker Compose apoya la construcción de la jerarquía de proyectos. Por lo tanto, ahora es fácil admitir un Dockerfile en cada subdirectorio.

├── docker-compose.yml
├── project1
│   └── Dockerfile
└── project2
    └── Dockerfile

Respuesta original

Acabo de crear un directorio que contiene un Dockerfile para cada componente. Ejemplo:

• Configuración de un entorno Doos / Fig Mesos

Cuando construya los contenedores, simplemente proporcione el nombre del directorio y Docker seleccionará el Dockerfile correcto.

En versiones más recientes (> = 1.8.0) de docker , puede hacer esto

docker build -f Dockerfile.db .
docker build -f Dockerfile.web .

Un gran ahorro.

EDITAR: actualizar versiones por comentario de raksja

EDITAR: comentario de @vsevolod: es posible obtener resaltado de sintaxis en el código VS dando archivos. Extensión de Dockerfile (en lugar de nombre), por ejemplo, Prod.Dockerfile, Test.Dockerfile, etc.

Uso docker-composey múltiples Dockerfileen directorios separados

No cambiar el nombreDockerfile de Dockerfile.dbo Dockerfile.web, puede no ser compatible con su IDE y se perderá el resaltado de sintaxis.

Como dijo Kingsley Uchnor , puede tener múltiples Dockerfile, uno por directorio, que representan algo que desea construir.

Me gusta tener una dockercarpeta que contenga cada aplicación y su configuración. Aquí hay una jerarquía de carpetas de proyecto de ejemplo para una aplicación web que tiene una base de datos.

docker-compose.yml
docker
├── web
│   └── Dockerfile
└── db
    └── Dockerfile

docker-compose.yml ejemplo:

version: '3'
services:
  web:
    # will build ./docker/web/Dockerfile
    build: ./docker/web
    ports:
     - "5000:5000"
    volumes:
     - .:/code
  db:
    # will build ./docker/db/Dockerfile
    build: ./docker/db
    ports:
      - "3306:3306"
  redis:
    # will use docker hub's redis prebuilt image from here:
    # https://hub.docker.com/_/redis/
    image: "redis:alpine"

docker-compose ejemplo de uso de línea de comando:

# The following command will create and start all containers in the background
# using docker-compose.yml from current directory
docker-compose up -d

# get help
docker-compose --help

En caso de que necesite archivos de carpetas anteriores al construir su Dockerfile

Todavía puede usar la solución anterior y colocarla Dockerfileen un directorio como docker/web/Dockerfile, todo lo que necesita es configurar la compilación contextde docker-compose.ymlesta manera:

version: '3'
services:
  web:
    build:
      context: .
      dockerfile: ./docker/web/Dockerfile
    ports:
     - "5000:5000"
    volumes:
     - .:/code

De esta manera, podrás tener cosas como esta:

config-on-root.ini
docker-compose.yml
docker
└── web
    ├── Dockerfile
    └── some-other-config.ini

y una ./docker/web/Dockerfilecomo esta:

FROM alpine:latest

COPY config-on-root.ini /
COPY docker/web/some-other-config.ini /

Aquí hay algunos comandos rápidos de tldr docker-compose . Asegúrese de consultar la documentación oficial para más detalles.

En Intellij, simplemente cambié el nombre de los archivos Docker a * .Dockerfile, y asocié el tipo de archivo * .Dockerfile a la sintaxis de Docker.

Agregue una capa de abstracción, por ejemplo, un archivo YAML como en este proyecto https://github.com/larytet/dockerfile-generator que se parece a

centos7:
    base: centos:centos7
    packager: rpm
    install:
      - $build_essential_centos 
      - rpm-build
    run:
      - $get_release
    env:
      - $environment_vars

Un breve script / make de Python puede generar todos los Dockerfiles desde el archivo de configuración.

Cuando trabaje en un proyecto que requiera el uso de múltiples dockerfiles, simplemente cree cada dockerfile en un directorio separado. Por ejemplo,

app / db /

Cada uno de los directorios anteriores contendrá su dockerfile. Cuando se crea una aplicación, Docker buscará todos los directorios y compilará todos los dockerfiles.