一篇文章学会docker

HemingwayM

2020-03-28

一篇文章学会docker

docker安装

docker在线安装

1.更新yum到最新

yum update

2.卸载旧版本

sudo yum remove docker             docker-client             docker-client-latest             docker-common             docker-latest             docker-latest-logrotate             docker-logrotate             docker-selinux             docker-engine-selinux             docker-engine

3.安装需要的软件包，yum-util提供yum-config-manager功能

yum install -y yum-utils device-mapper-persistent-data lvm2

3.设置yum仓库

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

4.安装docker，默认y确认

yum install -y docker-ce

5.启动并查看docker版本

systemctl start docker
docker -v

离线安装

1.下载好docker的离线二进制包

wget https://download.docker.com/linux/static/stable/x86_64/docker-18.06.3-ce.tgz

2.解压docker，并将所有docker下所有内容已到/usr/bin目录下

tar -zxvf docker-18.06.3-ce.tgz
sudo cp docker/* /usr/bin

3.开启docker服务

sudo dockerd &

4.现在你可以尝试着打印下版本号，试着看看 images，看看 info

sudo docker --version

5.docker命令不需要敲sudo的方法

sudo groupadd docker
sudo usermod -aG docker 用户名

6.绑定docker仓库ip和端口

sudo vim /etc/docker/daemon.json
{ "insecure-registries":["ip:port"] }

7.注册docker为service服务

注册后可以通过systemclt来管理socker服务

systemctl start/stop/restart/ docker

将以下内容写入/etc/systemd/system/docker.service中（没有该文件则新建）。

vim /etc/systemd/system/docker.service

[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target
[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
# Uncomment TasksMax if your systemd version supports it.
# Only systemd 226 and above support this version.
#TasksMax=infinity
TimeoutStartSec=0
# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes
# kill only the docker process, not all processes in the cgroup
KillMode=process
# restart the docker process if it exits prematurely
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s
[Install]
WantedBy=multi-user.target

8.修改文件为可执行文件

chmod +x /etc/systemd/system/docker.service #添加文件权限

9.启动docker

systemctl daemon-reload #重载unit配置文件
systemctl start docker #启动Docker
systemctl enable docker.service #设置开机自启

docker架构

一篇文章学会docker

docker三个基本概念

镜像images：docker镜像（image），相当于一个root文件系统，如官方镜像ubuntu:16.04，包含了ubuntu:16.04完整的最小的root文件系统。
容器container：镜像（image）和容器（container）的关系，好比面向对象中类和对象的关系。镜像是静态的定义，容器是镜像实例化的实体。
仓库repository：仓库（repository）可以看作一个代码管理中心，用来保存镜像。

配置docker镜像加速器

Docker Registry 公开服务是开放给用户使用、允许用户管理镜像的 Registry 服务。

最常使用的 Registry 公开服务是官方的 Docker Hub，这也是默认的 Registry，并拥有大量的高质量的官方镜像。

从Docker Hub下载docker镜像，比较慢，一般会配置镜像加速器：

1.daocloud加速器

终端执行：

curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

这个命令是修改/etc/docker/daemon.json文件,写入一个json数据如下

[ ~]# cat /etc/docker/daemon.json
{"registry-mirrors": ["http://f1361db2.m.daocloud.io"]}# 配置好了docker加速器,下载镜像就快很多了

注意：有的人使用这个命令后会出问题，这个问题可以通过修改这个json文本，去掉最后的逗号，即可。

2.阿里云加速器

通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-‘EOF‘
{
  "registry-mirrors": ["https://jaqjblse.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

镜像加速地址，通过登录阿里云服务搜索得到。

docker操作命令

docker服务相关命令

1.启动docker服务

systemctl start docker

2.停止docker服务

systemctl stop docker

3.重启docker服务

systemctl restart docker

4.查看docker服务状态

systemctl status docker

5.开机自启动docker

systemctl enable docker

docker镜像相关命令

docker镜像命令如下几类：

1.查看镜像

docker images
docker images -q # 查看所有的镜像id

2.搜索镜像

docker search 镜像名称

3.拉取镜像

docker pull 镜像名[:版本]
docker pull centos:7

可以指定版本，版本号取hub仓库查找：hub.docker.com

4.删除镜像

docker rmi 容器id/容器名  # 删除指定本地镜像
docker rmi `docker images -q`  # 删除所有本地镜像

docker容器相关命令

1.查看容器

docker ps  # 查看正在运行的容器
docker ps -a  # 查看所有容器，包括停止的

2.创建并启动容器

docker run 参数

参数说明

-i：interactive-交互式，保持容器运行，与-t同时使用，-it创建容器并进入，退出后，容器自动关闭
-t：terminate-终端，为容器分配一个伪终端，通常与-i同时使用
-d：daemon-守护，以守护（后台）模型运行容器，使用docker exec 进入容器
-it：创建交互式容器，-id：创建守护式容器
--name：为创建的容器命名

3.进入容器

docker exec 参数 容器名  # 退出容器，容器不会关闭

4.停止容器

docker stop 容器名

5.删除容器，运行状态需要先停止在删除

docker rm 容器名

6.查看容器信息

docker inspect 容器名

容器的数据卷

数据卷概念

1.数据卷：宿主机中的一个目录或文件

宿主机和容器中映射的文件夹，或者文件

一篇文章学会docker

2.数据卷的特点

数据卷目录和容器目录绑定是，目录的修改对宿主机和容器是同步的
一个数据卷可以被多个容器同时挂载
一个容器也可以挂载多个数据卷

3.数据卷作用

容器数据持久化
外部机器和容器间通信
容器之间数据交换

配置数据卷

1.创建容器时，使用-v参数设置数据卷

docker run ... -v 宿主机目录（文件）:容器内目录（文件）

注意：

目录必须是绝对路径
如果目录不存在，会自动创建
可以挂载多个数据卷

数据卷容器

多个容器进行数据交换

多个容器挂载数据卷同一个数据卷
数据卷容器

一篇文章学会docker

配置数据卷容器

1.创建启动c3数据卷容器，使用-v设置数据卷

docker run -it --name=c3 -v /volume centos /bin/bash

2.创建启动c1,c2容器，使用 --volumes-from 参数设置数据卷

docker run -it --name=c1 --volumns-from c3 centos /bin/bash
docker run -it --name=c2 --volumns-from c3 centos /bin/bash

作用：

创建一个容器，挂载一个目录，让其他容器继承该容器（--volumn-from）
通过简单的方式实现数据卷配置

docker端口映射

1.概念

容器内的网络服务和外部机器不能直接通信，但是外部机器可以和宿主机直接通信，这样就需要通过宿主机搭建桥梁。

让容器中的网络服务需要被外部机器访问是，可以将容器中提供服务的端口映射到宿主机的端口上，外部机器访问宿主机的该端口是，间接访问容器的服务，这个就被称作：端口映射

端口映射通过-p参数指定

2.实现端口映射

docker -run ... -p 宿主机port:容器中port 容器名

docker应用部署实例

docker部署mysql

实现docker容器中部署mysql，并通过外部mysql客户端操作mysql server

1.搜索myslq镜像

docker search mysql

2.拉取mysql镜像

docker pull mysql:5.6

3.创建容器，设置端口映射，目录映射

root目录下创建/data/mysql

mkdir -p /opt/mysql
cd /opt/mysql

运行容器

docker run -id -p 3307:3306 --name c_mysql -v $PWD/conf:/etc/mysql/conf.d -v $PWD/logs:/logs -v $PWD/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.6

参数说明

-p 3307:3306，容器3306映射到宿主机3307
-v $PWD/conf:/etc/mysql/conf.d，当前路径下/conf挂载到容器/etc/mysql/conf.d
-v $PWD/logs:/logs，当前路径下/conf挂载到容器/logs
-v $PWD/data:/var/lib/mysql，当前路径下/conf挂载到容器/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456，初始root密码 -e 配置环境变量

docker部署tomcat

1.搜索tomcat镜像

docker search tomcat

2.拉取tomcat镜像

docker pull tomcat

3.创建容器，设置端口映射，目录映射

root目录下创建/opt/tomcat

mkdir -p /opt/tomcat
cd /opt/tomcat

运行容器

docker run -id -p 8080:8080 --name c_tomcat -v $PWD:/usr/local/tomcat/webapps tomcat

参数说明

-p 8080:8080，容器8080映射到宿主机8080
-v $PWD/:/usr/local/tomcat/webapps，当前路径下/conf挂载到容器webapps

docker部署nginx

实现docker容器中部署mysql，并通过外部mysql客户端操作mysql server

1.搜索nginx镜像

docker search nginx

2.拉取nginx镜像

docker pull nginx

3.创建容器，设置端口映射，目录映射

root目录下创建/data/mysql

mkdir -p /opt/nginx
cd /opt/nginx
mkdir conf

拷贝nginx官方配置文件，写入/opt/nginx/conf/nginx.conf

#user  nobody;
#nginx进程，一般数值为cpu核数
worker_processes  1;
#错误日志存放目录
#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;
#进程pid存放位置
#pid        logs/nginx.pid;

#工作模式及连接数上限
events {
    #单个后台worker process进程的最大并发链接数
    worker_connections  1024;
}


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"‘;
    #nginx访问日志
    #access_log  logs/access.log  main;
    #开启高效传输模式   
    sendfile        on;
    #激活tcp_nopush参数可以允许把httpresponse header和文件的开始放在一个文件里发布， 积极的作用是减少网络报文段的数量
    #tcp_nopush     on;
    #连接超时时间，单位是秒
    #keepalive_timeout  0;
    keepalive_timeout  65;
    #开启gzip压缩功能
    #gzip  on;
    
    #基于域名的虚拟主机
    server {
        #监听端口
        listen       80;
        server_name  localhost;
        #编码识别
        #charset koi8-r;
        #日志格式及日志存放路径
        #access_log  logs/host.access.log  main;

        location / {
            #站点根目录，即网站程序存放目录 
            root   html;
            #首页排序
            index  index.html index.htm;
        }
        #错误页面
        #error_page  404              /404.html;
        # 将服务器错误页面重定向到静态页面/50x.html
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }        

       
        #代理PHP脚本到Apache上监听127.0.0.1:80
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

   
        #将PHP脚本传递到正在监听127.0.0.1:9000的FastCGI服务器
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        #如果Apache的文档根目录与nginx的根目录一致，则拒绝访问.htaccess文件
        #location ~ /\.ht {
        #    deny  all;
        #}
    }



    #另一个虚拟主机，混合使用IP、名称和基于端口的配置
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;
    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;
    #    服务的证书
    #    ssl_certificate      cert.pem;
    #    服务端key
    #    ssl_certificate_key  cert.key;
    #    会话缓存
    #    ssl_session_cache    shared:SSL:1m;
    #    会话超时时间
    #    ssl_session_timeout  5m;
    #    #加密算法
    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    启动加密算法
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}
}

运行容器

docker run -id -p 80:80 --name c_nginx -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf -v $PWD/logs:/var/log/nginx -v $PWD/html:/usr/share/nginx/html nginx

参数说明

-p 80:80，容器80映射到宿主机80
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf，挂载配置文件到容器

docker部署redis

1.搜索redis镜像

docker search redis

2.拉取redis镜像

docker pull redis

3.创建容器，设置端口映射，目录映射

运行容器

docker run -id -p 6379:6379 --name c_redis redis:5.0

4.外部链接redis服务

./redis-cli.exe -h ip -p port

docker镜像原理

1.操作系统重要的组成部分：文件管理子系统。而linux文件系统有bootfs和rootfs两部分组成：

bootfs：包含bootloader（引导加载程序）和kernel（内核）
rootfs：root文件系统，包含的就是典型Linux系统中的/dev，/proc，/etc

一篇文章学会docker

2.docker镜像是由特殊的文件系统叠加而成

最底层是bootfs，并使用宿主机的bootfs
第二层是root文件系统rootfs，成为base image
在往上叠加其他镜像文件

3.docker镜像的特点

统一的文件系统，隐藏了很多层的存在，用户看来，只存在一个文件系统。
一个镜像放在另一个镜像上，下面的称为父镜像，最底层称为基础镜像。
当一个镜像容器启动，docker在会在顶层加载一个读写文件系统作为容器

一篇文章学会docker

4.小结

docker镜像本质：一个分层的文件系统，能够不断复用，

centos镜像比操作系统iso小很多，是因为对rootfs的复用。

tomcat镜像比安装包大很多，是因为有很多依赖父镜像和基础镜像。

Docker镜像制作

1.容器转镜像

在已存在的镜像中做修改，最终提交为新的镜像

docker commit 容器id 镜像名称:版本号

还可以将镜像压缩为文件，进行传输。

docker save -o 压缩文件名 镜像名称:版本号

将文件解压为镜像

docker load -i 压缩文件名

注意：通过这种方式生成的容器，目录挂载的地方不会改变，其他位置都会改变。

2.dockerfile制作镜像*

dockerfile是一个文件，包含了一条条指令，每一条指令构建一层，基于基础镜像，最终构建一个新镜像。

3.dockerfile命令

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基础镜像
MAINTAINER	作者信息	标识dockerfile作者
LABEL	标签	docker标签，可代替maintainer
RUN	执行命令	指定一段命令，默认`/bin/sh`；RUN commond或RUN["commond", "param1", "param2"]
CMD	容器启动命令	容器启动时候的默认命令，格式CMD command p1 p2
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中使用
COPY	复制文件	build的时候复制文件到images中
ADD	添加文件	build的时候添加到images，另含解压作用，来源可以是远程服务
ENV	环境变量	指定build时候的环境变量，在容器时可以通过 `-e` 格式name=value覆盖
ARG	构建参数	在构建的时候使用的参数，ENV中相同名字的值始终覆盖arg的参数
VOLUME	定义外部挂载数据卷	指定build的image那些目录可以挂载到文件系统中，启动时使用-v格式绑定。
EXPOSE	暴露端口	定义容器运行监听的端口，启动容器时使用-p来绑定，EXPOST 8080
WORKDIR	工作目录	指定容器内部工作目录，没有的则自动创建，“/”开头是绝对路径，不是“/”开头，则是workdir路径的相对路径
USER	指定指定用户	指定build或者启动容器时，在 RUN COM ENTRYPOINT执行的时候的用户
HEALTHCHECK	检查健康	指定检测当前容器的健康检测的命令，基本没用
ONBUILD	触发器	存在ONBUILD关键字的镜像作基础镜像的时候，当指定FROM完成之后，会指定ONBUILD的命令，用处不大
STOPSINGNAL	发送信号到宿主机	STOPSINGNAL指令设置将发送到容器的系统调用信号以退出
SHELL	指定执行脚本的shell	指定RUN COM ENTRYPOINT执行命令的时候，使用的shell

4.dockerfile制作镜像例子

vim centos_dockerfiles
# 1.定义父镜像
FROM centos:7
# 2.指定作者信息
MAINTAINER ryxiong <ryxiong.com>
# 3.执行安装vim命令
RUN yum install -y vim
# 4.定义默认工作目录
WORKDIR /usr
# 5.定义容器启动执行的命令
CMD /bin/bash

制作命令

docker build -f ./centos_dockerfiles -t centos:1.0 .

-f 指定dockerfile文件
-t 执行镜像名字

案例-django项目docker部署

1.准备django运行的环境基础镜像

[ ~]$ docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
django               1.0                 ba0aa44992b1        9 hours ago         372MB

2.准备django项目工程文件

django-test

3.编写dockerfile文件

FROM django:1.0
MAINTAINER ryxiong
ADD ./django-test  # 当前路径的django工程
CD ./django-test  # 进入工程文件根目录
CMD python3 manage.py runserver

4.打包项目镜像

docker build -f ./dockerfile -t web:1.0 .

5.根据项目镜像启动容器

docker run -id -p 9000:8000 web:1.0

6.查看项目容器状态

docker ps

Docker服务编排

docker-compose

1.背景

微服务架构中应用系统包含若干个微服务，每个微服务部署多个实例，每个微服务手动启停，维护工作巨大。

Dockerfile build image 或 docker pull image
创建多个container
管理多个container（启动停止）

2.服务编排

按照一定的业务规则批量管理容器

3.docker-compose工具

Docker-compose是一个编排多容器分布式部署的工具，提供命令集中管理容器化应用的完整开发周期，包括服务构建，启动和停止，使用方法：

利用dockerfile定义运行环境镜像
使用docker-compose.yml定义组成应用的各服务
运行docker-compose up 启动应用

一篇文章学会docker

4.docker-compose安装

docker-compose是基于docker，安装之前，需要先安装docker，docker-compose以编译好的二进制包方式安装在linux中。

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

其他版本替换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

docker-compose的卸载

rm /usr/local/bin/docker-compose

docker-compose部署项目案例

1.创建测试项目

$ mkdir composetest
$ cd composetest

编写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

5.yml配置指令参考

build

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

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

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

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 模式的运行情况。

environment

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

environment:
  RACK_ENV: development
  SHOW: ‘true‘

expose

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

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

expose:
 - "3000"
 - "8000"

image

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

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

volumes

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

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

docker私有仓库

搭建私有仓库

1.拉取私有仓库镜像

docker pull registry

2.启动私有仓库

docker run -id --name registry -p 5000:5000 registry

3.验证私有仓库

打开浏览器，输入http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]}表示搭建成功

4.修改daemon.json

vim /etc/docker/daemon.json

添加key，信任私有仓库地址，写入自己私有仓库真实ip

{"insecure-registries":["私有仓库服务器ip:5000"]}

私有仓库上传和拉取

1.标记镜像为私有仓库镜像

docker tag centos:7 私有仓库ip:5000/centos:7

2.上传标记的镜像

docker push 私有仓库ip:5000/centos:7

3.拉取到本地

docker pull 私有仓库ip:5000/centos:7

Docker-machine

简介

Docker Machine 是一种让您在虚拟主机上安装 Docker 的工具，并可以使用 docker-machine 命令来管理主机。

Docker Machine 功能

集中管理所有的 docker 主机
启动，检查，停止和重新启动托管主机
升级 Docker 客户端和守护程序
配置 Docker 客户端与主机进行通信

一篇文章学会docker

安装

安装 Docker Machine 之前你需要先安装 Docker

Linux 安装命令

base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine &&
  sudo mv /tmp/docker-machine /usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine

macOS 安装命令

base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine

Windows 安装命令

如果你是 Windows 平台，可以使用 Git BASH，并输入以下命令：

base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  mkdir -p "$HOME/bin" &&
  curl -L $base/docker-machine-Windows-x86_64.exe > "$HOME/bin/docker-machine.exe" &&
  chmod +x "$HOME/bin/docker-machine.exe"

查看是否安装成功：

docker-machine version
docker-machine version 0.16.0, build 9371605

使用

1.列出可用机器，默认有default虚拟机

docker-machine ls

2.创建机器

创建一个名为test的机器

$ docker-machine create --driver virtualbox test

--driver：指定用来创建机器的驱动类型，这里是 virtualbox

3.查看机器ip

docker-machine ip test

4.停止机器

docker-machine stop test

5.启动机器

docker-machine start test

6.进入机器

docker-machine ssh test

docker-machine 命令参数说明

docker-machine active：查看当前激活状态的 Docker 主机。

docker-machine ls

NAME      ACTIVE   DRIVER         STATE     URL
dev       -        virtualbox     Running   tcp://192.168.99.103:2376
staging   *        digitalocean   Running   tcp://203.0.113.81:2376

echo $DOCKER_HOST
tcp://203.0.113.81:2376

docker-machine active
staging

config：查看当前激活状态 Docker 主机的连接信息。
creat：创建 Docker 主机
env：显示连接到某个主机需要的环境变量
inspect：以 json 格式输出指定Docker的详细信息
ip：获取指定 Docker 主机的地址
kill：直接杀死指定的 Docker 主机
ls：列出所有的管理主机
provision：重新配置指定主机
regenerate-certs：为某个主机重新生成 TLS 信息
restart：重启指定的主机
rm：删除某台 Docker 主机，对应的虚拟机也会被删除
ssh：通过 SSH 连接到主机上，执行命令
scp：在 Docker 主机之间以及 Docker 主机和本地主机之间通过 scp 远程复制数据
mount：使用 SSHFS 从计算机装载或卸载目录
start：启动一个指定的 Docker 主机，如果对象是个虚拟机，该虚拟机将被启动
status：获取指定 Docker 主机的状态(包括：Running、Paused、Saved、Stopped、Stopping、Starting、Error)等
stop：停止一个指定的 Docker 主机
upgrade：将一个指定主机的 Docker 版本更新为最新
url：获取指定 Docker 主机的监听 URL
version：显示 Docker Machine 的版本或者主机 Docker 版本
help：显示帮助信息

Swarm 集群管理

简介

Docker Swarm 是 Docker 的集群管理工具。它将 Docker 主机池转变为单个虚拟 Docker 主机。 Docker Swarm 提供了标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 轻松地扩展到多个主机。

支持的工具包括但不限于以下各项：

Dokku
Docker Compose
Docker Machine
Jenkins

原理

如下图所示，swarm 集群由管理节点（manager）和工作节点（work node）构成。

swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。
work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。

使用

1.创建 swarm 集群管理节点（manager）

docker-machine create -d virtualbox swarm-manager

初始化 swarm 集群，进行初始化的这台机器，就是集群的管理节点。

docker-machine ssh swarm-manager
docker swarm init --advertise-addr 192.168.99.107 #这里的 IP 为创建机器时分配的 ip。

成功会输出一段命令，在增加工作节点时会用到：

docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377

2.创建swarm 集群工作节点（worker）

这里直接创建好俩台机器，swarm-worker1 和 swarm-worker2

docker-machine create -d virtualbox swarm-worker1
docker-machine create -d virtualbox swarm-worker2

分别进入俩个机器里，指定添加至上一步中创建的集群，这里会用到上一步复制的内容。

docker-machine ssh swarm-worker1
docker swarm join --token SWMTKN-1-4oogo9qziq768dma0uh3j0z0m5twlm10iynvz7ixza96k6jh9p-ajkb6w7qd06y1e33yrgko64sk 192.168.99.107:2377

3.查看集群信息

docker info

4.部署服务到集群中

注意：跟集群管理有关的任何操作，都是在管理节点上操作的。

以下例子，在一个工作节点上创建一个名为 helloworld 的服务，这里是随机指派给一个工作节点

:~$ docker service create --replicas 1 --name helloworld alpine ping docker.com

5.查看服务部署情况

:~$ docker service create --replicas 1 --name helloworld alpine ping docker.com

查看 helloworld 部署的具体信息：

:~$ docker service inspect --pretty helloworld

6.扩展集群服务

:~$ docker service scale helloworld=2

服务已经从一个节点，扩展到两个节点

7.删除服务

:~$ docker service rm helloworld

确认是否删除

docker service ps helloworld

8.滚动升级服务

将 redis 版本滚动升级至更高版本

创建一个 3.0.6 版本的 redis。

:~$ docker service create --replicas 1 --name redis --update-delay 10s redis:3.0.6

滚动升级 redis 。

:~$ docker service update --image redis:3.0.7 redis

9.停止某个节点接收新的任务

查看所有的节点：

:~$ docker node ls

可以看到目前所有的节点都是 Active, 可以接收新的任务分配。

停止节点 swarm-worker1

:~$  docker node update --availability drain swarm-worker1

注意：swarm-worker1 状态变为 Drain。不会影响到集群的服务，只是 swarm-worker1 节点不再接收新的任务，集群的负载能力有所下降。

重新激活节点

:~$  docker node update --availability active swarm-worker1

docker-stack集群管理

docker stack deploy命令用于部署新的堆栈或更新现有堆栈。从群集中的compose文件或dab文件创建和更新堆栈，必须以管理员节点为目标运行此命令。

用法

docker stack deploy [OPTIONS] STACK

参数

名称，简写	默认	说明
`--bundle-file`		分布式应用程序包文件的路径
`--compose-file, -c`		Compose 文件的路径
`--with-registry-auth`	`false`	将注册表身份验证详细信息发送给Swarm代理

命令	描述
`docker stack deploy`	部署新的堆栈或更新现有堆栈
`docker stack ls`	列出现有堆栈
`docker stack ps`	列出堆栈中的任务
`docker stack rm`	删除堆栈
`docker stack services`	列出堆栈中的服务

示例

Compose 文件

deploy命令支持3.0及更高版本的Compose文件。

$ docker stack deploy --compose-file docker-compose.yml vossibility

Ignoring unsupported options: links

Creating network vossibility_vossibility
Creating network vossibility_default
Creating service vossibility_nsqd
Creating service vossibility_logstash
Creating service vossibility_elasticsearch
Creating service vossibility_kibana
Creating service vossibility_ghollector
Creating service vossibility_lookupd

您可以验证服务是否正确创建 -

$ docker service ls

ID            NAME                               MODE        REPLICAS  IMAGE
29bv0vnlm903  vossibility_lookupd                replicated  1/1       nsqio/:eeba05599f31eba418e96e71e0984c3dc96963ceb66924dd37a47bf7ce18a662
4awt47624qwh  vossibility_nsqd                   replicated  1/1       nsqio/:eeba05599f31eba418e96e71e0984c3dc96963ceb66924dd37a47bf7ce18a662
4tjx9biia6fs  vossibility_elasticsearch          replicated  1/1       :12ac7c6af55d001f71800b83ba91a04f716e58d82e748fa6e5a7359eed2301aa
7563uuzr9eys  vossibility_kibana                 replicated  1/1       :6995a2d25709a62694a937b8a529ff36da92ebee74bafd7bf00e6caf6db2eb03
9gc5m4met4he  vossibility_logstash               replicated  1/1       :2dc8bddd1bb4a5a34e8ebaf73749f6413c101b2edef6617f2f7713926d2141fe
axqh55ipl40h  vossibility_vossibility-collector  replicated  1/1       icecrime/:f03f2977203ba6253988c18d04061c5ec7aab46bca9dfd89a9a1fa4500989fba

DAB文件

$ docker stack deploy --bundle-file vossibility-stack.dab vossibility

Loading bundle from vossibility-stack.dab
Creating service vossibility_elasticsearch
Creating service vossibility_kibana
Creating service vossibility_logstash
Creating service vossibility_lookupd
Creating service vossibility_nsqd
Creating service vossibility_vossibility-collector

您可以验证服务是否正确创建 -

$ docker service ls

ID            NAME                               MODE        REPLICAS  IMAGE
29bv0vnlm903  vossibility_lookupd                replicated  1/1       nsqio/:eeba05599f31eba418e96e71e0984c3dc96963ceb66924dd37a47bf7ce18a662
4awt47624qwh  vossibility_nsqd                   replicated  1/1       nsqio/:eeba05599f31eba418e96e71e0984c3dc96963ceb66924dd37a47bf7ce18a662
4tjx9biia6fs  vossibility_elasticsearch          replicated  1/1       :12ac7c6af55d001f71800b83ba91a04f716e58d82e748fa6e5a7359eed2301aa
7563uuzr9eys  vossibility_kibana                 replicated  1/1       :6995a2d25709a62694a937b8a529ff36da92ebee74bafd7bf00e6caf6db2eb03
9gc5m4met4he  vossibility_logstash               replicated  1/1       :2dc8bddd1bb4a5a34e8ebaf73749f6413c101b2edef6617f2f7713926d2141fe
axqh55ipl40h  vossibility_vossibility-collector  replicated  1/1       icecrime/:f03f2977203ba6253988c18d04061c5ec7aab46bca9dfd89a9a1fa4500989fba

HemingwayM

0 关注 0 粉丝 0 动态

关注关注

安科网

一篇文章学会docker

HemingwayM

一篇文章学会docker

docker安装

docker在线安装

离线安装

docker架构

配置docker镜像加速器

docker操作命令

docker服务相关命令

docker镜像相关命令

docker容器相关命令

容器的数据卷

docker端口映射

docker应用部署实例

docker部署mysql

docker部署tomcat

docker部署nginx

docker部署redis

docker镜像原理

Docker镜像制作

案例-django项目docker部署

Docker服务编排

docker-compose

docker-compose部署项目案例

1.创建测试项目

2.创建dockerfile文件

3.创建 docker-compose.yml

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

5.yml配置指令参考

build

depends_on

deploy

environment

expose

image

volumes

docker私有仓库

搭建私有仓库

私有仓库上传和拉取

Docker-machine

简介

安装

使用

docker-machine 命令参数说明

Swarm 集群管理

简介

原理

使用

docker-stack集群管理

示例

HemingwayM

HemingwayM