ฉันได้อ่านและเรียนรู้เกี่ยวกับDockerและพยายามเลือกการตั้งค่า Django ที่จะใช้อย่างถูกต้อง จนถึงตอนนี้ก็มี:

นักแต่งเพลงเขียนหรือDockerfile

ฉันเข้าใจว่าDockerfilesใช้Docker Composeแล้ว แต่ฉันไม่แน่ใจว่าเป็นการดีหรือไม่ที่จะวางทุกอย่างไว้ใน Dockerfile ขนาดใหญ่ที่มีหลายFROMคำสั่งสำหรับรูปภาพที่แตกต่างกัน?

ฉันต้องการใช้ภาพที่แตกต่างกันหลายอย่างซึ่งรวมถึง:

uwsgi
nginx
postgres
redis
rabbitmq
celery with cron

โปรดให้คำแนะนำในสิ่งที่เป็นแนวปฏิบัติที่ดีในการตั้งค่าประเภทของสิ่งแวดล้อมนี้โดยใช้หาง

ถ้ามันจะช่วยให้ผมบน Mac เพื่อใช้boot2docker

ปัญหาบางอย่างที่ฉันมี:

1. ส่วนประกอบของนักเทียบท่าใช้งานไม่ได้กับ Python3
2. ฉันต้องการจัดโครงงานของฉันดังนั้นถ้าหนึ่ง Dockerfile ขนาดใหญ่ไม่เหมาะฉันก็รู้สึกว่าฉันจะต้องเลิกใช้ Docker Compose
3. ฉันโอเคที่จะทำให้โปรเจ็กต์ Py2 & Py3 เข้ากันได้ดังนั้นฉันจึงมุ่งไปที่ django-compose

คำตอบคือไม่ใช่

Docker Compose (ในที่นี้เรียกว่า Compose) จะใช้ Dockerfile หากคุณเพิ่มคำสั่ง build ให้กับโปรเจ็กต์ของdocker-compose.ymlคุณ

เวิร์กโฟลว์นักเทียบท่าของคุณควรสร้างที่เหมาะสมDockerfileสำหรับแต่ละภาพที่คุณต้องการสร้างจากนั้นใช้การเขียนเพื่อรวบรวมภาพโดยใช้buildคำสั่ง

คุณสามารถระบุเส้นทางไปยัง Dockerfiles ส่วนบุคคลของคุณโดยใช้build /path/to/dockerfiles/blahสถานที่ที่/path/to/dockerfiles/blahเป็นที่ที่ blah ของDockerfileชีวิต

Dockerfile

Dockerfile เป็นไฟล์ข้อความธรรมดาที่มีคำสั่งที่ผู้ใช้สามารถเรียกเพื่อรวบรวมภาพ

ตัวอย่าง Dockerfile

FROM ubuntu:latest
MAINTAINER john doe 

RUN apt-get update
RUN apt-get install -y python python-pip wget
RUN pip install Flask

ADD hello.py /home/hello.py

WORKDIR /home

นักแต่งเพลงประกอบ

นักแต่งเพลงประกอบ

• เป็นเครื่องมือสำหรับการกำหนดและเรียกใช้แอปพลิเคชัน Multi-container Docker

• กำหนดบริการที่ประกอบเป็นแอปของคุณdocker-compose.ymlเพื่อให้สามารถทำงานร่วมกันในสภาพแวดล้อมที่แยก

• รับแอปที่ทำงานอยู่ในคำสั่งเดียวโดยใช้งาน docker-compose up

ตัวอย่างเช่น docker-compose.yml

version: "3"
services:
  web:
    build: .
    ports:
    - '5000:5000'
    volumes:
    - .:/code
    - logvolume01:/var/log
    links:
    - redis
  redis:
    image: redis
    volumes:
      logvolume01: {}

เขียนไฟล์อธิบายภาชนะในสภาพการทำงานของมันออกจากรายละเอียดเกี่ยวกับวิธีการสร้างภาชนะเพื่อDockerfiles http://deninet.com/blog/1587/docker-scratch-part-4-compose-and-volumes

เมื่อคุณกำหนดแอปของคุณด้วยการเขียนในการพัฒนาคุณสามารถใช้คำนิยามนี้จะเรียกใช้โปรแกรมประยุกต์ของคุณในสภาพแวดล้อมที่แตกต่างกันเช่น CI, การแสดงละครและการผลิต https://docs.docker.com/compose/production/

นอกจากนี้ดูเหมือนว่า Compose จะถือว่าปลอดภัยสำหรับการผลิตตั้งแต่1.11เนื่องจากhttps://docs.docker.com/v1.11/compose/production/ไม่มีคำเตือนที่จะไม่ใช้ในการผลิตเช่นhttps: // docs อีกต่อไป .docker.com / v1.10 / เขียน / ผลิต /ไม่

มีนักเขียนที่ประกอบไปด้วยเพื่อให้คุณต้องเขียนคำสั่งมากมายที่คุณต้องใช้กับ docker-cli

นักเทียบท่าเขียนยังทำให้ง่ายต่อการเริ่มต้นหลายคอนเทนเนอร์ในเวลาเดียวกันและเชื่อมต่อพวกเขาโดยอัตโนมัติพร้อมกับเครือข่ายบางรูปแบบ

วัตถุประสงค์ของนักแต่งเพลงคือเพื่อทำหน้าที่เป็นนักเทียบท่า cli แต่จะออกคำสั่งหลายคำสั่งให้เร็วขึ้น

ในการใช้ประโยชน์จากนักแต่งเพลงคุณต้องเข้ารหัสคำสั่งที่คุณใช้ก่อนหน้านี้ในdocker-compose.ymlไฟล์

คุณไม่เพียง แต่จะคัดลอกวางลงในไฟล์ yaml มีไวยากรณ์พิเศษ

เมื่อสร้างแล้วคุณจะต้องป้อนไปที่ cli-docker close และมันจะขึ้นอยู่กับ cli เพื่อแยกวิเคราะห์ไฟล์และสร้างคอนเทนเนอร์ต่าง ๆ ทั้งหมดด้วยการกำหนดค่าที่ถูกต้องที่เราระบุ

ดังนั้นคุณจะมีคอนเทนเนอร์แยกต่างหากสมมติว่าตัวอย่างหนึ่งคือredis-serverและที่สองคือnode-appและคุณต้องการที่สร้างขึ้นโดยใช้Dockerfileในไดเรกทอรีปัจจุบันของคุณ

นอกจากนี้หลังจากสร้างคอนเทนเนอร์คุณจะแมปพอร์ตจากคอนเทนเนอร์ไปยังเครื่องโลคัลเพื่อเข้าถึงทุกสิ่งที่ทำงานอยู่ภายใน

ดังนั้นสำหรับdocker-compose.ymlไฟล์ของคุณคุณต้องการเริ่มบรรทัดแรกดังนี้:

version: '3'

นั่นบอกนักเทียบท่าถึงเวอร์ชันที่docker-composeคุณต้องการใช้ หลังจากนั้นคุณต้องเพิ่ม:

version: '3'
services: 
  redis-server: 
    image: 'redis'
  node-app:
    build: .

โปรดสังเกตการเยื้องสำคัญมาก นอกจากนี้แจ้งให้ทราบสำหรับบริการที่ฉันคว้าภาพ แต่สำหรับบริการอื่นฉันกำลังบอกdocker-composeให้ดูในไดเรกทอรีปัจจุบันเพื่อสร้างภาพที่จะใช้สำหรับภาชนะที่สอง

จากนั้นคุณต้องการระบุพอร์ตต่าง ๆ ทั้งหมดที่คุณต้องการเปิดบนคอนเทนเนอร์นี้

version: '3'
services: 
  redis-server: 
    image: 'redis'
  node-app:
    build: .
    ports:
      -

โปรดสังเกตว่าเส้นประเส้นประในไฟล์ yaml เป็นวิธีที่เราระบุอาร์เรย์ ในตัวอย่างนี้ฉันกำลังทำแผนที่8081ในเครื่องท้องถิ่นของฉันไป8081ยังภาชนะที่ชอบ:

version: '3'
services: 
  redis-server: 
    image: 'redis'
  node-app:
    build: .
    ports:
      - "8081:8081"

ดังนั้นพอร์ตแรกคือเครื่องโลคัลของคุณและอีกพอร์ตคือพอร์ตบนคอนเทนเนอร์คุณสามารถแยกแยะความแตกต่างระหว่างสองอย่างเพื่อหลีกเลี่ยงความสับสนดังนี้

version: '3'
services:
  redis-server:
    image: 'redis'
  node-app:
    build: .
    ports:
      - "4001:8081"

โดยการพัฒนาdocker-compose.ymlไฟล์ของคุณเช่นนี้มันจะสร้างคอนเทนเนอร์เหล่านี้บนเครือข่ายเดียวกันและพวกเขาจะสามารถเข้าถึงสื่อสารกับกันและกันได้อย่างอิสระตามที่พวกเขาต้องการและแลกเปลี่ยนข้อมูลได้มากเท่าที่พวกเขาต้องการ

เมื่อสร้างคอนเทนเนอร์สองรายการโดยใช้docker-composeเราไม่ต้องการการประกาศพอร์ตใด ๆ

ในตัวอย่างของฉันเราต้องทำการกำหนดค่าโค้ดบางอย่างในแอป Nodejs ที่มีลักษณะดังนี้:

const express = require('express');
const redis = require('redis');

const app = express();
const client = redis.createClient({
  host: 'redis-server'
});

ฉันใช้ตัวอย่างนี้ด้านบนเพื่อทำให้คุณทราบว่าอาจมีการกำหนดค่าบางอย่างที่คุณต้องทำเพิ่มเติมจากdocker-compose.ymlไฟล์ที่อาจเฉพาะเจาะจงสำหรับโครงการของคุณ

ตอนนี้ถ้าคุณพบว่าตัวเองกำลังทำงานกับแอพ Nodejs และ redis คุณต้องการให้แน่ใจว่าคุณทราบถึงพอร์ตเริ่มต้นที่ Nodejs ใช้ดังนั้นฉันจะเพิ่มสิ่งนี้:

const express = require('express');
const redis = require('redis');

const app = express();
const client = redis.createClient({
  host: 'redis-server',
  port: 6379
});

ดังนั้นนักเทียบท่าจะเห็นว่าแอป Node กำลังค้นหาredis-serverและเปลี่ยนเส้นทางการเชื่อมต่อนั้นไปยังคอนเทนเนอร์ที่ใช้งานอยู่

ตลอดเวลาDockerfileมีเพียงสิ่งนี้:

FROM node:alpine

WORKDIR '/app'

COPY /package.json ./
RUN npm install
COPY . .

CMD ["npm", "start"]

ดังนั้นในขณะที่ก่อนที่คุณจะต้องเรียกใช้docker run myimageเพื่อสร้างอินสแตนซ์ของคอนเทนเนอร์หรือบริการทั้งหมดภายในไฟล์คุณสามารถเรียกใช้แทนได้docker-compose upและคุณไม่จำเป็นต้องระบุรูปภาพเนื่องจาก Docker จะมองหาไดเรกทอรีการทำงานปัจจุบันและมองหาdocker-compose.ymlไฟล์ข้างในนั้น

ก่อนที่docker-compose.ymlเรามีการจัดการกับคำสั่งที่สองที่แยกต่างหากจากdocker build .และdocker run myimageแต่ในโลกถ้าคุณต้องการที่จะสร้างภาพของคุณที่คุณเขียนdocker-compose docker-compose up --buildนั่นบอกให้ Docker เริ่มต้นคอนเทนเนอร์อีกครั้ง แต่สร้างใหม่เพื่อรับการเปลี่ยนแปลงล่าสุด

ดังนั้นdocker-composeทำให้การทำงานกับคอนเทนเนอร์หลาย ๆ ตัวง่ายขึ้น ครั้งต่อไปที่คุณจะต้องเริ่มต้นกลุ่มภาชนะนี้ในพื้นหลังที่คุณสามารถทำได้และจะหยุดพวกเขาที่คุณสามารถทำได้docker-compose up -ddocker-compose down

ในเวิร์กโฟลว์ของฉันฉันเพิ่ม Dockerfile สำหรับแต่ละส่วนของระบบและกำหนดค่าให้แต่ละส่วนสามารถทำงานแยกกันได้ จากนั้นฉันเพิ่มนักเทียบท่า-compose.yml เพื่อนำพวกเขามารวมกันและเชื่อมโยงพวกเขา

ข้อได้เปรียบที่ใหญ่ที่สุด (ในความคิดของฉัน): เมื่อเชื่อมโยงคอนเทนเนอร์คุณสามารถกำหนดชื่อและ ping คอนเทนเนอร์ของคุณด้วยชื่อนี้ ดังนั้นฐานข้อมูลของคุณอาจเข้าถึงได้ด้วยชื่อdbและไม่ใช้ IP อีกต่อไป

"ดีกว่า" เป็นญาติ ทุกอย่างขึ้นอยู่กับความต้องการของคุณ การประกอบ Docker ใช้สำหรับการจัดเตรียมคอนเทนเนอร์หลายตัว หากภาพเหล่านี้มีอยู่แล้วในรีจิสทรีนักเทียบท่าดังนั้นจะเป็นการดีกว่าถ้าจะแสดงรายการเหล่านี้ในไฟล์เขียน หากรูปภาพเหล่านี้หรือรูปภาพอื่น ๆ ต้องสร้างจากไฟล์ในคอมพิวเตอร์ของคุณคุณสามารถอธิบายกระบวนการสร้างภาพเหล่านั้นใน Dockerfile ได้

ฉันเข้าใจว่า Dockerfiles ใช้ใน Docker Compose แต่ฉันไม่แน่ใจว่าเป็นการดีหรือไม่ที่จะวางทุกอย่างไว้ใน Dockerfile ขนาดใหญ่ที่มีคำสั่ง FROM หลายคำสำหรับรูปภาพที่แตกต่างกัน?

การใช้หลาย FROM ใน dockerfile เดียวไม่ใช่ความคิดที่ดีมากเพราะมีข้อเสนอให้ลบคุณสมบัติ 13026

หากเช่นคุณต้องการเชื่อมต่อแอปพลิเคชันที่ใช้ฐานข้อมูลและมีไฟล์แอปพลิเคชันในคอมพิวเตอร์ของคุณคุณสามารถใช้ไฟล์เขียนร่วมกับ dockerfile ดังต่อไปนี้

นักเทียบท่า-compose.yml

mysql:
  image: mysql:5.7
  volumes:
    - ./db-data:/var/lib/mysql
  environment:
    - "MYSQL_ROOT_PASSWORD=secret"
    - "MYSQL_DATABASE=homestead"
    - "MYSQL_USER=homestead"
  ports:
    - "3307:3306"
app:
  build:
    context: ./path/to/Dockerfile
    dockerfile: Dockerfile
  volumes:
    - ./:/app
  working_dir: /app

Dockerfile

FROM php:7.1-fpm 
RUN apt-get update && apt-get install -y libmcrypt-dev \
  mysql-client libmagickwand-dev --no-install-recommends \
  && pecl install imagick \
  && docker-php-ext-enable imagick \
  && docker-php-ext-install pdo_mysql \
  && curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

Dockerfile และ Docker Compose เป็นแนวคิดที่แตกต่างกันสองอย่างใน Dockerland เมื่อเราพูดถึงนักเทียบท่าสิ่งแรกที่นึกถึงคือการประสานการจำลองเสมือนระดับ OS ภาพภาชนะบรรจุ ฯลฯ ฉันจะพยายามอธิบายแต่ละอย่างดังนี้:

อิมเมจ: รูปภาพเป็นไฟล์ที่ไม่เปลี่ยนแปลงและแบ่งใช้ได้ที่เก็บไว้ในรีจิสตรีที่เชื่อถือได้ของนักเทียบท่า รูปภาพ Docker สร้างขึ้นจากชุดของเลเยอร์แบบอ่านอย่างเดียว แต่ละเลเยอร์หมายถึงคำสั่งที่ให้ไว้ใน Dockerfile ของรูปภาพ รูปภาพจัดเก็บไบนารีที่จำเป็นทั้งหมดเพื่อให้ทำงาน

คอนเทนเนอร์: อินสแตนซ์ของภาพที่เรียกว่าตู้คอนเทนเนอร์ คอนเทนเนอร์เป็นเพียงไบนารีอิมเมจที่สามารถเรียกใช้งานได้ซึ่งโฮสต์ของระบบปฏิบัติการจะดำเนินการ รูปภาพที่กำลังเรียกใช้เป็นคอนเทนเนอร์

Dockerfile: Dockerfile เป็นเอกสารข้อความที่มีคำสั่ง / คำสั่งการสร้างทั้งหมดที่ผู้ใช้สามารถโทรบนบรรทัดคำสั่งเพื่อประกอบภาพ Dockerfileนี้จะถูกบันทึกเป็น (หมายเหตุตัวพิมพ์เล็ก 'f')

ประกอบด้วยนักเทียบท่า: เขียนเป็นเครื่องมือสำหรับการกำหนดและเรียกใช้แอปพลิเคชันนักจัดเก็บหลายคอนเทนเนอร์ ด้วยการเรียบเรียงคุณใช้ไฟล์ YAML เพื่อกำหนดค่าบริการของแอปพลิเคชันของคุณ (คอนเทนเนอร์) จากนั้นด้วยคำสั่งเดียวคุณสามารถสร้างและเริ่มบริการทั้งหมดจากการกำหนดค่าของคุณ docker-compose.ymlแฟ้มเขียนจะถูกบันทึกเป็น

ลองนึกภาพคุณเป็นผู้จัดการของ บริษัท ซอฟต์แวร์และคุณเพิ่งซื้อเซิร์ฟเวอร์ใหม่ เพียงแค่ฮาร์ดแวร์

คิดว่าDockerfileเป็นชุดของคำแนะนำคุณจะบอกผู้ดูแลระบบของคุณว่าจะติดตั้งอะไรบนเซิร์ฟเวอร์ใหม่นี้ ตัวอย่างเช่น:

• เราต้องการ Debian linux
• เพิ่มเว็บเซิร์ฟเวอร์ apache
• เราต้องการ postgresql เช่นกัน
• ติดตั้งผู้บัญชาการเที่ยงคืน
• เมื่อเสร็จแล้วให้คัดลอกไฟล์ * .php, * .jpg ฯลฯ ทั้งหมดของโครงการของเราลงใน webroot ของเว็บเซิร์ฟเวอร์ ( /var/www)

ในทางตรงกันข้ามคิดว่าdocker-compose.ymlเป็นชุดคำสั่งที่คุณจะบอกผู้ดูแลระบบของคุณว่าเซิร์ฟเวอร์สามารถโต้ตอบกับส่วนที่เหลือของโลกได้อย่างไร ตัวอย่างเช่น,

• สามารถเข้าถึงโฟลเดอร์แชร์จากคอมพิวเตอร์เครื่องอื่น
• มันพอร์ต 80 เหมือนกันกับพอร์ต 8000 ของโฮสต์คอมพิวเตอร์
• และอื่น ๆ

(นี่ไม่ใช่คำอธิบายที่ชัดเจน แต่ก็ดีพอที่จะเริ่มต้นด้วย)

Dockerfiles มีการสร้างภาพตัวอย่างจากกระดูกเปลือย Ubuntu คุณสามารถเพิ่มmysqlที่เรียกว่าmySQLในภาพหนึ่งในภาพที่สองเรียกว่าmywordpressmywordpress

เขียนไฟล์ YAML เพื่อถ่ายภาพเหล่านี้และเรียกใช้งานร่วมกัน ตัวอย่างเช่นหากคุณมีdocker-compose.ymlบริการโทรในไฟล์ของคุณdb:

services:
   db:
     image: mySQL  --- image that you built.

และบริการที่เรียกว่า worpress เช่น:

wordpress: 
    image: mywordpress

จากนั้นภายในคอนเทนเนอร์ mywordpress คุณสามารถใช้dbเพื่อเชื่อมต่อกับคอนเทนเนอร์ mySQL ของคุณ เวทมนต์นี้เป็นไปได้เพราะโฮสต์นักเทียบท่าของคุณสร้างสะพานเชื่อมต่อเครือข่าย

ในโลก Microservices (มี codebase ที่ใช้ร่วมกันทั่วไป) Microservice แต่ละรายการจะมีDockerfileระดับรูท (โดยทั่วไปอยู่นอก Microservices ทั้งหมดและที่ POM แม่ของคุณอยู่) คุณจะกำหนดdocker-compose.ymlกลุ่ม Microservices ทั้งหมดลงในแอป

ในกรณีของคุณควรใช้ "Docker Compose" เหนือ "Dockerfile" คิดว่า "แอป" คิดว่า "เขียน"

Dockerfile เป็นไฟล์ที่มีคำสั่งข้อความเพื่อประกอบภาพ

การเรียบเรียงโดยนักเทียบท่าใช้เพื่อเรียกใช้สภาพแวดล้อมแบบมัลติคอนเทนเนอร์

ในสถานการณ์เฉพาะของคุณหากคุณมีบริการหลายอย่างสำหรับแต่ละเทคโนโลยีที่คุณกล่าวถึง (บริการ 1 โดยใช้ reddis, บริการ 2 โดยใช้ Rabbit mq ฯลฯ ) จากนั้นคุณสามารถมี Dockerfile สำหรับแต่ละบริการและ docker-compose.yml ทั่วไปเพื่อเรียกใช้ "Dockerfile" ทั้งหมดเป็นคอนเทนเนอร์

ถ้าคุณต้องการทั้งหมดในการบริการเดียวนักเทียบท่าจะเป็นตัวเลือกที่เหมาะสม