Comment organisez-vous les Dockerfiles appartenant à un projet lorsque vous avez un Dockerfile pour la base de données, un pour le serveur d'applications, etc.? Créez-vous une sorte de hiérarchie dans la source? Un grand projet d'entreprise ne peut pas se composer d'un seul Dockerfile?

Note de l'auteur

Cette réponse est obsolète. La figure n'existe plus et a été remplacée par Docker compose . Les réponses acceptées ne peuvent pas être supprimées ....

Docker Compose prend en charge la création d'une hiérarchie de projet. Il est donc désormais facile de prendre en charge un Dockerfile dans chaque sous-répertoire.

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

Réponse originale

Je viens de créer un répertoire contenant un Dockerfile pour chaque composant. Exemple:

• Configuration d'un environnement Docker / Fig Mesos

Lors de la construction des conteneurs, donnez simplement le nom du répertoire et Docker sélectionnera le fichier Docker correct.

Dans les versions plus récentes (> = 1.8.0) de docker , vous pouvez le faire

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

Une grosse économie.

EDIT: mise à jour des versions par commentaire de raksja

EDIT: commentaire de @vsevolod: il est possible d'obtenir la coloration syntaxique dans le code VS en donnant des fichiers .Dockerfile extension (au lieu du nom) par exemple Prod.Dockerfile, Test.Dockerfile etc.

Utiliser docker-composeet multiple Dockerfiledans des répertoires séparés

Ne renommez pas votreDockerfile en Dockerfile.dbou Dockerfile.web, il peut ne pas être pris en charge par votre IDE et vous perdrez la coloration syntaxique.

Comme l'a dit Kingsley Uchnor , vous pouvez en avoir plusieurs Dockerfile, un par répertoire, qui représentent quelque chose que vous voulez construire.

J'aime avoir un dockerdossier qui contient chaque application et sa configuration. Voici un exemple de hiérarchie de dossiers de projet pour une application Web qui possède une base de données.

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

docker-compose.yml exemple:

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 exemple d'utilisation de la ligne de commande:

# 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

Si vous avez besoin de fichiers des dossiers précédents lors de la création de votre Dockerfile

Vous pouvez toujours utiliser la solution ci-dessus et placer votre Dockerfiledans un répertoire tel que docker/web/Dockerfile, tout ce dont vous avez besoin est de définir la construction contextdans votre docker-compose.ymlcomme ceci:

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

De cette façon, vous pourrez avoir des choses comme ça:

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

et un ./docker/web/Dockerfilecomme ça:

FROM alpine:latest

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

Voici quelques commandes rapides de tldr docker-compose . Assurez-vous de vous référer à la documentation officielle pour plus de détails.

Dans Intellij, j'ai simplement changé le nom des fichiers Docker en * .Dockerfile, et associé le type de fichier * .Dockerfile à la syntaxe Docker.

Ajoutez une couche d'abstraction, par exemple, un fichier YAML comme dans ce projet https://github.com/larytet/dockerfile-generator qui ressemble à

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

Un court script / make Python peut générer tous les Dockerfiles à partir du fichier de configuration.

Lorsque vous travaillez sur un projet qui nécessite l'utilisation de plusieurs Dockerfiles, créez simplement chaque Dockerfile dans un répertoire séparé. Par exemple,

app / db /

Chacun des répertoires ci-dessus contiendra leur dockerfile. Lorsqu'une application est en cours de construction, docker recherche tous les répertoires et crée tous les fichiers docker.