简述两者的区别

docker是自动化构建镜像，并启动镜像。 docker compose是自动化编排容器。
docker是基于Dockerfile得到images，启动的时候是一个单独的container。
docker-compose是基于docker-compose.yml，通常启动的时候是一个服务，这个服务通常由多个container共同组成，并且端口，配置等由docker-compose定义好。
两者都需要安装，但是要使用docker-compose，必须已经安装docker。

docker-compose的使用

docker-compose安装

pip安装方法（推介）

pip install docker-compose  -i  https://pypi.douban.com/simple

安装完成，版本检查

docker-compose version

官方包安装

访问https://github.com/docker/compose/releases，下载 docker-compose-Linux-x86_64，我是复制链接地址，在迅雷中下载的，下载后，将docker-compose-Linux-x86_64重命名为docker-compose，并上传到到服务器的的/usr/local/bin/目录下。

# 添加可执行权限
sudo chmod +x /usr/local/bin/docker-compose
# 查看docker-compose版本
docker-compose -v

Docker-Compose生命周期

由于docker-compose是建立在docker的基础上的，因此docker-compose的生命周期与docker相似。

一句话的生命周期：编写docker-compose.yml，通过build建立服务镜像，start启动服务，pause/unpause暂停/恢复服务，restart重启服务，stop停止服务，rm停止容器服务并强制删除。

Docker-Compose常用命令

命令需在docker-compose.yml文件目录下进行，否则提示无法找到服务。

build创建服务

创建时必须在docker-compose.yml文件目录下进行。

#用来创建或重新创建服务使用的镜像

[root@localhost ~]

# docker-compose build 例如：docker-compose build service_a #创建一个镜像名叫service_a

pull拉取服务

除了使用docker-compose.yml建立镜像，也可以从云端拉取容器服务。

如果你docker-compose pull ServiceName在docker-compose.yml定义服务的文件所在的目录下运行，Docker 会提取 postgres 镜像。例如，要在我们的示例中调用postgres配置为db服务的映像，您可以运行docker-compose pull db

提取与在docker-compose.yml或docker-stack.yml文件中定义的服务相关联的映像，但不会基于这些映像启动容器。

例如，假设您docker-compose.yml从 Quickstart：Compose 和 Rails 示例中获得此文件。

version: '2'services:
  db:
    image: postgres
  web:
    build: .
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:      - .:/myapp
    ports:      - "3000:3000"
    depends_on:      - db

Usage: pull [options] [SERVICE...]
    Options:    
    --ignore-pull-failures  Pull what it can and ignores images with pull failures.    
    --parallel              Pull multiple images in parallel.    
    --quiet                 Pull without printing progress information
#用于拉取服务依赖的镜像

[root@localhost ~]

# docker-compose pull db

run一次性命令

Usage: run [options] [-v VOLUME...] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]
Options:    
  -d, --detach               Run container in background and print container ID  后台运行容器
  -e, --env list             Set environment variables                           设置环境变量
  --expose list              Expose a port or a range of ports                   暴露端口
  -i, --interactive          Keep STDIN open even if not attached                交互模式
  --name string              Assign a name to the container                      给当前运行的容器指定名字
  -p, --publish list         Publish a container's port(s) to the host           指定端口映射
  -P, --publish-all          Publish all exposed ports to random ports           随机指定暴露的端口映射
  -t, --tty                  Allocate a pseudo-TTY                               分配一个终端
  -v, --volume list          Bind mount a volume                                 挂载数据卷
  --volumes-from list        Mount volumes from the specified container(s)       从一个数据卷容器挂载目录
  -w, --workdir string       Working directory inside the container              指定容器中的工作目录

使用的命令run从具有由服务定义的配置的新容器中启动，包括卷，链接和其他详细信息。

run启动的区别：

web服务配置以bash开头，则将其docker-compose run web python app.py覆盖python app.py
docker-compose run命令不会创建服务配置中指定的任何端口。这可以防止端口与已打开的端口发生冲突。如果您确实想要创建服务的端口并将其映射到主机，请指定--service-ports标志：

docker-compose run --service-ports web python manage.py shell

或者，可以使用--publish或-p选项，就像使用docker run：

docker-compose run --publish 8080:80 -p 2022:22 -p 127.0.0.1:2021:21 web python manage.py shell

如果启动使用链接配置的服务，则该run命令首先检查链接服务是否正在运行，并在服务停止时启动该服务。一旦所有链接的服务正在运行，run执行您通过它的命令。例如，您可以运行：

docker-compose run db psql -h db -U docker

这将为链接db容器打开一个交互式 PostgreSQL shell。

如果您不希望run命令启动链接容器，请使用--no-deps

docker-compose run --no-deps web python manage.py shell

start启动服务

Usage: start [SERVICE...]

启动指定服务的容器

pause暂停服务

Usage: pause [SERVICE...]

暂停服务，不可以与unpause一起使用。

stop停止服务

Usage: stop [options] [SERVICE...]
    Options:
        -t, --timeout TIMEOUT      Specify a shutdown timeout in seconds (default: 10).

停止容器

restart重启服务

Usage: stop [options] [SERVICE...]
    Options:
        -t, --timeout TIMEOUT      Specify a shutdown timeout in seconds (default: 10).

重启服务

up启动所有容器服务

Usage: up [options] [--scale SERVICE=NUM...] [SERVICE...]
Options: -d Detached mode: Run containers in the background,
print new container names.
Incompatible with --abort-on-container-exit.
--no-color Produce monochrome output.
--no-deps Don't start linked services.
--force-recreate Recreate containers even if their configuration
and image haven't changed.
Incompatible with --no-recreate.
--no-recreate If containers already exist, don't recreate them.
Incompatible with --force-recreate.
--no-build Don't build an image, even if it's missing.
--build Build images before starting containers.
--abort-on-container-exit Stops all containers if any container was stopped.
Incompatible with -d.
-t, --timeout TIMEOUT Use this timeout in seconds for container shutdown
when attached or when containers are already
running. (default: 10)
--remove-orphans Remove containers for services not defined in
the Compose file
--exit-code-from SERVICE Return the exit code of the selected service container.
Implies --abort-on-container-exit.
--scale SERVICE=NUM Scale SERVICE to NUM instances. Overrides the `scale`
setting in the Compose file if present.

构建，（重新）创建，启动并附加到服务的容器。

docker-compose up

退出命令时，所有容器也停止。

docker-compose up -d

该命令将以后台启动所有容器服务。

容器服务后服务的配置或映像已更改的处理

docker-compose up -d --no-recreat

防止撰写选取更改

强制停止重启容器服务

docker-compose up -d --force-recreate

如果进程遇到错误，则此命令的退出代码为1。

如果使用SIGINT（ctrl+ C）中断进程或者SIGTERM容器停止，并且退出代码为0。

如果SIGINT或SIGTERM在此关闭阶段再次发送，正在运行的容器将被终止，并且退出代码为2。

logs服务日志查看

Usage: logs [options] [SERVICE...]
    Options:
    --no-color          Produce monochrome output.
    -f, --follow        Follow log output
    -t, --timestamps    Show timestamps
    --tail="all"        Number of lines to show from the end of the logs                    
                        for each container.

服务日志查看

down停止并删除容器

Usage: down [options]
Options:    
    --rmi type          Remove images. Type must be one of:                        
                        'all': Remove all images used by any service.                        
                        'local': Remove only images that don't have a custom tag                        
                        set by the `image` field.    
    -v, --volumes       Remove named volumes declared in the `volumes` section                        
                        of the Compose file and anonymous volumes
                        attached to containers.    
    --remove-orphans    Remove containers for services not defined in the
                        Compose file

停止容器并移除通过创建的容器，网络，卷和图像up。

默认情况下，唯一删除的内容是：

在撰写文件中定义的服务容器
网络在networks撰写文件的部分中定义
默认网络（如果使用的话）

定义为external的网络和卷从不删除。

rm删除停止的容器

Usage: rm [options] [SERVICE...]
Options:    
-f, --force   Don't ask to confirm removal    
-s, --stop    Stop the containers, if required, before removing    
-v            Remove any anonymous volumes attached to containers

删除已停止的服务容器。

默认情况下，附加到容器的匿名卷不会被删除。你可以用这个覆盖它-v。要列出所有卷，请使用docker volume ls。

任何不在卷中的数据都将丢失。

运行没有选项的命令也会删除由docker-compose up或创建的一次性容器docker-compose run：

$ docker-compose rm
Going to remove djangoquickstart_web_run_1
Are you sure? [yN] y
Removing djangoquickstart_web_run_1 ... done

create创建容器

为服务创建容器。

docker-compose create [options] [SERVICE…]
  --force-recreate：重新创建容器，即使配置和镜像没有改变，不兼容–no-recreate参数
  --no-recreate：如果容器已经存在，不需要重新创建，不兼容–force-recreate参数
  --no-build：不创建镜像，即使缺失
  --build：创建容器前，生成镜像

kill强制停止服务容器

通过发送SIGKILL信号来强制停止服务容器。

支持通过-s参数来指定发送的信号，例如通过如下指令发送SIGINT信号。

docker-compose kill [options] [SERVICE…]
	-s SIGNAL ，向容器发出信号。默认信号是SIGKILL。
 docker-compose kill -s SIGINT

ps显示在运行的服务

显示正在运行的服务

docker-compose ps [options] [SERVICE…]
  -q, --quiet ，只显示id
  --services  ，显示服务
  --filter KEY=VAL ，根据属性筛选服务
  -a, --all  ，显示所有已停止的容器(包括run命令创建的容器)

port暴露端口

docker-compose port [options] SERVICE PRIVATE_PORT
Options:
    --protocol=proto  tcp or udp [default: tcp]
    --index=index     index of the container if there are multiple
                      instances of a service [default: 1]

打印端口绑定的公共端口

例子：

docker-compose ps --services #找出服务名称

映射端口，并查询服务状态信息

ports暴露容器端口到主机的任意端口或指定端口，用法：

ports:

– “80:80” # 绑定容器的80端口到主机的80端口

– “9000:80” # 绑定容器的80端口到主机的9000端口

– “443” # 绑定容器的443端口到主机的任意端口，容器启动时随机分配绑定的主机端口号

不管是否指定主机端口，使用ports都会将端口暴露给主机和其他容器。

配置中的expose暴露端口

expose暴露容器给link到当前容器的容器，或者暴露给同一个networks的容器，用法：

expose:

– “3000”

– “8000”

以上指令将当前容器的端口3000和8000暴露给其他容器。

和ports的区别是，expose不会将端口暴露给主机，主机无法访问expose的端口。

docker-compose.yml配置

docker-compose.yml是配置应用程序需要的所有服务。

Compose和Docker兼容性：

Compose 文件格式有3个版本,分别为1, 2.x 和 3.x

目前主流的为 3.x 其支持 docker 1.13.0 及其以上的版本

version: '2'
services:
  web:
    image: dockercloud/hello-world
    ports:
      - 8080
    networks:
      - front-tier
      - back-tier
 
  redis:
    image: redis
    links:
      - web
    networks:
      - back-tier
 
  lb:
    image: dockercloud/haproxy
    ports:
      - 80:80
    links:
      - web
    networks:
      - front-tier
      - back-tier
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock 
 
networks:
  front-tier:
    driver: bridge
  back-tier:
driver: bridge

标准配置文件应该包含 version、services、networks 三大部分，其中最关键的就是 services 和 networks 两个部分，下面先来看 services 的书写规则。

1. image

1. services:
2. web:
3. image: hello-world

在 services 标签下的第二级标签是 web，这个名字是用户自己自定义，它就是服务名称。

image 则是指定服务的镜像名称或镜像 ID。如果镜像在本地不存在，Compose 将会尝试拉取这个镜像。

例如下面这些格式都是可以的：

1. image: redis
2. image: ubuntu:14.04
3. image: tutum/influxdb
4. image: example-registry.com:4000/postgresql
5. image: a4bc65fd

2. build

服务除了可以基于指定的镜像，还可以基于一份 Dockerfile，在使用 up 启动之时执行构建任务，这个构建标签就是 build，它可以指定 Dockerfile 所在文件夹的路径。Compose 将会利用它自动构建这个镜像，然后使用这个镜像启动服务容器。

1. build: /path/to/build/dir
2.

也可以是相对路径，只要上下文确定就可以读取到 Dockerfile。

build: ./dir

设定上下文根目录，然后以该目录为准指定 Dockerfile。

1. build:
2.   context: ../
3.   dockerfile: path/of/Dockerfile
4.

注意 build 都是一个目录，如果你要指定 Dockerfile 文件需要在 build 标签的子级标签中使用 dockerfile 标签指定，如上面的例子。

如果你同时指定了 image 和 build 两个标签，那么 Compose 会构建镜像并且把镜像命名为 image 后面的那个名字。

1. build: ./dir
2. image: webapp:tag

既然可以在 docker-compose.yml 中定义构建任务，那么一定少不了 arg 这个标签，就像 Dockerfile 中的 ARG 指令，它可以在构建过程中指定环境变量，但是在构建成功后取消，在 docker-compose.yml 文件中也支持这样的写法：

1. build:
2. context: .
3. args:
4. buildno: 1
5. password: secret

下面这种写法也是支持的，一般来说下面的写法更适合阅读。

1. build:
2. context: .
3. args:
4. - buildno=1
5. - password=secret

与 ENV 不同的是，ARG 是允许空值的。例如：

1. args:
2.   - buildno
3.   - password

这样构建过程可以向它们赋值。

注意：YAML 的布尔值（true, false, yes, no, on, off）必须要使用引号引起来（单引号、双引号均可），否则会当成字符串解析。

3. command

使用 command 可以覆盖容器启动后默认执行的命令。

command: bundle exec thin -p 3000

也可以写成类似 Dockerfile 中的格式：

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

4.container_name

前面说过 Compose 的容器名称格式是：<项目名称><服务名称><序号>

虽然可以自定义项目名称、服务名称，但是如果你想完全控制容器的命名，可以使用这个标签指定：

container_name: app

这样容器的名字就指定为 app 了。

5.depends_on

在使用 Compose 时，最大的好处就是少打启动命令，但是一般项目容器启动的顺序是有要求的，如果直接从上到下启动容器，必然会因为容器依赖问题而启动失败。

例如在没启动数据库容器的时候启动了应用容器，这时候应用容器会因为找不到数据库而退出，为了避免这种情况我们需要加入一个标签，就是 depends_on，这个标签解决了容器的依赖、启动先后的问题。

例如下面容器会先启动 redis 和 db 两个服务，最后才启动 web 服务：

1. version: '2'
2. services:
3.   web:
4.     build: .
5.     depends_on:
6.       - db
7.       - redis
8.   redis:
9.     image: redis
10.   db:
11.     image: postgres

注意的是，默认情况下使用 docker-compose up web 这样的方式启动 web 服务时，也会启动 redis 和 db 两个服务，因为在配置文件中定义了依赖关系。

6.dns

和 –dns 参数一样用途，格式如下：

1. dns: 8.8.8.8
2.

也可以是一个列表：

1. dns:
2.   - 8.8.8.8
3.   - 9.9.9.9
4.

此外 dns_search 的配置也类似：

1. dns_search: example.com
2. dns_search:
3.   - dc1.example.com
4.   - dc2.example.com
5.

7. tmpfs

挂载临时目录到容器内部，与 run 的参数一样效果：

1. tmpfs: /run
2. tmpfs:
3.   - /run
4.   - /tmp

8. entrypoint

在 Dockerfile 中有一个指令叫做 ENTRYPOINT 指令，用于指定接入点，第四章有对比过与 CMD 的区别。

在 docker-compose.yml 中可以定义接入点，覆盖 Dockerfile 中的定义：

1. entrypoint: /code/entrypoint.sh
2.

格式和 Docker 类似，不过还可以写成这样：

1. entrypoint:
2.     - php
3.     - -d
4.     - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
5.     - -d
6.     - memory_limit=-1
7.     - vendor/bin/phpunit
8.

9.env_file

还记得前面提到的 .env 文件吧，这个文件可以设置 Compose 的变量。而在 docker-compose.yml 中可以定义一个专门存放变量的文件。

如果通过 docker-compose -f FILE 指定了配置文件，则 env_file 中路径会使用配置文件路径。

如果有变量名称与 environment 指令冲突，则以后者为准。格式如下：

1. env_file: .env
2.

或者根据 docker-compose.yml 设置多个：

1. env_file:
2.   - ./common.env
3.   - ./apps/web.env
4.   - /opt/secrets.env
5.

注意的是这里所说的环境变量是对宿主机的 Compose 而言的，如果在配置文件中有 build 操作，这些变量并不会进入构建过程中，如果要在构建中使用变量还是首选前面刚讲的 arg 标签。

10. environment

与上面的 env_file 标签完全不同，反而和 arg 有几分类似，这个标签的作用是设置镜像变量，它可以保存变量到镜像里面，也就是说启动的容器也会包含这些变量设置，这是与 arg 最大的不同。

一般 arg 标签的变量仅用在构建过程中。而 environment 和 Dockerfile 中的 ENV 指令一样会把变量一直保存在镜像、容器中，类似 docker run -e 的效果。

1. environment:
2.   RACK_ENV: development
3.   SHOW: 'true'
4.   SESSION_SECRET:
5. 
6. environment:
7.   - RACK_ENV=development
8.   - SHOW=true
9.   - SESSION_SECRET

11. expose

这个标签与Dockerfile中的EXPOSE指令一样，用于指定暴露的端口，但是只是作为一种参考，实际上docker-compose.yml的端口映射还得ports这样的标签。

1. expose:
2.  - "3000"
3.  - "8000"

12. external_links

在使用Docker过程中，我们会有许多单独使用docker run启动的容器，为了使Compose能够连接这些不在docker-compose.yml中定义的容器，我们需要一个特殊的标签，就是external_links，它可以让Compose项目里面的容器连接到那些项目配置外部的容器（前提是外部容器中必须至少有一个容器是连接到与项目内的服务的同一个网络里面）。

格式如下：

1. external_links:
2.  - redis_1
3.  - project_db_1:mysql
4.  - project_db_1:postgresql
5.

13. extra_hosts

添加主机名的标签，就是往/etc/hosts文件中添加一些记录，与Docker client的–add-host类似：

1. extra_hosts:
2.  - "somehost:162.242.195.82"
3.  - "otherhost:50.31.209.229"

启动之后查看容器内部hosts：

1. 162.242.195.82  somehost
2. 50.31.209.229   otherhost
3.

14. labels

向容器添加元数据，和Dockerfile的LABEL指令一个意思，格式如下：

1. labels:
2.   com.example.description: "Accounting webapp"
3.   com.example.department: "Finance"
4.   com.example.label-with-empty-value: ""
5. labels:
6.   - "com.example.description=Accounting webapp"
7.   - "com.example.department=Finance"
8.   - "com.example.label-with-empty-value"
9.

15. links

还记得上面的depends_on吧，那个标签解决的是启动顺序问题，这个标签解决的是容器连接问题，与Docker client的–link一样效果，会连接到其它服务中的容器。

格式如下：

1. links:
2.  - db
3.  - db:database
4.  - redis
5.

使用的别名将会自动在服务容器中的/etc/hosts里创建。例如：

1. 172.12.2.186  db
2. 172.12.2.186  database
3. 172.12.2.187  redis
4.

相应的环境变量也将被创建。

16. logging

这个标签用于配置日志服务。格式如下：

1. logging:
2.   driver: syslog
3.   options:
4.     syslog-address: "tcp://192.168.0.42:123"

默认的driver是json-file。只有json-file和journald可以通过docker-compose logs显示日志，其他方式有其他日志查看方式，但目前Compose不支持。对于可选值可以使用options指定。

有关更多这方面的信息可以阅读官方文档：

https://docs.docker.com/engine/admin/logging/overview/

17. pid

pid: "host"

将PID模式设置为主机PID模式，跟主机系统共享进程命名空间。容器使用这个标签将能够访问和操纵其他容器和宿主机的名称空间。

18. ports

映射端口的标签。

使用HOST:CONTAINER格式或者只是指定容器的端口，宿主机会随机映射端口。

1. ports:
2.  - "3000"
3.  - "8000:8000"
4.  - "49100:22"
5.  - "127.0.0.1:8001:8001"
6.

注意：当使用HOST:CONTAINER格式来映射端口时，如果你使用的容器端口小于60你可能会得到错误得结果，因为YAML将会解析xx:yy这种数字格式为60进制。所以建议采用字符串格式。

19. security_opt

为每个容器覆盖默认的标签。简单说来就是管理全部服务的标签。比如设置全部服务的user标签值为USER。

1. security_opt:
2.   - label:user:USER
3.   - label:role:ROLE
4.

20. stop_signal

设置另一个信号来停止容器。在默认情况下使用的是SIGTERM停止容器。设置另一个信号可以使用stop_signal标签。

stop_signal: SIGUSR1

21. volumes

挂载一个目录或者一个已存在的数据卷容器，可以直接使用 [HOST:CONTAINER] 这样的格式，或者使用 [HOST:CONTAINER:ro] 这样的格式，后者对于容器来说，数据卷是只读的，这样可以有效保护宿主机的文件系统。

Compose的数据卷指定路径可以是相对路径，使用 . 或者 .. 来指定相对目录。

数据卷的格式可以是下面多种形式：

1. volumes:
2.   // 只是指定一个路径，Docker 会自动在创建一个数据卷（这个路径是容器内部的）。
3.   - /var/lib/mysql
4.  
5.   // 使用绝对路径挂载数据卷
6.   - /opt/data:/var/lib/mysql
7.  
8.   // 以 Compose 配置文件为中心的相对路径作为数据卷挂载到容器。
9.   - ./cache:/tmp/cache
10.  
11.   // 使用用户的相对路径（~/ 表示的目录是 /home/<用户目录>/ 或者 /root/）。
12.   - ~/configs:/etc/configs/:ro
13.  
14.   // 已经存在的命名的数据卷。
15.   - datavolume:/var/lib/mysql
16.

如果你不使用宿主机的路径，你可以指定一个volume_driver。

volume_driver: mydriver

22. volumes_from

从其它容器或者服务挂载数据卷，可选的参数是 :ro或者 :rw，前者表示容器只读，后者表示容器对数据卷是可读可写的。默认情况下是可读可写的。

1. volumes_from:
2.   - service_name
3.   - service_name:ro
4.   - container:container_name
5.   - container:container_name:rw
6.

23. cap_add, cap_drop

添加或删除容器的内核功能。详细信息在前面容器章节有讲解，此处不再赘述。

1. cap_add:
2.   - ALL
3. 
4. cap_drop:
5.   - NET_ADMIN
6.   - SYS_ADMIN

24. cgroup_parent

指定一个容器的父级cgroup。

cgroup_parent: m-executor-abcd

25. devices

设备映射列表。与Docker client的–device参数类似。

1. devices:
2.   - "/dev/ttyUSB0:/dev/ttyUSB0"

26. extends

这个标签可以扩展另一个服务，扩展内容可以是来自在当前文件，也可以是来自其他文件，相同服务的情况下，后来者会有选择地覆盖原有配置。

1. extends:
2.   file: common.yml
3.   service: webapp
4.

用户可以在任何地方使用这个标签，只要标签内容包含file和service两个值就可以了。file的值可以是相对或者绝对路径，如果不指定file的值，那么Compose会读取当前YML文件的信息。

更多的操作细节在后面的12.3.4小节有介绍。

27. network_mode

网络模式，与Docker client的–net参数类似，只是相对多了一个service:[service name] 的格式。

例如：

1. network_mode: "bridge"
2. network_mode: "host"
3. network_mode: "none"
4. network_mode: "service:[service name]"
5. network_mode: "container:[container name/id]"

可以指定使用服务或者容器的网络。

28. networks

加入指定网络，格式如下：

1. services:
2. some-service:
3. networks:
4.      - some-network
5.      - other-network

关于这个标签还有一个特别的子标签aliases，这是一个用来设置服务别名的标签，例如：

1. services:
2. some-service:
3. networks:
4. some-network:
5. aliases:
6.          - alias1
7.          - alias3
8. other-network:
9. aliases:
10.          - alias2

相同的服务可以在不同的网络有不同的别名。

29. 其它

还有这些标签：cpu_shares, cpu_quota, cpuset, domainname, hostname, ipc, mac_address, mem_limit, memswap_limit, privileged, read_only, restart, shm_size, stdin_open, tty, user, working_dir

上面这些都是一个单值的标签，类似于使用docker run的效果。

cpu_shares: 73
cpu_quota: 50000
cpuset: 0,1
 
user: postgresql
working_dir: /code
 
domainname: foo.com
hostname: foo
ipc: host
mac_address: 02:42:ac:11:65:43
 
mem_limit: 1000000000
memswap_limit: 2000000000
privileged: true
 
restart: always
 
read_only: true
shm_size: 64M
stdin_open: true
tty: true