Docker 使用

Docker核心解决的问题是利用LXC来实现类似VM的功能，从而利用更加节省的硬件资源提供给用户更多的计算资源。同VM的方式不同, LXC 其并不是一套硬件虚拟化方法 - 无法归属到全虚拟化、部分虚拟化和半虚拟化中的任意一个，而是一个操作系统级虚拟化方法, 理解起来可能并不像VM那样直观。所以我们从虚拟化到docker要解决的问题出发，看看他是怎么满足用户虚拟化需求的。 用户需要考虑虚拟化方法，尤其是硬件虚拟化方法，需要借助其解决的主要是以下4个问题: 隔离性 - 每个用户实例之间相互隔离, 互不影响。 硬件虚拟化方法给出的方法是VM, LXC给出的方法是container，更细一点是kernel namespace 可配额/可度量 - 每个用户实例可以按需提供其计算资源，所使用的资源可以被计量。硬件虚拟化方法因为虚拟了CPU, memory可以方便实现, LXC则主要是利用cgroups来控制资源 移动性 - 用户的实例可以很方便地复制、移动和重建。硬件虚拟化方法提供snapshot和image来实现，docker(主要)利用AUFS实现 安全性 - 这个话题比较大，这里强调是host主机的角度尽量保护container。硬件虚拟化的方法因为虚拟化的水平比较高，用户进程都是在KVM等虚拟机容器中翻译运行的, 然而对于LXC, 用户的进程是lxc-start进程的子进程, 只是在Kernel的namespace中隔离的, 因此需要一些kernel的patch来保证用户的运行环境不会受到来自host主机的恶意入侵, dotcloud(主要是)利用kernel grsec patch解决的.

• YAML 入门教程
• Docker Compose
• Dockerfile 配置模板
• [shell] docker deploy service script 部署脚本模板
• [shell] Docker 部署脚本模板2
• 修改 docker 日志大小配置
• 如何科学的在Docker Container中运行多个服务

YAML 入门教程

YAML 是 "YAML Ain't a Markup Language"（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）。

YAML 的语法和其他高级语言类似，并且可以简单表达清单、散列表，标量等数据形态。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）。

YAML 的配置文件后缀为 .yml，如：wzhz.xyz.yml 。

基本语法

• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格
• 缩进的空格数不重要，只要相同层级的元素左对齐即可
• '#'表示注释

数据类型

YAML 支持以下几种数据类型：

• 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
• 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
• 纯量（scalars）：单个的、不可再分的值

YAML 对象

对象键值对使用冒号结构表示 *key: value，冒号后面要加一个空格。

也可以使用 key:{key1: value1, key2: value2, ...}。

还可以使用缩进表示层级关系；

key: 
    child-key: value
    child-key2: value2

较为复杂的对象格式，可以使用问号加一个空格代表一个复杂的 key，配合一个冒号加一个空格代表一个 value：

?  
    - complexkey1
    - complexkey2
:
    - complexvalue1
    - complexvalue2

意思即对象的属性是一个数组 [complexkey1,complexkey2]，对应的值也是一个数组 [complexvalue1,complexvalue2]

YAML 数组

以 - 开头的行表示构成一个数组：

- A
- B
- C

YAML 支持多维数组，可以使用行内表示：

key: [value1, value2, ...]

数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。

-
 - A
 - B
 - C

一个相对复杂的例子：

companies:
    -
        id: 1
        name: company1
        price: 200W
    -
        id: 2
        name: company2
        price: 500W

意思是 companies 属性是一个数组，每一个数组元素又是由 id、name、price 三个属性构成。

数组也可以使用流式(flow)的方式表示：

companies: [{id: 1,name: company1,price: 200W},{id: 2,name: company2,price: 500W}]

复合结构

数组和对象可以构成复合结构，例：

languages:
  - Ruby
  - Perl
  - Python 
websites:
  YAML: yaml.org 
  Ruby: ruby-lang.org 
  Python: python.org 
  Perl: use.perl.org

转换为 json 为：

{ 
  languages: [ 'Ruby', 'Perl', 'Python'],
  websites: {
    YAML: 'yaml.org',
    Ruby: 'ruby-lang.org',
    Python: 'python.org',
    Perl: 'use.perl.org' 
  } 
}

纯量

纯量是最基本的，不可再分的值，包括：

• 字符串
• 布尔值
• 整数
• 浮点数
• Null
• 时间
• 日期

使用一个例子来快速了解纯量的基本使用：

boolean: 
    - TRUE  #true,True都可以
    - FALSE  #false，False都可以
float:
    - 3.14
    - 6.8523015e+5  #可以使用科学计数法
int:
    - 123
    - 0b1010_0111_0100_1010_1110    #二进制表示
null:
    nodeName: 'node'
    parent: ~  #使用~表示null
string:
    - 哈哈
    - 'Hello world'  #可以使用双引号或者单引号包裹特殊字符
    - newline
      newline2    #字符串可以拆成多行，每一行会被转化成一个空格
date:
    - 2018-02-17    #日期必须使用ISO 8601格式，即yyyy-MM-dd
datetime: 
    -  2018-02-17T15:02:31+08:00    #时间使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区

引用

& 锚点和 * 别名，可以用来引用:

defaults: &defaults
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *defaults

test:
  database: myapp_test
  <<: *defaults

相当于:

defaults:
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  adapter:  postgres
  host:     localhost

test:
  database: myapp_test
  adapter:  postgres
  host:     localhost

& 用来建立锚点（defaults），<< 表示合并到当前数据，* 用来引用锚点。

下面是另一个例子:

- &showell Steve
- Clark
- Brian
- Oren
- *showell

转为 JavaScript 代码如下:

[ 'Steve', 'Clark', 'Brian', 'Oren', 'Steve' ]

参考地址：

YAML 语言教程

YAML快速入门

yaml教程

Docker Compose

Compose 简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

如果你还不了解 YML 文件配置，可以先阅读 YAML 入门教程。

Compose 使用的三个步骤：

• 使用 Dockerfile 定义应用程序的环境。

• 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。

• 最后，执行 docker-compose up 命令来启动并运行整个应用程序。

docker-compose.yml 的配置案例如下（配置参数参考下文）：

# yaml 配置实例
version: '3'
services:
  web:
    build: .
    ports:
   - "5000:5000"
    volumes:
   - .:/code
    - logvolume01:/var/log
    links:
   - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

Compose 安装

Linux

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：compose-releases。

运行以下命令以下载 Docker Compose 的当前稳定版本：

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

要安装其他版本的 Compose，请替换 1.24.1。

将可执行权限应用于二进制文件：

$ sudo chmod +x /usr/local/bin/docker-compose

创建软链：

$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

测试是否安装成功：

$ docker-compose --version
cker-compose version 1.24.1, build 4667896b

注意： 对于 alpine，需要以下依赖包： py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

macOS

Mac 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Mac 用户不需要单独安装 Compose。Docker 安装说明可以参阅 MacOS Docker 安装。

windows PC

Windows 的 Docker 桌面版和 Docker Toolbox 已经包括 Compose 和其他 Docker 应用程序，因此 Windows 用户不需要单独安装 Compose。Docker 安装说明可以参阅 Windows Docker 安装。

使用

1、准备

创建一个测试目录：

$ mkdir composetest
$ cd composetest

在测试目录中创建一个名为 app.py 的文件，并复制粘贴以下内容：

composetest/app.py 文件代码

import time

import redis
from flask import Flask

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


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

在此示例中，redis 是应用程序网络上的 redis 容器的主机名，该主机使用的端口为 6379。

在 composetest 目录中创建另一个名为 requirements.txt 的文件，内容如下：

flask
redis

2、创建 Dockerfile 文件

在 composetest 目录中，创建一个名为的文件 Dockerfile，内容如下：

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]

Dockerfile 内容解释：

• FROM python:3.7-alpine: 从 Python 3.7 映像开始构建镜像。
• WORKDIR /code: 将工作目录设置为 /code。

• ENV FLASK_APP app.py
  ENV FLASK_RUN_HOST 0.0.0.0
  

  设置 flask 命令使用的环境变量。
• RUN apk add --no-cache gcc musl-dev linux-headers: 安装 gcc，以便诸如 MarkupSafe 和 SQLAlchemy 之类的 Python 包可以编译加速。

• COPY requirements.txt requirements.txt
  RUN pip install -r requirements.txt
  

  复制 requirements.txt 并安装 Python 依赖项。
• COPY . .: 将 . 项目中的当前目录复制到 . 镜像中的工作目录。
• CMD ["flask", "run"]: 容器提供默认的执行命令为：flask run。

3、创建 docker-compose.yml

在测试目录中创建一个名为 docker-compose.yml 的文件，然后粘贴以下内容：

docker-compose.yml 配置文件

# yaml 配置
version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

该 Compose 文件定义了两个服务：web 和 redis。

• web：该 web 服务使用从 Dockerfile 当前目录中构建的镜像。然后，它将容器和主机绑定到暴露的端口 5000。此示例服务使用 Flask Web 服务器的默认端口 5000 。
• redis：该 redis 服务使用 Docker Hub 的公共 Redis 映像。

4、使用 Compose 命令构建和运行您的应用

在测试目录中，执行以下命令来启动应用程序：

docker-compose up

如果你想在后台执行该服务可以加上 -d 参数：

docker-compose up -d

yml 配置指令参考

version

指定本 yml 依从的 compose 哪个版本制定的。

build

指定为构建镜像上下文路径：

例如 webapp 服务，指定为从上下文路径 ./dir/Dockerfile 所构建的镜像：

version: "3.7"
services:
  webapp:
    build: ./dir

或者，作为具有在上下文指定的路径的对象，以及可选的 Dockerfile 和 args：

version: "3.7"
services:
  webapp:
    build:
      context: ./dir
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1
      labels:
        - "com.example.description=Accounting webapp"
        - "com.example.department=Finance"
        - "com.example.label-with-empty-value"
      target: prod

• context：上下文路径。
• dockerfile：指定构建镜像的 Dockerfile 文件名。
• args：添加构建参数，这是只能在构建过程中访问的环境变量。
• labels：设置构建镜像的标签。
• target：多层构建，可以指定构建哪一层。

cap_add，cap_drop

添加或删除容器拥有的宿主机的内核功能。

cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限

cgroup_parent

为容器指定父 cgroup 组，意味着将继承该组的资源限制。

cgroup_parent: m-executor-abcd

command

覆盖容器启动的默认命令。

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

container_name

指定自定义容器名称，而不是生成的默认名称。

container_name: my-web-container

depends_on

设置依赖关系。

• docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。
• docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。
• docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。

version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

注意：web 服务不会等待 redis db 完全启动 之后才启动。

deploy

指定与服务的部署和运行有关的配置。只在 swarm 模式下才会有用。

version: "3.7"
services:
  redis:
    image: redis:alpine
    deploy:
      mode：replicated
      replicas: 6
      endpoint_mode: dnsrr
      labels: 
        description: "This redis service label"
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
        reservations:
          cpus: '0.25'
          memory: 20M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
        window: 120s

可以选参数：

endpoint_mode：访问集群服务的方式。

endpoint_mode: vip 
# Docker 集群服务一个对外的虚拟 ip。所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器。
endpoint_mode: dnsrr
# DNS 轮询（DNSRR）。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。

labels：在服务上设置标签。可以用容器上的 labels（跟 deploy 同级的配置） 覆盖 deploy 下的 labels。

mode：指定服务提供的模式。

• replicated：复制服务，复制指定服务到集群的机器上。

• global：全局服务，服务将部署至集群的每个节点。

• 图解：下图中黄色的方块是 replicated 模式的运行情况，灰色方块是 global 模式的运行情况。

replicas：mode 为 replicated 时，需要使用此参数配置具体运行的节点数量。

resources：配置服务器资源使用的限制，例如上例子，配置 redis 集群运行需要的 cpu 的百分比 和 内存的占用。避免占用资源过高出现异常。

restart_policy：配置如何在退出容器时重新启动容器。

• condition：可选 none，on-failure 或者 any（默认值：any）。

• delay：设置多久之后重启（默认值：0）。

• max_attempts：尝试重新启动容器的次数，超出次数，则不再尝试（默认值：一直重试）。

• window：设置容器重启超时时间（默认值：0）。

• rollback_config：配置在更新失败的情况下应如何回滚服务。

• parallelism：一次要回滚的容器数。如果设置为0，则所有容器将同时回滚。

• delay：每个容器组回滚之间等待的时间（默认为0s）。

• failure_action：如果回滚失败，该怎么办。其中一个 continue 或者 pause（默认pause）。

• monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。

• max_failure_ratio：在回滚期间可以容忍的故障率（默认为0）。

• order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认 stop-first ）。

• update_config：配置应如何更新服务，对于配置滚动更新很有用。

• parallelism：一次更新的容器数。

• delay：在更新一组容器之间等待的时间。

• failure_action：如果更新失败，该怎么办。其中一个 continue，rollback 或者pause （默认：pause）。

• monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。

• max_failure_ratio：在更新过程中可以容忍的故障率。

• order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认stop-first）。

注：仅支持 V3.4 及更高版本。

devices

指定设备映射列表。

devices:
  - "/dev/ttyUSB0:/dev/ttyUSB0"

dns

自定义 DNS 服务器，可以是单个值或列表的多个值。

dns: 8.8.8.8

dns:
  - 8.8.8.8
  - 9.9.9.9

dns_search

自定义 DNS 搜索域。可以是单个值或列表。

dns_search: example.com

dns_search:
  - dc1.example.com
  - dc2.example.com

entrypoint

覆盖容器默认的 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

env_file

从文件添加环境变量。可以是单个值或列表的多个值。

env_file: .env

也可以是列表格式：

env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env

environment

添加环境变量。您可以使用数组或字典、任何布尔值，布尔值需要用引号引起来，以确保 YML 解析器不会将其转换为 True 或 False。

environment:
  RACK_ENV: development
  SHOW: 'true'

expose

暴露端口，但不映射到宿主机，只被连接的服务访问。

仅可以指定内部端口为参数：

expose:
 - "3000"
 - "8000"

extra_hosts

添加主机名映射。类似 docker client --add-host。

extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"

以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：

162.242.195.82  somehost
50.31.209.229   otherhost

healthcheck

用于检测 docker 服务是否健康运行。

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序

image

指定容器运行的镜像。以下格式都可以：

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

logging

服务的日志记录配置。

driver：指定服务容器的日志记录驱动程序，默认值为json-file。有以下三个选项

driver: "json-file"
driver: "syslog"
driver: "none"

仅在 json-file 驱动程序下，可以使用以下参数，限制日志得数量和大小。

logging:
  driver: json-file
  options:
    max-size: "200k" # 单个文件大小为200k
    max-file: "10" # 最多10个文件

当达到文件限制上限，会自动删除旧得文件。

syslog 驱动程序下，可以使用 syslog-address 指定日志接收地址。

logging:
  driver: syslog
  options:
    syslog-address: "tcp://192.168.0.42:123"

network_mode

设置网络模式。

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

networks

配置容器连接的网络，引用顶级 networks 下的条目 。

services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2
networks:
  some-network:
    # Use a custom driver
    driver: custom-driver-1
  other-network:
    # Use a custom driver which takes special options
    driver: custom-driver-2

aliases ：同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。

restart

• no：是默认的重启策略，在任何情况下都不会重启容器。
• always：容器总是重新启动。
• on-failure：在容器非正常退出时（退出状态非0），才会重启容器。
• unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

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

注：swarm 集群模式，请改用 restart_policy。

secrets

存储敏感数据，例如密码：

version: "3.1"
services:

mysql:
  image: mysql
  environment:
    MYSQL_ROOT_PASSWORD_FILE: /run/secrets/my_secret
  secrets:
    - my_secret

secrets:
  my_secret:
    file: ./my_secret.txt

security_opt

修改容器默认的 schema 标签。

security-opt：
  - label:user:USER   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

stop_grace_period

指定在容器无法处理 SIGTERM (或者任何 stop_signal 的信号)，等待多久后发送 SIGKILL 信号关闭容器。

stop_grace_period: 1s # 等待 1 秒
stop_grace_period: 1m30s # 等待 1 分 30 秒 

默认的等待时间是 10 秒。

stop_signal

设置停止容器的替代信号。默认情况下使用 SIGTERM 。

以下示例，使用 SIGUSR1 替代信号 SIGTERM 来停止容器。

stop_signal: SIGUSR1

sysctls

设置容器中的内核参数，可以使用数组或字典格式。

sysctls:
  net.core.somaxconn: 1024
  net.ipv4.tcp_syncookies: 0

sysctls:
  - net.core.somaxconn=1024
  - net.ipv4.tcp_syncookies=0

tmpfs

在容器内安装一个临时文件系统。可以是单个值或列表的多个值。

tmpfs: /run

tmpfs:
  - /run
  - /tmp

ulimits

覆盖容器默认的 ulimit。

ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000

volumes

将主机的数据卷或着文件挂载到容器里。

version: "3.7"
services:
  db:
    image: postgres:latest
    volumes:
      - "/localhost/postgres.sock:/var/run/postgres/postgres.sock"
      - "/localhost/data:/var/lib/postgresql/data"

Dockerfile 配置模板

FROM openjdk:8
VOLUME /tmp
# EXPOSE 80
ENV TZ=Asia/Shanghai JAVA_OPTS=-Xmx512m
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ADD *.jar app.jar
ENTRYPOINT java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar
# ENTRYPOINT exec java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --Dspring.config.location=/config/*
# 为了缩短 Tomcat 的启动时间，添加java.security.egd的系统属性指向/dev/urandom作为 ENTRYPOINT
ENTRYPOINT ['java', $JAVA_OPTS, '-Djava.security.egd=file:/dev/./urandom','-jar', '/app.jar', '--Dspring.config.location=/config/*']

FROM java:8
VOLUME /tmp
EXPOSE 8080
ENV TZ=Asia/Shanghai JAVA_OPTS=-Xmx512m
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ADD *.jar app.jar
ENTRYPOINT java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar

# 
FROM openjdk:11
VOLUME /tmp
ENV TZ=Asia/Shanghai JAVA_OPTS=-Xmx512m
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ADD *.jar app.jar
# CMD echo '10.254.7.7 bzdts.chinaetc.org' >> /etc/hosts; java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --Dspring.config.location=/config/*
ENTRYPOINT echo '10.254.7.7 bzdts.chinaetc.org' >> /etc/hosts && java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar --Dspring.config.location=/config/*


# tomcat_8.5.47-jdk11
FROM tomcat:8.5.47-jdk11
# MAINTAINER itqmdx@gmail.com
# VOLUME /usr/local/tomcat
EXPOSE 8080
# RUN rm -rf /usr/local/tomcat/webapps/*
ENV TZ=Asia/Shanghai JAVA_OPTS=-Xmx512m
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# ADD ./target/* /usr/local/tomcat/webapps/
ENTRYPOINT ['/usr/local/tomcat/bin/catalina.sh', 'run']
# ENTRYPOINT echo '10.254.7.7 bzdts.chinaetc.org' >> /etc/hosts && /usr/local/tomcat/bin/catalina.sh run

[shell] docker deploy service script 部署脚本模板

#!/bin/bash

# service name
SERVICE_NAME=service-name
# service port (--net=host invalid)
OPEN_PORT=7000
# 实例
INSTANCES=1

# log path
LOG_PATH=/logs

# author: wzhz
# email: itqmdx@gmail.com
# version: v0.4
version=v0.4

# local ip (--net=host invalid)
IP=$(ip a | grep inet | grep -v 127.0.0.1 | grep -v inet6 | grep -v docker | awk '{print $2}' | tr -d 'addr:' | awk -F '/' '{print $1}' | head -1)
# get ip
# ip addr | grep 'state UP' -A2 | tail -n1 | awk '{print $2}' | awk -F"/" '{print $1}'
DATEVERSION=$(date +'%Y.%m.%d.%H')

# script_dir
script_dir=$(readlink -f $0)
bootpath=$(dirname $script_dir)

# logspath=$bootpath/logs
# configpath=$bootpath/config
# jarpath=$bootpath/jar

RED='\e[1;31m'
GREEN='\e[1;32m'
YELLOW='\033[1;33m'
BLUE='\E[1;34m'
PINK='\E[1;35m'
RES='\033[0m'

# get all filename in specified path
getFileName() {
  path=$1
  files=$(ls $bootpath/jar)
  for filename in $files
  do
    echo $filename # >> filename.txt
  done

  for file in `find  $1 -name "*.jar"`
  do
    echo $file
  done
}

# touch Dockerfile
createDockerfile() {
#  --Dspring.config.location=/config/*
cat > ./Dockerfile << EOF
FROM openjdk:8
VOLUME /logs
EXPOSE $OPEN_PORT
ENV TZ=Asia/Shanghai JAVA_OPTS="-server -Xms512m -Xmx512m -XX:PermSize=64M -XX:MaxNewSize=256m -XX:MaxPermSize=128m -Djava.awt.headless=true "
RUN ln -snf /usr/share/zoneinfo/\$TZ /etc/localtime && echo \$TZ > /etc/timezone
ADD *.jar app.jar
ENTRYPOINT exec java \$JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar
EOF
}

# delete old and images
deleteOldImage() {
  docker image rm -f $SERVICE_NAME:$DATEVERSION >> /dev/null 2>&1;
  docker image ls
}
# delete old containers
deleteOldContainer() {
  OLD_INSTANCES=$(docker container ps -a | grep -i $SERVICE_NAME | wc -l);
  for((i=0;i<$OLD_INSTANCES;i++));
  do
    docker container stop $SERVICE_NAME-$i >> /dev/null 2>&1;
    docker container rm -f $SERVICE_NAME-$i >> /dev/null 2>&1;
  done
  # rm -rf $bootpath/logs;
  if docker container ps -a | grep -i $SERVICE_NAME;then
    echo -e $RED hase $OLD_INSTANCES instances. $RES
  fi
  docker container ps
}

# build docker image
buildImage() {
  docker build -t $SERVICE_NAME:$DATEVERSION . ;
  docker image ls
}

# run docker container
runImage() {
  for((i=0;i < $INSTANCES;i++));
  do
    name=$SERVICE_NAME-$i
    port=$(($OPEN_PORT+$i))
    docker container rm -f $name >> /dev/null 2>&1
    echo create container is $name:$IP:$port;

    # docker run \
    # --net=host \
    # -v $bootpath/logs:$LOG_PATH \
    # -v $bootpath/config:/config \
    # --name $name \
    # --restart=on-failure:10 \
    # -d $SERVICE_NAME >> /dev/null 2>&1
    docker run \
    --expose=$port \
    -p $port:$port \
    -v $bootpath/logs:$LOG_PATH \
    -e server.port=$port \
    -e spring.application.name=$SERVICE_NAME \
    -e spring.cloud.client.ip-address=$IP \
    -e EUREKA_INSTANCE_INSTANCE-ID=$IP:$SERVICE_NAME:$port \
    -e EUREKA_INSTANCE_IP-ADDRESS=$IP \
    -e SERVER_PORT=$port \
    -e JAVA_OPTS=-Xmx512m \
    --name $name \
    --restart=on-failure:10 \
    -d $SERVICE_NAME:$DATEVERSION # >> /dev/null 2>&1
    CONTAINERID_NEW=`docker container ps -a | grep ${name}| awk '{print $NF}'`
    echo new container created successfully is $CONTAINERID_NEW
    if [ $i -lt $INSTANCES ];then
      sleep 1;
    fi
  done
  docker container ps
}
startContainer() {
  for((i=0;i < $INSTANCES;i++));
  do
    name=$SERVICE_NAME-$i
    port=$(($OPEN_PORT+$i))

    docker container start $name >> /dev/null 2>&1
    echo start container is $name:$IP:$port
    if [ $i -lt $INSTANCES ];then
      sleep 1;
    fi
  done
  docker container ps
}
restartContainer() {
  for((i=0;i < $INSTANCES;i++));
  do
    name=$SERVICE_NAME-$i
    port=$(($OPEN_PORT+$i))

    docker container restart $name >> /dev/null 2>&1
    echo restart container is $name:$IP:$port
    if [ $i -lt $INSTANCES ];then
      sleep 1;
    fi
  done
  docker container ps
}
stopContainer() {
  for((i=0;i < $INSTANCES;i++));
  do
    name=$SERVICE_NAME-$i
    port=$(($OPEN_PORT+$i))

    docker container stop $name >> /dev/null 2>&1
    echo stop container is $name:$IP:$port
    if [ $i -lt $INSTANCES ];then
      sleep 1;
    fi
  done
  docker container ps
}
viewContainerLog() {
  if [ $INSTANCES -eq 1 ];then
    showLog $SERVICE_NAME-0
  else
    # more
    echo -e $GREEN show logs for containers: $RES
    docker ps -a | grep ${SERVICE_NAME}| awk '{print $1, $2, $(NF-1), $NF}'
    read -p 'please input a container id or name: ' input
    showLog $input
  fi
}
showLog() {
  docker container logs -f --tail=100 $1
}
readme() {
  echo -e $GREEN ---- deploy service script $RES
  echo -e $YELLOW ---- author: wzhz $RES
  echo -e $YELLOW ---- email: itqmdx@gmail.com $RES
  echo -e $YELLOW ---- version: $version $RES
}

current() {
  echo 
  echo -e $PINK current time is $(date +'%Y-%m-%d %T') $RES
  echo 
}

var() {
  echo 
  echo IP $IP
  echo SERVICE_NAME $SERVICE_NAME
  echo OPEN_PORT $OPEN_PORT
  echo INSTANCES $INSTANCES
  echo DATEVERSION $DATEVERSION
  echo 
}

# setting env var
setEnvironmentVariable() {
  ARRT=$1
  ARRT_NAME=`echo ${ARRT} | awk -F '=' '{print $1}'`
  ARRT_VALUE=`echo ${ARRT} | awk -F '=' '{print $2}'`
  # echo $ARRT_NAME is $ARRT_VALUE
  if [ $ARRT_NAME == 'name' ]; then
    SERVICE_NAME=$ARRT_VALUE
  elif [ $ARRT_NAME == 'port' ]; then
    OPEN_PORT=$ARRT_VALUE
  elif [ $ARRT_NAME == 'ip' ]; then
    IP=$ARRT_VALUE
  elif [ $ARRT_NAME == 'i' ]; then
    INSTANCES=$ARRT_VALUE
  else
    echo 
    echo -e $RED $ARRT no matches found. $RES
    echo 
  fi
}

functionItems() {
  echo 
  echo -e $GREEN = 0. perform steps 7-8 and 1-3 automatically $RES
  echo -e $BLUE = 1. create current environment\'s Dockerfile $RES
  echo -e $BLUE = 2. build image $SERVICE_NAME $RES
  echo -e $BLUE = 3. run image $SERVICE_NAME $RES
  echo -e $BLUE = 4. start $SERVICE_NAME\'s containers $RES
  echo -e $BLUE = 5. restart $SERVICE_NAME\'s containers $RES
  echo -e $BLUE = 6. stop $SERVICE_NAME\'s containers $RES
  echo -e $BLUE = 7. delete $SERVICE_NAME\'s containers  $RES
  echo -e $BLUE = 8. delete image $SERVICE_NAME $RES
  echo -e $BLUE = 9. view $SERVICE_NAME\'s container log $RES
  echo -e $RED = 99. configure global information $RES
  echo 
}

main() {
  functionItems
  read -p 'please input a function item no: ' input
  echo your input is $input
  case $input in
    0)
    deleteOldContainer
    echo -e $GREEN delete containers successfully. $RES
    deleteOldImage
    echo -e $GREEN delete image successfully. $RES
    createDockerfile
    echo -e $GREEN Dockerfile created successfully, default is based on openjdk:8. $RES
    buildImage
    echo -e $GREEN created successfully, image is $SERVICE_NAME. $RES
    runImage
    echo -e $GREEN runs successfully. $RES
    ;;
    1)
    createDockerfile
    echo -e $GREEN Dockerfile created successfully, default is based on openjdk:8. $RES
    cat Dockerfile
    ;;
    2)
    buildImage
    echo -e $GREEN created successfully, image is $SERVICE_NAME. $RES
    ;;
    3)
    runImage
    echo -e $GREEN runs successfully. $RES
    ;;
    4)
    startContainer
    echo -e $GREEN start container successfully. $RES
    ;;
    5)
    restartContainer
    echo -e $GREEN restart container successfully. $RES
    ;;
    6)
    stopContainer
    echo -e $GREEN stop container successfully. $RES
    ;;
    7)
    deleteOldContainer
    echo -e $GREEN delete containers successfully. $RES
    ;;
    8)
    deleteOldImage
    echo -e $GREEN delete image successfully. $RES
    ;;
    9)
    viewContainerLog
    echo -e $GREEN view container log complete. $RES
    ;;
    99)
    echo -e $YELLOW developing... $RES
    ;;
    *)
    echo -e $RED wrong input, exit 0. $RES
    exit 0
    ;;
  esac
}

echo -e $YELLOW working directory is $bootpath $RES
cd $bootpath;ls -all;

for arg in $@
do
  setEnvironmentVariable $arg
done

readme

current

var

while true
do
  main
  sleep 1
done

[shell] Docker 部署脚本模板2

#!/bin/bash

if [ $1 == "" ];then
     echo "plsese input the image name of the jar api"
     exit 0
fi

IMAGE=$1 
echo "input image is ${IMAGE}"






######################## delete the container of this jar api  ########################

CONTAINERID=`docker ps -a|grep ${IMAGE} |awk '{print $1}'`
echo "contained id is ${CONTAINERID}"

docker stop ${CONTAINERID}
docker rm ${CONTAINERID}

########################  get image name and image tag ....sed -n 为获取第几行数据  ########################


IMAGENAME=`echo ${IMAGE} | awk -F ":" '{print $1}'`
echo "imagename is ${IMAGENAME}"

IMAGETAG=`echo ${IMAGE}| awk -F ":" '{print $2}'`
echo "imagetag is ${IMAGETAG}"

IMAGEROWNUM=`docker images | grep ${IMAGENAME}| wc -l`
echo "imagerownum is ${IMAGEROWNUM}"

########################  同一镜像名称可能有多个不同的版本，如果同时满足所要删除的镜像名称和tag，则删除该镜像 ########################
for ((i=1;i<=$IMAGEROWNUM;i++))
  do
    echo "i is ${i}"
    IMAGENAME2=`docker images|grep ${IMAGENAME} | sed -n "${i}p" |awk '{print $1}'`
    echo "imagename2 is ${IMAGENAME2}"
    if [ "${IMAGENAME2}" == "${IMAGENAME}" ];then
    IMAGETAG2=`docker images|grep ${IMAGENAME} | sed -n "${i}p" |awk '{print $2}'`
    echo "imagetag2 is ${IMAGETAG2}"
       if [ "${IMAGETAG2}" == "${IMAGETAG}" ];then
       IMAGEID=`docker images|grep ${IMAGENAME} | sed -n "${i}p" |awk '{print $3}'`
       echo "imageid is ${IMAGEID}"

       docker rmi ${IMAGEID}
       fi
    fi
done


######################## 创建镜像  ########################

docker build -t ${IMAGE} . 

######################## 生成容器，并在后台运行，生成容器时才会执行dockerfile文件中的java -jar等指令  ########################

docker run -d --net=host -v /home/xjjtuser/dataAnalysis-logs/:/data-analysis/  -v /home/xjjtuser/docker-program/config/:/config/ --name data-analysis  ${IMAGE}

# 显示日志信息
containerid_new=`docker ps -a | grep ${IMAGE}| awk '{print $1}'`
echo "containerid_new is ${containerid_new}"

docker logs "${containerid_new}"

修改 docker 日志大小配置

修改 docker 日志大小配置

编辑或新建配置文件需要 root 用户

命 令: vi /etc/docker/daemon.json 添加以下内容：

{
"log-driver":"json-file",
"log-opts":{"max-size":"500M","max-file":"3"}  
}

配置完成重启 docker

重启docker: systemctl restart docker

如何科学的在Docker Container中运行多个服务

在一个Docker Container中运行多个服务？打扰了。

0x00 前言

Docker，或说任何基于 内核 namespace 的轻量级进程隔离技术，在设计之初，都不是为了当作虚拟机使用的。也就是说，其中运行的并不是一个完整的操作系统。包括 Docker 官方，也是推荐在一个 Container 内仅运行一个服务。如果需要运行多个服务，应通过 docker run --link 或者 docker-compose 来关联多个容器。但是在实际的应用中，我们经常希望将一个完整的可运行环境打包成一个 docker image ，不再依赖其他的容器。比如在 CTF 比赛中，将多个服务打包成一个 Image ，可以有效地提高在环境受损后恢复的效率。在经历了多场比赛，看过各种大师傅用各种奇怪的姿势完成这个任务后，觉得应该好好的讨论一下这个问题。

0x01 错误的姿势

• 使用upstart的启动方式

# Dockerfile
From ubuntu:14.04
RUN apt-get update && apt-get upgrade -y && apt-get install mysql apache2 php7.0 
ADD web /var/www/html
RUN service mysql start && /var/www/html/init_sql.sh && service mysql stop
CMD service mysql start && service apache2 start && while true; do sleep 10;done

• 使用systemd的启动方式

# Dockerfile
From ubuntu:16.04
RUN apt-get update && apt-get upgrade -y && apt-get install mysql apache2 php7.0 
ADD web /var/www/html
RUN systemctl start mysql && /var/www/html/init_sql.sh && systemctl stop mysql
CMD systemctl start mysql && systemctl start apache2 && while true; do sleep 10;done

• 使用启动脚本启动多个服务

# Dockerfile
From ubuntu:16.04
RUN apt-get update && apt-get upgrade -y && apt-get install mysql apache2 php7.0 
ADD web /var/www/html
ADD entrypoint.sh /sbin/
RUN chmod +x /sbin/entrypoint.sh /var/www/html/init_sql.sh&& 
     /etc/init.d/mysql start && /var/www/html/init_sql.sh && /etc/init.d/mysql stop

CMD /sbin/entrypoint.sh

#!/bin/bash 

# entrypoint.sh
/usr/bin/mysqld start &
/usr/bin/httpd &
while true
do
sleep 100
done

在实际中，使用 方法1 或者 方法2 很大几率无法完成将多个服务跑在同一个container中的任务。 方法3 虽然可以，但仍然存在一些问题：

SIGTERM

方法1 和 方法2 不能成功，是因为docker只是一个进程隔离的沙箱环境，并不是真正的虚拟机。而 service xxx start 和 systemctl start xxx 分别是 upstart 和 systemd 这两个 /sbin/init 进程的替代者的服务管理命令。而 upstart 和 systemd 都要求系统必须是物理机或虚拟机，并不支持作为container的 init 进程。方法3存在问题是因为，在正常的系统中， init 进程永远占用 PID=1 的位置，回收僵尸进程、处理未处理的信号等都是由 init 进程帮我们完成的，一个子进程如果失去了父进程，也会由 init 进程接管。但是在container中， init 进程并不存在， PID=1 的进程是我们在 Dockerfile 中定义的 Entrypoint 或最后一个 CMD 指定的命令。

root@vpscn:/var/lib/docker# docker exec -it hackmd sh
/hackmd # ps -ef
PID   USER     TIME   COMMAND
    1 hackmd     1:03 node app.js
   42 hackmd     0:00 /usr/local/bin/node ./lib/workers/dmpWorker.js
   62 root       0:00 sh
   69 root       0:00 ps -ef

因此，对于启动方法3的container，我们应该在启动时加上 --init 参数，来强制使用 tini 作为 init 进程。但是就算这样，在服务多了之后，进行重启等操作仍然很繁琐。

0x02 推荐的姿势

作为一个金牌运维打杂的，简单谈谈我常用的方法。

首先推荐一个超级好用的基础镜像 phusion/baseimage 。截至SUCTF2018环境准备完成时，该镜像的最新版本是 0.10.1 ，基于 ubuntu 16.04 。我们常用的 apt-get 等命令都可以无缝兼容。 phusion/baseimage 采用了作者自己开发的一个基于 python 的 init 进程作为Container的 Entrypoint ，采用 runit 作为服务管理器。这个基础镜像还是在Coding打杂的时候知道的， Coding WebIDE Studio 的Web Terminal也是基于这个镜像做的。NUAACTF/SUCTF的PWN题基础镜像 ctf-xinetd 也是基于这个镜像做的。

然后直接贴个在SUCTF2018运维期间写的 Dockerfile

#Dockerfile
FROM phusion/baseimage:0.10.1
MAINTAINER Yibai Zhang 

RUN sed -i 's/archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list &&
    sed -i 's/security.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list &&
    apt-get update && apt-get install -y apache2 libapache2-mod-php php-mysql mariadb-server &&
    apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* /var/www/html/*

RUN mkdir -p /etc/service/apache2/ && 
    printf "#!/bin/shnntrap "apachectl -k graceful-stop" 1 2 3 6 15nnexec /usr/sbin/apachectl -D FOREGROUNDn" > /etc/service/apache2/run &&
    chmod +x /etc/service/apache2/run && mkdir -p /etc/service/mysql/ &&
    printf "#!/bin/shnntrap "mysqladmin -uroot -psuCTF_P1us_1s shutdown" 1 2 3 6 15nnexec /usr/bin/mysqld_safe" > /etc/service/mysql/run &&
    mkdir -p /var/run/mysqld/ && chown mysql:mysql /var/run/mysqld &&
    chmod 700 /etc/service/mysql/run /etc/service/apache2/run

COPY web /var/www/html
COPY flag /flag
RUN echo "secure-file-priv=/var/www/" >>/etc/mysql/mariadb.conf.d/50-server.cnf && chmod -R 777 /var/www/html/favicon
COPY init_sql.sh /tmp/init_sql.sh
RUN chmod +x /tmp/init_sql.sh && bash -c "/tmp/init_sql.sh" && rm /tmp/init_sql.sh
EXPOSE 80

#!/usr/bin/env bash
#init_sql.sh

mysqld_safe &   
echo -n "Waiting for mysql startup"
while ! mysqladmin --host="localhost" --silent ping ; do
    echo -n "."
    sleep 1
done
echo

mysql -uroot <<EOF
UPDATE mysql.user SET Password=PASSWORD('XXXXXX'), plugin = '' WHERE User='root';
create database calc;
use calc;
create table user(
id INT NOT NULL AUTO_INCREMENT primary key,
username varchar(32) NOT NULL,
password varchar(32) NOT NULL
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into user values(1,'admin','aa67095d8e65d624548cb6b50bd4778e');
create table file(
id INT NOT NULL AUTO_INCREMENT primary key,
filename varchar(32) NOT NULL,
filehash varchar(32) NOT NULL,
sig varchar(120) NOT NULL
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
create table flag(
flag varchar(120) primary key
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into flag values('SUCTF{a_very_long_long_long_long_long_fake_flag_d}');
grant SELECT, INSERT on calc.user to 'suctf'@localhost identified by 'suctf';
grant SELECT, INSERT, UPDATE on calc.file to 'suctf'@localhost ;
grant SELECT on calc.flag to 'suctf'@localhost ;
FLUSH PRIVILEGES;
EOF

mysqladmin -uroot -pXXXXXX shutdown

这里着重看一下 printf "#!/bin/shnntrap "apachectl -k graceful-stop" 1 2 3 6 15nnexec /usr/sbin/apachectl -D FOREGROUNDn" > /etc/service/apache2/run ，这个命令就是在创建runit启动脚本。具体的说明可以去看 phusion/baseimage 或者 runit 的手册。执行完成后会在 /etc/service/apache2/run 下面生成如下内容的脚本

#!/bin/sh

trap "apachectl -k graceful-stop" 1 2 3 6 15

exec /usr/sbin/apachectl -D FOREGROUND

这个脚本会作为runit的子进程运行，并将Apache2保持在前台运行。在接收到 1 2 3 6 15 这几个信号的时候友好的(graceful)结束Apache2。如果在运行中需要重启Apache服务，只需要运行 docker exec container_name sv restart apache2 即可。通过这种方式，在Container停止的时候也可以通知相关的进程，而不是直接全部杀死，更可以保证服务的完整性。~~ 虽然在比赛中基本挂了就要恢复环境根本不需要保证完整性。 ~~