Come si organizzano i file Dockerfile appartenenti a un progetto quando si dispone di un file Dockerfile per il database, uno per il server delle applicazioni e così via? Crei una sorta di gerarchia nella fonte? Un progetto di grande impresa non può consistere in un solo Dockerfile?

Nota dell'autore

Questa risposta non è aggiornata. Fig non esiste più ed è stato sostituito da Docker compose . Le risposte accettate non possono essere eliminate ....

Docker Compose supporta la costruzione di gerarchie di progetti. Quindi ora è facile supportare un file Docker in ogni sottodirectory.

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

Risposta originale

Creo solo una directory contenente un file Docker per ciascun componente. Esempio:

• Configurare un ambiente Mesos docker / fig

Quando si creano i contenitori, basta fornire il nome della directory e Docker selezionerà il Dockerfile corretto.

Nelle versioni più recenti (> = 1.8.0) della finestra mobile , è possibile farlo

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

Un grande risparmio.

EDIT: aggiorna le versioni per il commento di raksja

EDIT: commento da @vsevolod: è possibile ottenere l'evidenziazione della sintassi nel codice VS fornendo file. Estensione del file di backup (anziché nome) ad esempio Prod.Dockerfile, Test.Dockerfile ecc.

Utilizzare docker-composee multipli Dockerfilein directory separate

Non rinominare il tuoDockerfile per Dockerfile.dbo Dockerfile.web, potrebbe non essere supportato dalla IDE e si perde l'evidenziazione della sintassi.

Come ha detto Kingsley Uchnor , puoi avere più Dockerfile, uno per directory, che rappresentano qualcosa che vuoi costruire.

Mi piace avere una dockercartella che contiene ogni applicazione e la loro configurazione. Ecco una gerarchia di cartelle di progetti di esempio per un'applicazione Web che ha un database.

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

docker-compose.yml esempio:

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 esempio di utilizzo da riga di 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

Nel caso in cui siano necessari file da cartelle precedenti durante la creazione del Dockerfile

Puoi ancora usare la soluzione sopra e posizionare il tuo Dockerfilein una directory come docker/web/Dockerfile, tutto ciò che serve è impostare la build contextnel tuo in docker-compose.ymlquesto modo:

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

In questo modo, sarai in grado di avere cose come questa:

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

e ./docker/web/Dockerfilecosì:

FROM alpine:latest

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

Ecco alcuni comandi rapidi di tldr docker-compose . Assicurati di fare riferimento alla documentazione ufficiale per maggiori dettagli.

In Intellij, ho semplicemente cambiato il nome dei file docker in * .Dockerfile e associato il tipo di file * .Dockerfile alla sintassi docker.

Aggiungi un livello di astrazione, ad esempio un file YAML come in questo progetto https://github.com/larytet/dockerfile-generator che assomiglia

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

Un breve script / make di Python può generare tutti i Dockerfile dal file di configurazione.

Quando si lavora su un progetto che richiede l'uso di più file docker, è sufficiente creare ciascun file docker in una directory separata. Per esempio,

app / db /

Ognuna delle directory precedenti conterrà il proprio file docker. Quando viene creata un'applicazione, la finestra mobile cercherà tutte le directory e creerà tutti i file docker.