version: "2"
services:
    nginx:
        depends_on:
          - "php"
        image: "nginx:latest"
        volumes:
          - "$PWD/src/docker/conf:/etc/nginx/conf.d"
          - "$PWD:/home/q/system/m_look_360_cn"
        ports:
          - "8082:80"
        container_name: "m.look.360.cn-nginx"
    php:
        image: "lizheming/php-fpm-yaf"
        volumes:
            - "$PWD:/home/q/system/m_look_360_cn"
        container_name: "m.look.360.cn-php"

#例如下面这个 Nginx 配置中的php:9000就是利用了这个原理。
server {
  listen 80;
  server_name dev.m.look.360.cn;
  charset utf-8;
  root /home/q/system/m_look_360_cn/public;
  index index.html index.htm index.php;
  error_page 500 502 503 504 /50x.html;
  location = /50x.html {
    root html;
  }
  # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
  location ~ .php$ {
    ##在每个容器中会将容器的 IP 和服务的名称使用 hosts 的方式绑定
    fastcgi_pass php:9000;
    #fastcgi_pass unix:/tmp/fcgi.sock;
    fastcgi_index index.php;
  }
} 

#pip方式安装
$sudo pip install -U docker-compose
#采用yum方式安装
$yum install -y docker-compose
#二进制包 在 Linux 上的也安装十分简单，从 官方 GitHub Release 处直接下载编译好的二进制文件即可。
$sudo curl -L https://github.com/docker/compose/releases/download/1.17.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
$sudo chmod +x /usr/local/bin/docker-compose

#卸载
sudo rm /usr/local/bin/docker-compose  #如果是二进制包方式安装的，删除二进制文件即可。
sudo pip uninstall docker-compose    #如果是通过 pip 安装的，则执行如下命令即可删除。

#安装成功测试
$docker-compose --version
docker-compose version 1.18.0, build 8dd22a9

$ curl -L https://github.com/docker/compose/releases/download/1.8.0/run.sh > /usr/local/bin/docker-compose
$ chmod +x /usr/local/bin/docker-compose

sudo curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

#其他安装方式
[root@localhost ~]# pip3 -V
pip 9.0.3 from /usr/lib/python3.6/site-packages (python 3.6)
[root@localhost ~]# pip3 install docker-compose
[root@localhost ~]# docker-compose version
docker-compose version 1.25.3, build unknown
docker-py version: 4.1.0
CPython version: 3.6.8
OpenSSL version: OpenSSL 1.1.1c FIPS  28 May 2019

#docker命令的基本的使用格式是
docker-compose [options] [COMMAND] [ARGS...]

#查看帮助
docker-compose [COMMAND] --help 或者 docker-compose help [COMMAND]

build  #构建（重新构建）项目中的服务容器，可以随时在项目目录下运行 docker-compose build 来重新构建服务。
config #验证 Compose 文件格式是否正确，若正确则显示配置，若格式错误显示错误原因。
up / down  #此命令将会启动/停止 up命令所启动的容器(up是非常重要的)，并创建/移除网络
exec  #进入指定的容器。
help
images  #列出 Compose 文件中包含的镜像。
kill  #通过发送 SIGKILL 信号来强制停止服务容器，支持通过 -s 参数来指定发送的信号，例如通过如下指令发送 SIGINT 信号。
logs  #查看服务容器的输出以不同颜色来区分,可以通过 --no-color 来关闭颜色。
port  #打印某个容器端口所映射的公共端口。
ps   #列出项目中目前的所有容器。
pull  #拉取服务依赖的镜像。
push  #推送服务依赖的镜像到 Docker 镜像仓库。
run   #在指定服务上执行一个命令(重点)
scale  #设置指定服务运行的容器个数。
start  #启动已经存在的服务容器。
pause  #暂停一个服务容器。
unpause #恢复处于暂停状态中的服务。
restart #重启项目中的服务。
stop  #停止已经处于运行状态的容器，但不删除它。（可通过start启动）
rm  #删除所有（停止状态的）服务容器,推荐先执行stop
top  #查看各个服务容器内运行的进程。
version

#build格式 docker-compose build [options] [SERVICE...]
选项包括：
  --force-rm 删除构建过程中的临时容器。
  --no-cache 构建镜像过程中不使用 cache（这将加长构建过程）。
  --pull 始终尝试通过 pull 来获取更新版本的镜像。


#run格式为 docker-compose run [options] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]。
选项：
  -d 后台运行容器。
  --name NAME 为容器指定一个名字。
  --entrypoint CMD 覆盖默认的容器启动指令。
  -e KEY=VAL 设置环境变量值，可多次使用选项来设置多个环境变量。
  -u, --user="" 指定运行容器的用户名或者 uid。
  --no-deps 不自动启动关联的服务容器。
  --rm 运行命令后自动删除容器，d 模式下将忽略该选项。
  -p, --publish=[] 映射容器端口到本地主机。
  --service-ports 配置服务端口并映射到本地主机。
  -T 不分配伪 tty，意味着依赖 tty 的指令将无法运行。

例如：
$docker-compose run ubuntu ping docker.com  #将会启动一个 ubuntu 服务容器，并执行 ping docker.com 命令。


#up格式 docker-compose up [options] [SERVICE...]  
#该up十分强大：它将尝试自动完成包括构建镜像build的工作，（重新）创建服务，启动服务run的工作，并关联服务相关容器的一系列操作。
docker-compose up  #前台启动,控制台将会同时打印所有容器的输出信息，可以很方便进行调试。
docker-compose up -d   #后台启动，查看信息需要使用logs命令,般推荐生产环境下使用该选项。
选项：
  -d 在后台运行服务容器。
  --no-color 不使用颜色来区分不同的服务的控制台输出。
  --no-deps 不启动服务所链接的容器。
  --force-recreate 强制重新创建容器，不能与 --no-recreate 同时使用。
  --no-recreate 如果容器已经存在了，则不重新创建，不能与 --force-recreate 同时使用。
  --no-build 不自动构建缺失的服务镜像。
  -t, --timeout TIMEOUT 停止容器时候的超时（默认为 10 秒）。


#rm格式为 docker-compose rm [options] [SERVICE...]。
选项：
  -f, --force 强制直接删除，包括非停止状态的容器。一般尽量不要使用该选项(使用前建议先stop)
  -v 删除容器所挂载的数据卷。


#scale格式为 docker-compose scale [options] [SERVICE=NUM...]
#通过 service=num 的参数来设置数量。例如：
$docker-compose scale web=3 db=2 #将启动 3 个容器运行 web 服务，2 个容器运行 db 服务。

$docker-compose config   #验证Dockerfile脚本-正确返回配置
services:
  redis:
    image: redis:alpine
  web:
    build:
      context: /opt/app
    ports:
    - 80:8080/tcp
version: '3.0'


$docker-compose -p FlaskApp build  #构建容器
Building web
Step 1/5 : FROM python:3.6-alpine

$docker-compose up -d  #后台启动容灾
Creating network "app_default" with the default driver
Building web
Step 1/5 : FROM python:3.6-alpine
 ---> 35bb01a3d284
Step 2/5 : ADD . /code


$docker-compose images   #显示构建运行后的容器
 Container    Repository    Tag       Image Id      Size
----------------------------------------------------------
app_redis_1   redis        alpine   72e76053ebb7   48.5 MB
app_web_1     app_web      latest   e5024b7bdce1   86.1 MB

$docker-compose ps   #项目中目前的容器状态
   Name                  Command               State          Ports
---------------------------------------------------------------------------
app_redis_1   docker-entrypoint.sh redis ...   Up      6379/tcp
app_web_1     python app.py                    Up      0.0.0.0:80->8080/tcp


$docker-compose logs   #后台运行的容器信息
Attaching to app_redis_1, app_web_1
web_1    |  * Debug mode: on
web_1    |  * Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)
web_1    |  * Restarting with stat
web_1    |  * Debugger is active!
web_1    |  * Debugger PIN: 324-716-279


$docker-compose exec web /bin/sh  #进入web服务的容器中(前提是必须运行，退出不影响后台运行的容器)
/code # ls
Dockerfile          app.py              docker-compose.yml
/code # whoami
root
/code # hostname
2e10bc9c7618
/code #

$docker-compose stop    #停止容器
Stopping app_redis_1 ... done
Stopping app_web_1   ... done


$docker-compose rm -v  #删除构建的容器
Going to remove app_redis_1, app_web_1
Are you sure? [yN] y
Removing app_redis_1 ... done
Removing app_web_1   ... done


$docker-compose kill -s SIGINT  #通过发送 SIGKILL 信号来强制停止服务容器。

#docker-composer版本注意冒号后有个空格
version: '3'
services:

#用户自定义服务名称
  web:

    #指定服务的镜像名称或镜像ID(先从本地拉取，如果没有找到则从从Docker Hub获取镜像)
    image: ubuntu/ubuntu:18.04

    #服务除了可以基于指定的镜像，还可以基于一份 Dockerfile,在使用 up 启动之时执行构建任务，这个构建标签就是 build，它可以指定 Dockerfile 所在文件夹的路径
    build：/path/to/build/dir  #方式1：存放dockerfile的可以是绝对路径也可以是相对路径
    #方式2：设定上下文根目录，然后以该目录为准指定 Dockerfile。
    build:  
      context: ../
      dockerfile: path/of/Dockerfile  
      #在 Dockerfile 中设置的选项(例如：CMD, EXPOSE, VOLUME, ENV 等) 将会自动被获取，无需在 docker-compose.yml 中再次设置。
      args:  #使用 arg 指令指定构建镜像时的变量。
        buildno: 1
      cache_from:  #使用 cache_from 指定构建镜像的缓存
        - alpine:latest
        - corp/web_app:3.14

    #自定义容器命名格式是：<项目名称><服务名称><序号>
    container_name: app

    #lables指令 向容器添加元数据，和Dockerfile的LABEL指令一个意思，格式如下：
    labels:
      - "com.example.author=weiyigeek"
      - "com.example.description=Accounting webapp"
      - "com.example.department=Finance"
      - "com.example.lrelease=rc3 for v1.0"

    #一般项目容器启动的顺序是有要求的， depends_on标签解决了容器的依赖、启动先后的问题。、
    #例如下面容器会先启动 redis 和 db 两个服务，最后才启动 web 服务：
    depends_on:  #定义了依赖关系
      - db
      - redis
    redis:
      image: redis
    db:
      image: postgres
    #注意：web 服务不会等待 redis db 「完全启动」之后才启动。

    #配置日志选项。
    logging:
      driver: syslog #目前支持三种日志驱动类型,"none" / "json-file"
      options: #配置日志驱动的相关参数。
        syslog-address: "tcp://192.168.0.42:123"
        max-size: "200k"
        max-file: "10"

    #ports标签指定映射端口,使用HOST:CONTAINER格式或者只是指定容器的端口，宿主机会随机映射端口。
    ports:
      - 8080   #注意格式
      - "49100:22"
      - "127.0.0.1:8001:8001"

    #管理全部服务的标签，比如设置全部服务的user标签值为USER，默认属性（用户、角色、类型、级别等）
    security_opt:
      - label:user:USER
      - label:role:ROLE

    #设置另一个信号来停止容器，默认情况下是使用SIGTERM停止容器
    stop_signal: SIGUSR1

    #配置容器连接的网络
    networks:
      - front-tier
      - back-tier
    
    #设置网络模式使用和 docker run 的 --network 参数一样的值(在集群模式下无法使用)。
    network_mode: "bridge" # "host"  "none" "service:[service name]" "container:[container name/id]"

    #和 --dns 参数一样用途，格式如下：
    dns: 
      - 8.8.8.8
      - 9.9.9.9
    #此外 dns_search 的配置也类似
    dns_search:
      - dc1.example.com
      - dc2.example.com


  redis:
    image: redis

    #tmpfs标签 挂载临时目录到容器内部(挂载一个 tmpfs 文件系统到容器),与 run 的参数一样效果：
    tmpfs: /run  #两种形式 单个和多个
    tmpfs:
      - /run
      - /tmp

    #env_file 标签指定.env 文件来存放设置的 Compose 的变量
    #如果通过 docker-compose -f FILE 指定了配置文件，则 env_file 中路径会使用配置文件路径。
    env_file:
      - ./common.env
      - ./apps/web.env
      - /opt/secrets.env


    #environment标签设置镜像变量，而且它可以保存变量到镜像/容器里面(类似 docker run -e 的效果)
    #如果有变量名称与 environment 指令冲突，则按照惯例，以后者为准。
    environment:
      - RACK_ENV=development
      - SHOW=true
      - SESSION_SECRET
      - MYSQL_ROOT_PASSWORD_FILE: /run/secrets/db_root_password

    #存储敏感数据，例如 mysql 服务密码，需要后面的配置
    secrets:
      - db_root_password
      - my_other_secret

    #与Dockerfile中的EXPOSE指令一样，用于指定暴露的端口（只是作为参考实际上常用ports指令）
    expose:
      - "6379"
 
    #links标签解决的是容器连接问题，与Docker client的--link一样效果，会连接到其它服务中的容器。
    #使用的别名将会自动在服务容器中的/etc/hosts里创建
    links:
      - web

    #使用 command 可以覆盖容器启动后默认执行的命令。
    command: bundle exec thin -p 3000
    #command: [bundle, exec, thin, -p, 3000]  #写成类似 Dockerfile 中的格式

    #使用entrypoint标签 可以定义接入点
    entrypoint: /code/entrypoint.sh
    entrypoint:
      - php
      - -d
      - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
      - -d
      - memory_limit=-1
      - vendor/bin/phpunit

  lb:
    image: dockercloud/haproxy
    ports:
      - 80:80

    #extra_hosts 添加主机名的标签，就是往/etc/hosts文件中添加下面的一些记录，与Docker client的--add-host类似：
    extra_hosts:
      - "somehost:162.242.195.82"
      - "otherhost:50.31.209.229"
    
    #让Compose项目里面的容器连接到那些项目配置外部的容器（前提是外部容器中必须至少有一个容器是连接到与项目内的服务的同一个网络里面）。
    #链接到 docker-compose.yml 外部的容器，甚至并非 Compose 管理的外部容器。
    external_links:
      - redis_1
      - project_db_1:mysql
      - project_db_1:postgresql

    links:
      - web

    #指定父 cgroup 组，意味着将继承该组的资源限制。
    cgroup_parent: cgroups_1  #指定父 cgroup 组，意味着将继承该组的资源限制
    network_mode: "host"  # 使用主机网络模式
    #加入指定网络,相同的服务可以在不同的网络有不同的别名。
    networks:
      - front-tier
      - back-tier

    #挂载一个目录或者一个已存在的数据卷容器格式[HOSTPATH:CONTAINERPATH:ro]  #定路径可以是相对路径，使用 . 或者 .. 来指定相对目录。
    #可以宿主机的 $PWD 常量
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock    #使用绝对路径挂载数据卷
      - ~/configs:/etc/configs/:ro  # 使用用户的相对路径（~/ 表示的目录是 /home/<用户目录>/ 或者 /root/）。
      - datavolume:/var/lib/mysql     # 已经存在的命名的数据卷。
      - './nginx/log:/var/log/nginx:rw' # 目录映射权限设置，例如此处的 :ro 是只读不能写

    #从其它容器或者服务挂载数据卷可选的参数是 :ro或者 :rw(默认)
    volumes_from:
      - service_name
      - service_name:ro
      - container:container_name
      - container:container_name:rw

    #添加或删除容器的内核功能
    cap_add:  #指定容器的内核能力（capacity）分配。
      - ALL
    cap_drop:  #去掉 NET_ADMIN 能力可以指定为：
      - NET_ADMIN
      - SYS_ADMIN

    #设备映射列表
    devices:
      - "/dev/ttyUSB0:/dev/ttyUSB0"

    #通过命令检查容器是否健康运行
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 1m30s
      timeout: 10s
      retries: 3

    #跟主机系统共享进程命名空间。
    #打开该选项的容器之间，以及容器和宿主机系统之间可以通过进程 ID 来相互访问和操作。
    pid: "host"

    #配置容器内核参数
    sysctls:
      - net.core.somaxconn=32768
      - net.ipv4.tcp_syncookies=0
      - net.ipv4.ip_forward=1

    #指定容器的 ulimits 限制值
    #例如，指定最大进程数为 65535，指定文件句柄数为 20000（软限制，应用可以随时修改，不能超过硬限制） 和 40000（系统硬限制，只能 root 用户提高）。
    ulimits:
      nproc: 65535
      nofile:
        soft: 20000
        hard: 40000

# 在 volumes 中绑定本地目录等同于`docker volume create --driver local --name esdata1`
volumes:
  esdata1:
    driver: local
  datavolume:
    driver: local
    driver_opts:
      type: none
      device: $PWD/logs
      o: bind

networks:
  front-tier:
    driver: bridge
  back-tier:
    driver: bridge
      aliases:  # 子标签aliases，这是一个用来设置服务别名的标签
        - alias1
# 加入已存在的网络(docker network ls)
networks:
  mongocluster_default:
    external: true

#放在最后
secrets:
  my_secret:
    file: ./my_secret.txt
  my_other_secret:
    external: true

# common.env: Set development environment
PROG_ENV=development
MONGO_VERSION=3.6

#例如，下面的 Compose 文件将从运行它的环境中读取变量 ${MONGO_VERSION} 的值，并写入执行的指令中。
version: "3"
services:

db:
  image: "mongo:${MONGO_VERSION}"

#项目结构
├── app.py
├── docker-compose.yml
└── Dockerfile

###############app.py###############
#!/usr/bin/env python
#每次刷新页面，计数就会加 1。
from flask import Flask
from redis import Redis

app = Flask(__name__)
redis = Redis(host='redis', port=6379)

@app.route('/')
def hello():
    count = redis.incr('hits')
    return 'Hello World! 该页面已被访问 {} 次。\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0",port=8080,debug=True)


########## Docker-compose.yml ##########    
version: '3'
services:
  web:
    #存放了dockerfile目录
    build: .
    ports:
     - "80:8080"
  #会进行自连接与网络通信关联-docker-compose的一大特色
  redis:
    image: "redis:alpine"


########## Dockerfile ##########  
FROM python:3.6-alpine
ADD . /code
WORKDIR /code
RUN pip install redis flask
RUN chown -R $USER:$USER .
CMD ["python", "app.py"]

#宿主机直接git clone我的blog项目
git clone https://github.com/WeiyiGeek/blog.git

#建立入口执行shell文件
$nano init.sh
#!/bin/bash
npm config set unsafe-perm true
npm config set registry https://registry.npm.taobao.org
npm install -g hexo-cli --save
npm install --save
hexo server

#建立docker-compose.yml文件、
version: "3.0"
services:
  blog:
    image: "mhart/alpine-node:latest"
    container_name: blog
    labels:
      - "com.example.author=weiyigeek"
      - "com.example.description=my blog"
      - "com.example.department=IT"
      - "com.example.lrelease=v1.0"
    ports: 
      - "80:4000"
    volumes:
      - "$PWD:/opt/blog/"
    working_dir: /opt/blog/
    entrypoint: /opt/blog/init.sh   #设置的环境变量也由此初始化到脚本之中

build: ./dir
image: webapp:tag

#Dockerfile 中的 ARG 指令它可以在构建过程中指定环境变量，但是在构建成功后取消，在 docker-compose.yml 文件中也支持这样的写法：
build:
  context: .
  #与 ENV 不同的是，ARG 是允许空值的。例如：
  args:
    - buildno=1
    - password=secret
    - version

configs #仅用于 Swarm mode
deploy #仅用于 Swarm mode
cpu_shares: 73
cpu_quota: 50000
cpuset: 0,1

#指定容器中运行应用的用户名
user: postgresql

#指定容器中工作目录
working_dir: /code

#指定容器中搜索域名、主机名、mac 地址等。
domainname: foo.com
hostname: foo
ipc: host
mac_address: 02:42:ac:11:65:43

#允许容器中运行一些特权命令。
privileged: true


#指定容器退出后的重启策略为始终重启。该命令对保持服务始终运行十分有效，在生产环境中推荐配置为 always 或者 unless-stopped。
restart: always

#以只读模式挂载容器的 root 文件系统，意味着不能对容器内容进行修改。
read_only: true


shm_size: 64M
#打开标准输入，可以接受外部输入。
stdin_open: true
#模拟一个伪终端。
tty: true

mem_limit: 1000000000
memswap_limit: 2000000000

version: '3.1'
services:
  db8:
    image: mysql
    container_name: mysql8.x
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: www.weiyigeek.top
      MYSQL_DATABASE: test
      MYSQL_USER: test8
      MYSQL_PASSWORD: weiyigeek.top
    volumes:
      - "/app/mysql8:/var/lib/mysql"
    ports:
      - 3306:3306
    networks:
      - database-net
  db5:
    image: mysql:5.7.29
    container_name: mysql5.x
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: www.weiyigeek.top
      MYSQL_DATABASE: test
      MYSQL_USER: test5
      MYSQL_PASSWORD: weiyigeek.top
    volumes:
      - "/app/mysql5:/var/lib/mysql"
    ports:
      - 3305:3306
    networks:
      - database-net
  redis:
    image: redis
    container_name: redis
    restart: always
    command: redis-server --requirepass weiyigeek.top
    volumes:
      - "/app/redis:/data"
    ports:
      - 6379:6379
  adminer:
    image: adminer
    container_name: MySQLManager
    restart: always
    ports:
      - 8888:8080
    networks:
      - database-net
    links:
      - db8:mysql8.x
      - db5:mysql5.7
    depends_on:
      - db8
      - db5

#新建（注意不在services中）它会自动创建以当前目录+database-net名称的docker网络名称。
# networks:
#   database-net:
#     driver: bridge

# 指定已存在的网络(推荐使用前必须进行创建否则报错)
# docker network create -d bridge mysql_database-net
networks:
  mysql_database-net:
    external: true

demo1:  
  image: weiyigeek/nginx:latest
  volumes:
    - ./ghost/config.js:/var/lib/ghost/config.js

services:
 mysql:  
  image: mysql
  container_name: mysql
  volumes:
    - mysql:/var/lib/mysql
...
volumes:
 mysql: {} 

# 1) 查看所有卷标
docker volume ls 

# 2) 查看批量的卷标
$ docker volume ls | grep mysql
local               vagrant_mysql


# 3) 查看具体的volume对应的真实地址
$ docker volume inspect vagrant_mysql
[
  {
    "Name": "vagrant_mysql",
    "Driver": "local",
    "Mountpoint": "/var/lib/docker/volumes/vagrant_mysql/_data"
  }
]