docker使用

• 1 docker介绍，跟传统虚拟机的比较
• 2 docker架构图
• 3 docker安装
• 3.1 windows安装
• 3.2 乌班图
• 3.3 centos上安装（必须7.0以上）
• 3.4 远程仓库
• 4 镜像操作
• 5 容器操作
• 6 应用部署
• 1 部署应用映射外部目录
• 2 迁移与备份
• 2.0 其他操作
• 2.1 容器保存为镜像
• 2.2 把镜像打包成压缩包
• 2.3 把压缩包回复为镜像
• 3 dockerfile(很重要)
• 4 私有仓库
• 步骤
• 5 docker-compose
• 5.1 部署多应用
• docker-compose.yml 如何写
• docker-compose命令
• 6 多个容器直接通信方式

docker内容
1 docker介绍，跟传统虚拟机的比较
2 安装docker，启动
3 镜像
4 容器
5 网络
6 数据卷
7 私有仓库
8 备份回顾
9 dockerfile
10 单机容器编排 docker-compose

1 docker介绍，跟传统虚拟机的比较

0 各种软件用什么语言写的
    zabbix（监控软件）：php
    ansible（批量管理主机，执行命令,无angent）：python
    openstack（云计算，管理虚拟机）：python
    jekins（ci/di）：自动化部署，java
    salstack(批量管理主机，执行命令，有angent):python
    普罗米修斯（Prometheus，监控）：go写的
    docker：go
    k8s：go

1 什么是虚拟化?
    -vmware,kvm,openstack,docker,k8s
    -云服务器：vmware,kvm虚拟化出来的
    -阿里云，腾讯云：opensatck，阿里飞天，用来管理虚拟化出来的操作系统
    -docker：进程级别的隔离，装在虚拟机，云服务器上，一个云服务上开业跑出成几百个docker容器，成百上千的服务器上，就会有个上万个容器
    -k8s：不同机器的上万个容器如何管理

    -虚拟化：打破实体结构间的不可切割的障碍

2 什么是Docker？
    - Go语言实现，开源出来，很多人用
    - docker-ce（免费），docker-ee（收费）
    - 通过go语言对lxc技术的一个封装
    -上手快，简单
3 容器与虚拟机比较
    -docker不需要虚拟硬件和操作系统，轻量级，占用体积小，启动快

4 Docker是一个客户端-服务器（C/S）架构程序（mysql，redis都是cs架构），整套RESTful API

5 docker非常重要的概念：镜像（image）与容器（container）
    有了镜像---》镜像运行起来是容器（真正的执行单位）
    面向对象的类     对象
6 镜像是从哪里来的？
    -镜像就是一堆文件
    -从远程仓库获取（拉取）

2 docker架构图

3 docker安装

3.1 windows安装

1 windows安装（不建议你装）http://get.daocloud.io/

3.2 乌班图

0 卸载
sudo apt-get remove docker docker-engine docker.io containerd runc
1 安装必要工具
sudo apt-get update
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common
2 安装GPG证书
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
#换成阿里云
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
2 写入软件源信息
#官方
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
#换成阿里云
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

3 更新并安装docker-ce
sudo apt-get -y install docker-ce
4 开启docker服务
 systemctl status docker

3.3 centos上安装（必须7.0以上）

6.8安装docker，自行搜索，升级内核版本
docker是在linux3.1以上内核中写出来的，在乌班图下开发的，docker的新特性，乌班图先看到，
官方建议docker运行在centos7 以上的系统

#####安装
0 卸载
yum remove docker docker-common  docker-selinux docker-engine
rm -rf /var/lib/docker

1 更新yum
yum update
2 安装需要的软件包， yum-util
yum install -y yum-utils device-mapper-persistent-data lvm2
3 执行（向你的yum源，增加一条记录）
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4 安装
yum install docker-ce

5 验证安装（查看版本）
docker -v
~]# docker -v  （19年03月12日发布）
自从分了docker-ce和docker-ee以后，以年份命名版本
Docker version 19.03.12, build 48a66213fe

6 启动docker服务
systemctl start docker

7 停止docker服务，重启docker服务
systemctl stop docker
systemctl restart docker

8 开机启动
systemctl enable docker

9 查看概要信息
docker info（你可能写了一个管理docker的运维平台）

3.4 远程仓库

注册，登录 https://hub.docker.com/
你可以上传镜像（类似于github），你把你制作的镜像传上去，别人可以下载使用

配置加速（之前去https://hub.docker.com/），阿里云，清华，做了一个备份，配置好以后，再拉镜像会去国内地址拉取
第一步：vi /etc/docker/daemon.json
第二步：
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

4 镜像操作

-1 第一个hello-world（没有任何意义）
    docker run hello-world
    1 客户端连到服务端，服务下载了hello-world镜像
    2 通过镜像跑起容器来
    3 容器输出一些东西，通过服务端发送给客户端，客户端展示在窗口里了

0 查找镜像
    方式一：https://hub.docker.com/ 点点点搜索（你用这种）
    方式二：docker search
1 拉取镜像
    docker pull hello-world  最新版本latest
    docker pull hello-world:nanoserver
2 查看机器上有哪些镜像
    docker images
    REPOSITORY  TAG   IMAGE ID   CREATED   SIZE
    镜像名字      版本   id号       创建时间   大小
3 删除镜像
    docker rmi 镜像名字/id号（# 如果还有基于这个镜像的容器，是不允许删除镜像的，先删除容器，再删除images）

    docker ps -a  查看镜像的生成的容器
    docker rm id  删除容器

4 练习：拉取python3.6镜像，redis最新镜像，mysql5.7镜像
    docker pull python:3.6
    docker pull redis
    docker pull mysql:5.7
    docker pull centos:centos7

5 镜像是什么？
    -就是一堆文件，这堆文件通过docker跑起来，就是容器，你现在就把他当成，一个操作系统内跑了这个软件（centos+redis）
    -假设centos7的镜像跑起来，容器你就当成在你宿主机上跑了一个centos7的操作系统（虚拟机）

 6 补充（了解）
    docker image inspect 46ff56815c7c
    docker image ls
    docker image rm

5 容器操作

1 删除容器
 docker rm 容器名字/容器id

2 启动并运行容器
    # 通过centos:centos7镜像，创建一个容器名字叫mycentos，并且把它运行起来
    docker run -di --name=mycentos centos:centos7
    打印出容器的id号
3 查看机器上正在运行的容器
    docker ps
4 查看宿主机上所有的容器（包括停止的）
    docker ps -a
5 停止容器
    docker stop 容器名字/id号
6 启动容器
    docker start 容器id/名字

7 容器的创建和启动（******）
    -创建：docker create --name=xxx redis
    docker create --name=test-container centos:centos7 ps -A
    -启动
    docker start test-container

    -容器一直运行的原因
        -它有一条前台进程,一直在运行
        -以后如果自己制作的镜像，运行起容器，必须有个可以夯住的命令
        -如果该命令结束，该容器也就结束了

    -创建并启动（run）
    -i：表示运行容器
    -t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
    -d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。
    --name :为创建的容器命名。如果不写，会自动分配一个名字（英文人名）
    -v：表示目录映射关系（前者是宿主机目录，后者是容器目录，映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。
    -p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
    docker run -it --name=myredis redis

 # 注意，docker run  镜像 如果本地没有，会先pull，再run

8 进入容器的几种方式（并不是真进入）
    第一种：docker exec -it  容器id /bin/bash
        docker exec 容器id ls
        exec真正的作用是在容器内执行命令
    第二种：ssh连接（容器内部装ssh服务端）
9 退出
    exit

10 文件拷贝
    -从宿主机拷贝到容器内部
        docker cp lqz.txt 容器id:/home
    -从容器内部拷贝到宿主机
        docker cp 容器id:/home/lqz.txt /app
11 目录挂载
                                     # 宿主机路径  容器路径
    docker run -di --name=mycentos99 -v /home/lqz:/home centos:centos7
    # 一旦挂载，以后宿主机目录内修改，同样影响容器内部
12 端口映射
    docker run -di -p 6377:6379 redis:latest

    # 了解：/usr/local/bin/docker-entrypoint.sh

13 查看容器详细信息
    docker inspect f81
    # 查看ip地址
    docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）

6 应用部署

在容器内部署mysql
-e表示环境变量

docker run -di --name=mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
官方提供的
docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

在容器内部署redis
docker run -di -p 6377:6379 redis:latest

在容器内部署nginx
docker run -di --name=mynginx -p 8080:80 nginx

1 部署应用映射外部目录

部署redis，把配置文件和数据目录映射出来
操作步骤
    -1 mkdir /reids /redis/conf /redis/data
    -2 vim /redis/conf/redis.conf
        # 配置文件
        bind 0.0.0.0
        daemonize NO
        protected-mode no
        requirepass 123456
    -3 创建并运行容器
    docker run -p 6378:6379 --name redis_6379 -v /redis/conf/redis.conf:/etc/redis/redis.conf -v /redis/data:/data -di redis redis-server /etc/redis/redis.conf
    -4 本地window机器上远程连接到了docker里的redis
    -5 cmd窗口下
        redis-cli -h 101.133.225.166 -p 6378
    -6 认证
        auth 123456
    -7 写入数据
        set name lqz
    -8 保存数据
        save或者是bgsave
    -9 在宿主机的/redis/data路径下就能看到一个文件
    -10 不管多少次重启redis容器，数据都还在
    -11 原来的redis容器没了，按照第三步再启动一遍，数据都还在

2 迁移与备份

2.0 其他操作

删除所有容器（）
docker rm docker ps -a -q
删除所有镜像
docker rmi docker images -q

通过自己构建的image启动容器
docker run -id --name=mydjango -p 8088:8088  mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088

查看容器运行日志
docker logs 容器id

操作步骤
    1 启动一个python容器
        docker run -di --name=lqz python:3.6
    2 进入装软件
        docker exec -it lqz /bin/bash
        mkdir /project
        pip install django==1.11.1
        退出
    3 把项目拷贝到容器内部
        docker cp /opt/lqz/django_test lqz:/project

    4 把容器做成镜像
        docker commit lqz mydjango
    5 基于自己做的镜像运行容器
    docker run -id --name=mydjango -p 8088:8088  mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088

2.1 容器保存为镜像

docker commit 容器名字 镜像名字
docker commit 19b mydjango
pip install django==1.11.11 -i https://pypi.douban.com/simple/

2.2 把镜像打包成压缩包

docker save -o mydjango.tar mydjango

2.3 把压缩包回复为镜像

docker load -i mydjango.tar

3 dockerfile(很重要)

1 dockerfile是什么
    一个文件，里面一堆指令，通过这个文件可以生成镜像
2 dockerfile指令
    命令                    作用
    FROM image_name:tag 定义了使用哪个基础镜像启动构建流程
    MAINTAINER user_name    声明镜像的创建者
    ENV key value   设置环境变量 (可以写多条)
    RUN command 是Dockerfile的核心部分(可以写多条)
    ADD source_dir/file dest_dir/file   将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
    COPY source_dir/file dest_dir/file  和ADD相似，但是如果有压缩文件并不能解压
    WORKDIR path_dir    设置工作目录

3 写一个dockerfile（文件名字必须交dockerfile）
vim dockerfile
    FROM python:3.6
    MAINTAINER lqz
    EXPOSE 8080
    ADD ./requirement.txt /home/
    RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/
    RUN pip install uwsgi -i https://pypi.douban.com/simple/
    VOLUME ["/home"]
    WORKDIR /home/django_test
    CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"]
4 通过dockerfile构建出镜像
    docker build -t='django_1.11.11' .
5 查看镜像
    docker images

6 启动容器
docker run -di --name=mydjango2 -v /opt/lqz/:/home -p 8080:8080 django_1.11.11

7 在外部访问即可

8 配置nginx转发
创建文件件
mkdir -p /opt/nginx/conf /opt/nginx/html /opt/nginx/logs
新建配置文件
vim nginx/conf/nginx.conf
写入
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    upstream node   {
        server  101.133.225.166:8080;
        server  101.133.225.166:8081;
        server  101.133.225.166:8082;
    }
    server {
        listen       80;
        server_name  localhost;
        location / {
          #proxy_pass http://101.133.225.166:8080;
          #负载均衡配置
          proxy_pass http://node;
        }
    }
}

docker 中运行nginx
docker run --name nginx -id -p 8888:80 -v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /opt/nginx/html:/etc/nginx/html -v /opt/nginx/logs:/var/log/nginx nginx

9 配置负载均衡
修改nginx配置文件
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    upstream node   {
        server  101.133.225.166:8080;
        server  101.133.225.166:8081;
        server  101.133.225.166:8082;
    }
    server {
        listen       80;
        server_name  localhost;
        location / {
          #proxy_pass http://101.133.225.166:8080;
          #负载均衡配置
          proxy_pass http://node;
        }
    }
}
多启动几个docker容器
docker run -di --name=mydjango3 -v /opt/lqz/django_test2/:/home/django_test/ -p 8081:8080 django_1.11.11
docker run -di --name=mydjango3 -v /opt/lqz/django_test2/:/home/django_test/ -p 8082:8080 django_1.11.11

重启nginx
假设8081的容器挂了，8080的容器挂了，正常提供服务，
再把docker容器启动起来即可

4 私有仓库

1 把自己的镜像传到docker hub上
    -docker login  输入用户名密码
    -给你要上传的image打个标签  docker tag 容器id 账号/django1.11.9:v1
    -docker images
    -docker push liuqingzheng/django1.11.9:v1

步骤

1 拉取私有仓库镜像
    docker pull registry
2 启动容器
    docker run -di --name=registry -p 5000:5000 registry
3 打开浏览器 输入地址http://101.133.225.166:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
4 配置
    修改daemon.json
    vi /etc/docker/daemon.json
    添加以下内容，保存退出。
    {"insecure-registries":["101.133.225.166:5000"]}
    此步用于让 docker信任私有仓库地址
5 重启docker 服务
    systemctl restart docker
6 重启容器
    docker start registry
7 打标签
    docker tag 5452fa6715c0 101.133.225.166:5000/django1.11.11
8 上传到私有仓库
docker push 101.133.225.166:5000/django1.11.11

9 从私有仓库拉取镜像
docker pull 101.133.225.166:5000/django1.11.11

5 docker-compose

1 docker-compose是一个单机情况下容器编排的工具
2 通过yml文件定义多个容器
3 默认名字docker-compose.yml
4 三个概念，Service  Networks ，Volumes
    一个service代表一个container，这个container可以从docker hub的image来创建，或者从本地dockerfile build的image来创建
5 version：有1，2，3版本，目前都用"3"

6 安装
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-uname -s-uname -m > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

7 验证安装成功
    docker-compose -v

5.1 部署多应用

部署flask redis
1 创建Dockerfile
vim Dockerfile
FROM python:3.6
COPY . /app
WORKDIR /app
RUN pip install flask redis
EXPOSE 5000
CMD [ "python", "app.py" ]

2 创建docker-compose文件
vim docker-compose.yml
version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .  # 当前路径下
      dockerfile: Dockerfile  # 的Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis
3 创建app.py
vim app.py
from flask import Flask
from redis import Redis
import os
import socket
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
@app.route('/')
def hello():
    redis.incr('hits')
    return '你好! 查看 %s 次， hostname 是 %s.\n' % (redis.get('hits'),socket.gethostname())
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)
4 启动--运行
docker-compose up

docker-compose.yml 如何写

Docker Compose File 顶级配置项：

​ •version：指定Docker Compose File版本号

​ •services：定义多个服务并配置启动参数

​ •volumes：声明或创建在多个服务中共同使用的数据卷对象

​ •networks：定义在多个服务中共同使用的网络对象

​ •configs：声明将在本服务中要使用的一些配置文件

​ •secrets：声明将在本服务中要使用的一些秘钥、密码文件

案例:
version: '3'
services:
  wordpress:
    image: wordpress
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_PASSWORD: root
    volumes:
      - mysql-data:/var/lib/mysql

docker-compose命令

启动管理容器
docker-compose up  # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d  # 后台执行，一般我们看日志输出，不用这个

docker-compose stop  # 停止，不会删除容器和镜像
docker-compose down # 停止，并删除关联的容器
docker-compose start  # 启动yml文件管理的容器
docker-compose ps    # 正在运行的容器
docker-compose images # docker-compose管理的容器

docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内

6 多个容器直接通信方式

1 端口映射到宿主机，直接访问宿主机
2 通过ip地址访问
3 run的时候指定 --link 容器
docker run -di --name=centos1 centos:centos7
docker run -di --name=centos2 --link centos1 centos:centos7

进入到centos2中 ping centos1 可以ping同

跨主机的容器通信
    -端口映射

Original: https://www.cnblogs.com/zonghan/p/16259615.html
Author: zong涵
Title: docker使用