Docker Compose 專案打包部署-有解無憂

Docker Compose

前面我們使用 Docker 的時候，定義 Dockerfile 檔案，然后使用 docker build、docker run 等命令操作容器，然而微服務架構的應用系統一般包含若干個微服務，每個微服務一般都會部署多個實體，如果每個微服務都要手動啟停，那么效率之低，維護量之大可想而知使用 Docker Compose 可以輕松、高效的管理容器，它是一個用于定義和運行多容器 Docker 的應用程式工具
Docker 和 Compose兼容性看下圖：

Docker版本變化說明：

Docker從1.13.x版本開始，版本分為企業版EE和社區版CE，版本號也改為按照時間線來發布，比如17.03就是2017年3月，
Docker的linux發行版的軟體倉庫從以前的https://apt.dockerproject.org和https://yum.dockerproject.org變更為目前的https://download.docker.com, 軟體包名字改為docker-ce和docker-ee，

docker compose是什么：

Compose是一個定義和管理多容器的工具，使用Python語言撰寫，
使用Compose組態檔描述多個容器應用的架構，比如使用什么鏡像、資料卷、網路、映射埠等；
然后一條命令管理所有服務，比如啟動、停止、重啟等，

docker compose作用：　

現在我們要部署django專案，需要 nginx+mysql+redis+nginx等
我們需要開啟四個docker容器進行部署每一個組件，如果每個容器單獨管理太過于復雜，而且可能是給客戶部署專案
docker compose就是一個可以同時管理一個專案中的多個docker容器的工具，一鍵部署啟動

docker compose安裝：

　　方法一：下載并安裝docker compose

[root@linux-node1 ~]# curl -L https://github.com/docker/compose/releases/download/1.15.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

[root@linux-node1 ~]# chmod +x /usr/local/bin/docker-compose
　　　　　　　#或者
pip install docker-compose

　　方法二：直接解壓安裝

unzip docker-compose-linux-x86_64.zip # 解壓后只有一個檔案 docker-compose

chmod +x docker-compose

mv docker-compose /usr/bin/

YAML檔案格式及撰寫注意事項：

注：docker-compose使用yaml檔案對容器進行描述
YAML是一種標記語言很直觀的資料序列化格式，可讀性高，類似于XML資料描述語言，語法比XML簡單的很多，
YAML資料結構通過縮進來表示，連續的專案通過減號來表示，鍵值對用冒號分隔，陣列用中括號括起來，hash用花括號括起來，

YAML檔案格式注意事項：

不支持制表符tab鍵縮進，需要使用空格縮進
通常開頭縮進2個空格
字符后縮進1個空格，如冒號、逗號、橫桿
用井號注釋
如果包含特殊字符用單引號引起來
布林值（true、false、yes、no、on、off）必須用引號括起來，這樣分析器會將他們解釋為字串，

compose配置：

# 欄位                             描述

build   　　　　　　# 指定Dockerfile檔案名構建鏡像背景關系路徑
　　dockerfile
　　context

image 　　　　　　# 指定鏡像 
command 　　　　　# 執行命令，覆寫默認命令
container_name 　# 指定容器名稱，由于容器名稱是唯一的，如果指定自定義名稱，則無法scale
deploy 　　　　　　# 指定部署和運行服務相關配置，只能在Swarm模式使用
environment 　　 # 添加環境變數
networks 　　　 # 加入網路，參考頂級networks下條目
ports 　　　　　# 暴露埠，與-p相同，但埠不能低于60
volumes 　　　　# 掛載宿主機路徑或命名卷，如果是命名卷在頂級volumes定義卷名稱
restart 　　　　# 重啟策略，默認no，always|on-failure|unless-staopped 
hostname 　　　# 容器主機名

常用命令：

# 欄位           描述
build       # 重新構建服務
ps    　　　 # 列出容器
up    　　  # 創建和啟動容器
exec    　　# 在容器里執行命令
scale    　 # 指定一個服務容器啟動數量
top        # 顯示容器行程
logs       # 查看容器輸出
down       # 洗掉容器、網路、資料卷和鏡像
stop       # 停止
start      # 啟動
restart    # 重啟服務

# 文章最后有詳細介紹

使用Docker Compose 一鍵部署LNMP網站平臺

　　參考官方：https://docs.docker.com/compose/compose-file/

　　專案地址：https://gitee.com/edushiyanlou/django-docker

一鍵部署LNMP檔案結構

├── docker-compose.yml           # compose 的yml檔案用于描述要構建的容器
├── mysql 
│   ├── conf
│   │   └── my.cnf               # my.cnf ： mysql主組態檔 
│   └── data                     # data 資料目錄，當構建的時候會將mysql資料持久化到宿主機上
├── nginx
│   ├── Dockerfile               # 構建nginx容器的 Dockerfile 檔案
│   ├── nginx-1.12.1.tar.gz
│   └── nginx.conf               # nginx的主組態檔
├── php
│   ├── Dockerfile               # 構建php容器的 Dockerfile 檔案
│   ├── php-5.6.31.tar.gz
│   └── php.ini                 
└── wwwroot
    └── index.php                # 網站根目錄

docker-compose.yml

version: '3'
services:
  nginx:
    hostname: nginx
    build:
      context: ./nginx
      dockerfile: Dockerfile
    ports:
      - 81:80
    networks:
      - lnmp
    volumes:
      - ./wwwroot:/usr/local/nginx/html

  php:
    hostname: php
    build:
      context: ./php
      dockerfile: Dockerfile
    networks:
      - lnmp
    volumes:
      - ./wwwroot:/usr/local/nginx/html

  mysql:
    hostname: mysql
    image: mysql:5.6
    ports:
      - 3306:3306
    networks:
      - lnmp
    volumes:
      - ./mysql/conf:/etc/mysql/conf.d
      - ./mysql/data:/var/lib/mysql
    command: --character-set-server=utf8
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: wordpress
      MYSQL_USER: user
      MYSQL_PASSWORD: user123

networks:
  lnmp:

mysql/conf/my.conf

[mysqld]
user=mysql
port=3306
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
pid-file=/var/run/mysql/mysql.pid
log_error=/var/log/mysql/error.log
character_set_server = utf8
max_connections=3600

nginx/Dockerfile

FROM centos:7
MAINTAINER www.aliangedu.com
RUN yum install -y gcc gcc-c++ make openssl-devel pcre-devel
ADD nginx-1.12.1.tar.gz /tmp

RUN cd /tmp/nginx-1.12.1 && \
    ./configure --prefix=/usr/local/nginx && \
    make -j 2 && \
    make install

RUN rm -rf /tmp/nginx-1.12.1* && yum clean all

COPY nginx.conf /usr/local/nginx/conf

WORKDIR /usr/local/nginx
EXPOSE 80
CMD ["./sbin/nginx", "-g", "daemon off;"]

nginx/nginx.conf

FROM centos:7
MAINTAINER www.aliangedu.com
RUN yum install -y gcc gcc-c++ make openssl-devel pcre-devel
ADD nginx-1.12.1.tar.gz /tmp

RUN cd /tmp/nginx-1.12.1 && \
    ./configure --prefix=/usr/local/nginx && \
    make -j 2 && \
    make install

RUN rm -rf /tmp/nginx-1.12.1* && yum clean all

COPY nginx.conf /usr/local/nginx/conf

WORKDIR /usr/local/nginx
EXPOSE 80
CMD ["./sbin/nginx", "-g", "daemon off;"]
[root@linux-node2 compose_lnmp]# cat nginx/nginx.conf 
user  root; 
worker_processes  auto; 

error_log  logs/error.log  info;

pid        logs/nginx.pid; 


events {
    use epoll; 
}

http {

    include       mime.types;
    default_type  application/octet-stream;

    log_format  main '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log logs/access.log main;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen 80;
        server_name localhost;
        root html;
        index index.html index.php;

        location ~ \.php$ {
            root html;
            fastcgi_pass php:9000;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; 
            include fastcgi_params;
        }
    }
}

php/Dockerfile

FROM centos:7
MAINTAINER www.aliangedu.com
RUN yum install -y gcc gcc-c++ make gd-devel libxml2-devel libcurl-devel libjpeg-devel libpng-devel openssl-devel
ADD php-5.6.31.tar.gz /tmp/

RUN cd /tmp/php-5.6.31 && \
    ./configure --prefix=/usr/local/php \
    --with-config-file-path=/usr/local/php/etc \
    --with-mysql --with-mysqli \
    --with-openssl --with-zlib --with-curl --with-gd \
    --with-jpeg-dir --with-png-dir --with-iconv \
    --enable-fpm --enable-zip --enable-mbstring && \
    make -j 4 && \
    make install && \
    cp /usr/local/php/etc/php-fpm.conf.default /usr/local/php/etc/php-fpm.conf && \
    sed -i "s/127.0.0.1/0.0.0.0/" /usr/local/php/etc/php-fpm.conf && \
    sed -i "21a \daemonize = no" /usr/local/php/etc/php-fpm.conf
COPY php.ini /usr/local/php/etc

RUN rm -rf /tmp/php-5.6.31* && yum clean all

WORKDIR /usr/local/php
EXPOSE 9000
CMD ["./sbin/php-fpm", "-c", "/usr/local/php/etc/php-fpm.conf"]

wwwroot/index.php

<?php phpinfo();?>

執行一鍵部署命令：　

docker-compose -f docker-compose.yml  up
docker-compose -f docker-compose.yml  up -d       # -d引數讓程式運行在后臺

說明：　　

http://192.168.0.211:81/                  # 運行上面命令即可在頁面打開php頁面

注：如果想要使用其他頁面直接將 wwwroot中的index.php問價進行替換即可

對docker-compose.yml說明

這里定義了部署LNMP環境的三個容器，Nginx、php、mysql
其中nginx和php使用我們自己定義的dockerfile從頭構建，mysql直接使用官方倉庫進行構建

version: '3'           # cocker compose版本號
services:              # 頂級組態檔
  nginx:               # 服務名，可以通過服務名對容器進行管理
    hostname: nginx              # docker容器主機名
    build:                       # 構建nginx 容器
      context: ./nginx           # 指定環境在當前目錄的 nginx檔案夾中
      dockerfile: Dockerfile     # 指定使用nginx檔案夾中的Dockerfile進行構建
    ports:             # 暴露埠
      - 81:80                    # 將宿主機的81埠映射到容器的80埠
    networks:          # 容器使用的網路
      - lnmp
    volumes:           # 指定容器資料卷掛載在宿主機路徑
      - ./wwwroot:/usr/local/nginx/html

  php:
    hostname: php
    build:
      context: ./php
      dockerfile: Dockerfile
    networks:
      - lnmp
    volumes:
      - ./wwwroot:/usr/local/nginx/html

  mysql:
    hostname: mysql
    image: mysql:5.6                 # 直接參考mysql官方鏡像倉庫
    ports:
      - 3306:3306
    networks:
      - lnmp
    volumes:
      - ./mysql/conf:/etc/mysql/conf.d
      - ./mysql/data:/var/lib/mysql
    command: --character-set-server=utf8     # 接收mysql的命令，比如這里設定mysql的字符集
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: wordpress
      MYSQL_USER: user
      MYSQL_PASSWORD: user123

networks:
  lnmp:                             # 創建一個網路

docker、docker-compose、docker swarm和k8s的區別

Docker-Compose

Docker-Compose 是用來管理你的容器的，想象一下當你的Docker中有成百上千的容器需要啟動，如果一個一個的啟動那得多費時間，
有了Docker-Compose你只需要撰寫一個檔案，在這個檔案里面宣告好要啟動的容器，配置一些引數
執行一下這個檔案，Docker就會按照你宣告的配置去把所有的容器啟動起來，只需docker-compose up即可啟動所有的容器
但是Docker-Compose只能管理當前主機上的Docker，也就是說不能去啟動其他主機上的Docker容器

Docker Swarm

Docker Swarm 是一款用來管理多主機上的Docker容器的工具，可以負責幫你啟動容器，監控容器狀態
如果容器的狀態不正常它會幫你重新幫你啟動一個新的容器，來提供服務，同時也提供服務之間的負載均衡

Kubernetes

Kubernetes它本身的角色定位是和Docker Swarm 是一樣的，都是一個跨主機的容器管理平臺
k8s是谷歌公司根據自身的多年的運維經驗研發的一款容器管理平臺,而Docker Swarm則是由Docker 公司研發的，

核心作用：快速迭代、服務自愈

專案環境介紹

docker-compose部署django+nginx+uwsgi+celery+redis+mysql　

專案圖解

專案目錄結構說明

專案地址：https://gitee.com/edushiyanlou/django-docker

django-docker                ## 專案根路徑

│  .gitignore                    # git忽略不上傳的檔案

│  docker-compose.yml            # docker-compose檔案

│  Dockerfile                    # 部署django專案的dockerfile

│  README.md                     # 專案Readme說明

│  requirements.txt              # 專案必須要安裝的檔案

│

├─nginx                      ## nginx容器組態檔

│  │  nginx.conf                 # /etc/nginx/nginx.conf組態檔

│  │

│  └─conf                        # /etc/nginx/conf.d配置nginx檔案夾

│          default.conf

│

└─web                        ## 部署django專案的web容器

    │  manage.py

    │  uwsgi.ini                 # django專案的uwsgi組態檔 

    │

    ├─demoapp

    │  │  admin.py

    │  │  apps.py

    │  │  models.py

    │  │  tasks.py               # 配置celery任務檔案

    │  │  tests.py

    │  │  urls.py

    │  │  views.py

    │  │  __init__.py

    │  │

    │  ├─migrations

    │  │      __init__.py        # 引入celery

    │  │

    │  └─templates

    │      └─demoapp

    │              celery_detail.html          # 查看具體celery執行結果頁面

    │              celery_index.html           # 查看對應celery任務頁面

    │              index.html                  # 專案主頁面

    │

    └─web

            celery.py           # celery組態檔

            settings.py

            urls.py

            wsgi.py

            __init__.py

專案檔案說明

初始化一個django專案

專案檔案

urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('', include('demoapp.urls')),
    path('admin/', admin.site.urls),
]

demoapp/urls.py

from django.urls import path
from . import views

app_name = 'demoapp'

urlpatterns = [
    path('', views.index, name='index'),
    path('celery/', views.celery_index, name='celery_index'),
    path('celery/random_add/', views.random_add, name='celery_random_add'),
    path('celery/random_mul/', views.random_mul, name='celery_random_mul'),
    path('celery/random_xsum/', views.random_xsum, name='celery_random_xsum'),
]

demoapp/views.py

import random
from django.shortcuts import render
from . import tasks


def index(request):
    context = {}
    return render(request, 'demoapp/index.html', context)


def celery_index(request):
    context = {}
    return render(request, 'demoapp/celery_index.html', context)


def random_add(request):
    a, b = random.choices(range(100), k=2)
    tasks.add.delay(a, b)
    context = {'function_detail': 'add({}, {})'.format(a, b)}
    return render(request, 'demoapp/celery_detail.html', context)


def random_mul(request):
    a, b = random.choices(range(100), k=2)
    tasks.mul.delay(a, b)
    context = {'function_detail': 'mul({}, {})'.format(a, b)}
    return render(request, 'demoapp/celery_detail.html', context)


def random_xsum(request):
    array = random.choices(range(100), k=random.randint(1, 10))
    tasks.xsum.delay(array)
    context = {'function_detail': 'xsum({})'.format(array)}
    return render(request, 'demoapp/celery_detail.html', context)

celery組態檔

web/__init__.py

# This will make sure the app is always imported when
# Django starts so that shared_task will use this app.
from .celery import app as celery_app

__all__ = ['celery_app']

web/celery.py

import os
from celery import Celery

# 只要是想在自己的腳本中訪問Django的資料庫等檔案就必須配置Django的環境變數
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'web.settings')

# app名字
app = Celery('web')

# 配置celery
class Config:
    BROKER_URL = 'redis://redis:6379'  # redis://127.0.0.1:6379
    CELERY_RESULT_BACKEND = 'redis://redis:6379'

app.config_from_object(Config)
# 到各個APP里自動發現tasks.py檔案
app.autodiscover_tasks()

demoapp/tasks.py

# Create your tasks here
from celery import shared_task


@shared_task
def add(x, y):
    return x + y


@shared_task
def mul(x, y):
    return x * y


@shared_task
def xsum(numbers):
    return sum(numbers)

nginx容器相關組態檔：

django-docker\nginx\nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

django-docker\nginx\conf\default.conf

server {
    listen                  80;
    server_name             localhost;
    charset                 utf-8;
    client_max_body_size    10M;

    location /static/ {
        alias   /django_static/;
    }

    location / {
        include     uwsgi_params;
        uwsgi_pass  web:8000;
    }
}

web向組態檔：

django-docker\Dockerfile

FROM python:3
ENV PYTHONUNBUFFERED=1
RUN mkdir /code
WORKDIR /code
ADD requirements.txt /code/
RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
# ADD . /code/

django-docker\web\uwsgi.ini

[uwsgi]
socket=:8000
chdir=/code/web
module=web.wsgi:application
pidfile=/tmp/web-master.pid
master=True
vacuum=True
processes=1
max-requests=5000

docker-compose.yml檔案：

docker-compose.yml

version: '3'

services:
  mysql:
    image: mysql:5.7
    volumes:
      - ./mysql:/var/lib/mysql
    expose:
      - "3306"
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=djangodocker
      - MYSQL_USER=django
      - MYSQL_PASSWORD=django

  nginx:
    image: nginx:alpine
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/conf:/etc/nginx/conf.d
      - ./web/staticfiles:/django_static
    ports:
      - "80:80"
    depends_on:
      - web

  redis:
    image: redis:alpine
    expose:
      - "6379"
    restart: always

  web:
    build: .
    # command: python manage.py runserver 0:8000
    # ports:
    #   - "8000:8000"
    command: uwsgi --ini uwsgi.ini
    working_dir: /code/web
    volumes:
      - .:/code
    expose:
      - "8000"
    depends_on:
      - mysql
      - redis

  celery:
    build: .
    command: celery -A web worker -l info
    working_dir: /code/web
    volumes:
      - .:/code
    depends_on:
      - mysql
      - redis

docker-compose.yml詳釋

docker-compose.yml詳解：

version: '3'                       # cocker compose版本號

services:                          # 頂級組態檔

  mysql:                           # 服務名: 容器建通信、管理容器

    image: mysql:5.7               # 引入官方mysql鏡像

    volumes:

      - ./mysql:/var/lib/mysql         # 把當前檔案夾下的 ./mysql檔案夾掛載到docker容器 /var/lib/mysql 路徑下

    expose:

      - "3306"                        # 將當前容器的埠3306埠暴露給link到本容器的容器

    restart: always                   # 宿主機重啟自動拉起這個docker容器

    environment:

      - MYSQL_ROOT_PASSWORD=root             # mysql服務器root密碼root

      - MYSQL_DATABASE=djangodocker          # 創建資料庫 djangodocker

      - MYSQL_USER=django                    # 創建一個用戶 django

      - MYSQL_PASSWORD=django                # 用戶密碼為django

  nginx:

    image: nginx:alpine

    volumes:

      - ./nginx/nginx.conf:/etc/nginx/nginx.conf

      - ./nginx/conf:/etc/nginx/conf.d

      - ./web/staticfiles:/django_static

    ports:

      - "80:80"                             # 系結容器的80埠到主機的80埠

    depends_on:

      - web                                 # 必須先啟動web容器然才能啟動nginx容器

  redis:

    image: redis:alpine

    expose:

      - "6379"

    restart: always


  web:

    build: .

    # command: python manage.py runserver 0:8000

    # ports:

    #   - "8000:8000"

    command: uwsgi --ini uwsgi.ini             # 啟動uwsgi命令

    working_dir: /code/web                     # 專案作業路徑

    volumes:

      - .:/code                                # 將當前檔案夾下所有檔案掛載到容器的 /code 檔案夾

    expose:

      - "8000"

    depends_on:                                # 必須mysql和reids容器啟動后才能啟動web容器

      - mysql

      - redis

  celery:

    build: .

    command: celery -A web worker -l info

    working_dir: /code/web

    volumes:

      - .:/code

    depends_on:

      - mysql

      - redis

相似指令比較

'''1. expose 與 ports 比較'''

# ports: 系結容器的埠到主機的埠，這樣就可以在外網訪問docker容器的服務

# expose: 將當前容器的埠3暴露給link到本容器的容器，expose不會將埠暴露給主機


'''2. depends_on 與 links區別'''

# depends_on: 指定本容器啟動依賴的容器必須先啟動

# links: 保證容器如果ip變化也能訪問(基本已經棄用，因為不使用link仍然可以通過容器名稱訪問)

build 可以指定包含構建背景關系的路徑：

version: '2'
services:
  webapp:
    build: ./dir

Compose常用服務配置參考

Compose檔案是一個定義服務，網路和卷的YAML檔案， Compose檔案的默認檔案名為docker-compose.yml
提示：您可以對此檔案使用.yml或.yaml擴展名，他們都作業，
與docker運行一樣，默認情況下，Dockerfile中指定的選項（例如，CMD，EXPOSE，VOLUME，ENV）都被遵守，你不需要在docker-compose.yml中再次指定它們，
同時你可以使用類似Bash的$ {VARIABLE} 語法在配置值中使用環境變數，有關詳細資訊，請參閱變數替換，
本節包含版本3中服務定義支持的所有配置選項，

build

build 可以指定包含構建背景關系的路徑：

version: '2'
services:
  webapp:
    build: ./dir

或者，作為一個物件，該物件具有背景關系路徑和指定的Dockerfile檔案以及args引數值：

version: '2'
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1

webapp服務將會通過./dir目錄下的Dockerfile-alternate檔案構建容器鏡像，

如果你同時指定image和build，則compose會通過build指定的目錄構建容器鏡像，而構建的鏡像名為image中指定的鏡像名和標簽，

build: ./dir
image: webapp:tag

這將由./dir構建的名為webapp和標記為tag的鏡像，

context

包含Dockerfile檔案的目錄路徑，或者是git倉庫的URL，
當提供的值是相對路徑時，它被解釋為相對于當前compose檔案的位置，該目錄也是發送到Docker守護程式構建鏡像的背景關系，

dockerfile

備用Docker檔案，Compose將使用備用檔案來構建，還必須指定構建路徑，

args

添加構建鏡像的引數，環境變數只能在構建程序中訪問，

首先，在Dockerfile中指定要使用的引數：

ARG buildno
ARG password
RUN echo "Build number: $buildno"
RUN script-requiring-password.sh "$password"

然后在args鍵下指定引數，你可以傳遞映射或串列：

build:
  context: .
  args:
    buildno: 1
    password: secret

build:
  context: .
  args:
    - buildno=1
    - password=secret

注意：YAML布林值（true，false，yes，no，on，off）必須用引號括起來，以便決議器將它們解釋為字串，

image

指定啟動容器的鏡像，可以是鏡像倉庫/標簽或者鏡像id（或者id的前一部分）

image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd

如果鏡像不存在，Compose將嘗試從官方鏡像倉庫將其pull下來，如果你還指定了build，在這種情況下，它將使用指定的build選項構建它，并使用image指定的名字和標記對其進行標記，

container_name

指定一個自定義容器名稱，而不是生成的默認名稱，

container_name: my-web-container

由于Docker容器名稱必須是唯一的，因此如果指定了自定義名稱，則無法將服務擴展到多個容器，

volumes

卷掛載路徑設定，可以設定宿主機路徑（HOST:CONTAINER）或加上訪問模式（HOST:CONTAINER:ro）,掛載資料卷的默認權限是讀寫（rw），可以通過ro指定為只讀，

你可以在主機上掛載相對路徑，該路徑將相對于當前正在使用的Compose組態檔的目錄進行擴展，相對路徑應始終以 . 或者 .. 開始，

volumes:

  # 只需指定一個路徑，讓引擎創建一個卷
  - /var/lib/mysql

  # 指定絕對路徑映射
  - /opt/data:/var/lib/mysql
  
  # 相對于當前compose檔案的相對路徑
  - ./cache:/tmp/cache

  # 用戶家目錄相對路徑
  - ~/configs:/etc/configs/:ro

  # 命名卷
  - datavolume:/var/lib/mysql

但是，如果要跨多個服務并重用掛載卷，請在頂級volumes關鍵字中命名掛在卷，但是并不強制，如下的示例亦有重用掛載卷的功能，但是不提倡，

version: "3" 

services:

  web1:

    build: ./web/

    volumes:

      - ../code:/opt/web/code

  web2:

    build: ./web/

    volumes:

      - ../code:/opt/web/code

注意：通過頂級volumes定義一個掛載卷，并從每個服務的卷串列中參考它，這會替換早期版本的Compose檔案格式中volumes_from，

version: "3"
services:

  db:

    image: db

    volumes:

      - data-volume:/var/lib/db

  backup:

    image: backup-service

    volumes:

      - data-volume:/var/lib/backup/data

volumes:

  data-volume:

command

覆寫容器啟動后默認執行的命令，

command: bundle exec thin -p 3000

該命令也可以是一個類似于dockerfile的串列：

command: ["bundle", "exec", "thin", "-p", "3000"]

links

鏈接到另一個服務中的容器，請指定服務名稱和鏈接別名（SERVICE：ALIAS），或者僅指定服務名稱，

web:
  links:
   - db
   - db:database
   - redis

在當前的web服務的容器中可以通過鏈接的db服務的別名database訪問db容器中的資料庫應用，如果沒有指定別名，則可直接使用服務名訪問，

鏈接不需要啟用服務進行通信 - 默認情況下，任何服務都可以以該服務的名稱到達任何其他服務，（實際是通過設定/etc/hosts的域名決議，從而實作容器間的通信，故可以像在應用中使用localhost一樣使用服務的別名鏈接其他容器的服務，前提是多個服務容器在一個網路中可路由聯通）

links也可以起到和depends_on相似的功能，即定義服務之間的依賴關系，從而確定服務啟動的順序，

external_links

鏈接到docker-compose.yml 外部的容器，甚至并非 Compose 管理的容器，引數格式跟 links 類似，

external_links:
 - redis_1
 - project_db_1:mysql
 - project_db_1:postgresql

expose

暴露埠，但不映射到宿主機，只被連接的服務訪問，
僅可以指定內部埠為引數

expose:
 - "3000"
 - "8000"

ports

暴露埠資訊，
常用的簡單格式：使用宿主：容器（HOST:CONTAINER）格式或者僅僅指定容器的埠（宿主將會隨機選擇埠）都可以，
注意：當使用 HOST:CONTAINER 格式來映射埠時，如果你使用的容器埠小于 60 你可能會得到錯誤得結果，因為 YAML 將會決議 xx:yy 這種數字格式為 60 進制，所以建議采用字串格式，

簡單的短格式：

ports:
 - "3000"
 - "3000-3005"
 - "8000:8000"
 - "9090-9091:8080-8081"
 - "49100:22"
 - "127.0.0.1:8001:8001"
 - "127.0.0.1:5000-5010:5000-5010"
 - "6060:6060/udp"

在v3.2中ports的長格式的語法允許配置不能用短格式表示的附加欄位，

長格式：

ports:
  - target: 80
    published: 8080
    protocol: tcp
    mode: host

target：容器內的埠

published：物理主機的埠

protocol：埠協議（tcp或udp）

mode：host 和ingress 兩總模式，host用于在每個節點上發布主機埠，ingress 用于被負載平衡的swarm模式埠，

restart

no是默認的重啟策略，在任何情況下都不會重啟容器，指定為always時，容器總是重新啟動，如果退出代碼指示出現故障錯誤，則on-failure將重新啟動容器，

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

environment

添加環境變數，你可以使用陣列或字典兩種形式，任何布林值; true，false，yes，no需要用引號括起來，以確保它們不被YML決議器轉換為True或False，
只給定名稱的變數會自動獲取它在 Compose 主機上的值，可以用來防止泄露不必要的資料，

environment:
  RACK_ENV: development
  SHOW: 'true'
  SESSION_SECRET:

environment:
  - RACK_ENV=development
  - SHOW=true
  - SESSION_SECRET

注意：如果你的服務指定了build選項，那么在構建程序中通過environment定義的環境變數將不會起作用，將使用build的args子選項來定義構建時的環境變數，

pid

將PID模式設定為主機PID模式，這就打開了容器與主機作業系統之間的共享PID地址空間，使用此標志啟動的容器將能夠訪問和操作裸機的命名空間中的其他容器，反之亦然，即打開該選項的容器可以相互通過行程 ID 來訪問和操作，

pid: "host"

dns

配置 DNS 服務器，可以是一個值，也可以是一個串列，

dns: 8.8.8.8
dns:
  - 8.8.8.8
  - 9.9.9.9

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/183059.html

標籤：Python

上一篇：請問，如何替換密鑰存盤庫檔案（keystore）中的過期的中間CA證書?

下一篇：python raw_input函式（48）