Linux08 /Docker

Linux08 /Docker

目录

• Linux08 /Docker
  • 1. docker简介/安装
  • 2. Docker镜像加速器的设置
  • 3. 核心三要素
    • 镜像仓库/Registry
    • 镜像/Image：打包了代码及环境的包
    • 容器/Containers：镜像的运行时
  • 4. HelloWorld容器的整体流程
  • 5. docker常用命令
  • 6. Dockerfile文件
  • 7. docker hub仓库、私有仓库的使用
  • 8. crm制作docker镜像示例

1. docker简介/安装

• docker概述

  1. 打包应用程序及程序运行所依赖的环境产出叫做Docker镜像

  2. 可以启动多个镜像到服务器中

  3. docker是cs架构，一般操作的都是客户端

     

  4. Docker概念：Docker是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一一个可移植的镜像中,然后发布到任何流行的Linux或Windows机器上,是一种轻量级的虚拟化技术。

     

• 安装docker

  # 1.安装:
  yum install docker-server docker -y
  # 通过yum安装的docker，直接使用systemctl start docker 启动 
  
  # 2.检查docker版本，是否安装成功
  docker version
  

2. Docker镜像加速器的设置

• Docker镜像加速器的设置如下：

  # 执行命令
  curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io
  
  # 需要修改docker的配置文件，删除一个逗号
  [root@localhost ~]# cat /etc/docker/daemon.json
  {"registry-mirrors": ["http://f1361db2.m.daocloud.io"]}
  

3. 核心三要素

• 镜像仓库/Registry

  1.镜像仓库文件的来源：
    里面的镜像都是通过Docker push传上去的
    官方公有仓库
    自建的私有仓库
  
  2.镜像仓库的作用：
    用来镜像存储
  

• 镜像/Image：打包了代码及环境的包

  1.镜像的生成：
    docker build 生成
    docker pull 拉取到本地
  
  2.镜像的作用：
    docker run 运行镜像生成容器Container
    docker push 把本地镜像推送到Registry
  

• 容器/Containers：镜像的运行时

  1.容器的生成：
    docker run起来的就是容器
  
  2.容器的作用：
    提供服务
  

4. HelloWorld容器的整体流程

• 执行命令：docker run hello-world

• 执行流程图

  

5. docker常用命令

• 增加相关的docker命令

  1.去仓库拉镜像
    docker pull  centos  # 默认去dockerhub下载一个centos镜像文件 
  
  2.运行镜像，生成容器，并且检测镜像是否存在，不存在自动docker Pull
    docker run 镜像id 
  
  3.运行centos容器 ，并且进入这个容器空间
    docker run -it centos /bin/bash
    #  -i 是交互式的操作
    #  -t 是开启一个终端 
  
  4.端口映射，运行一个web程序，在容器中要对外进行端口暴露
    docker run -d -p 8090:5000 training/webapp python app.py
    #  -d  后台运行
    #  -p  指定端口映射   宿主机的 9000映射到容器内的5000 （宿主机的端口你可以自由定义，容器的端口根据代码决定）
    #  -P  随机端口映射 ，宿主机会随机生成一个端口，映射到容器的5000  
  
  5.构建镜像
    docker build    
  
  6.暂停一个正在运行的容器记录
    docker stop 容器id  
  
  7.再次运行一个容器
    docker start 容器id  	
  
  8.在容器与宿主机之间拷贝文件
    docker cp
  
  9.导出本地的docker镜像
    docker save 容器id > 镜像压缩文件
  
  10.导入docker镜像文件
    docker load  < 镜像压缩文件 
  
  11.运行一个活着的容器
   docker run -d centos /bin/sh -c "while true;do echo hellodocker
  ; sleep 1;done"
   #  -d 后台运行
   #  /bin/sh  Linux的shell解释器
   #  -c  指定一段shell脚本 
  
  12.给运行的容器添加一个名字,并使容器一直存活
   docker run --name rongqi  -d centos /bin/sh -c "while true;do echo  hellodocker; sleep 1;done"
  

• 删除相关的docker命令

  1.删除镜像，必须清除所有的容器记录依赖
    docker rmi 镜像id前三位即可 
  
  2.删除容器记录，必须是挂掉的记录才能删除
    docker rm 容器id  
  
  3.批量删除容器记录
    docker rm `docker ps -aq`  
  
  4.批量删除镜像记录
    docker rmi `docker images -aq`
  

• 修改相关的docker命令

  1.修改docker镜像的名字
    docker tag 镜像id 新的镜像名
  
  2.进入centos容器内，并且修改容器内的信息，然后提交为新的镜像
    docker run  -it  centos  /bin/bash
    # 然后下载一个vim，退出这个容器
    exit
    # 提交这个容器记录，为新的镜像
    docker commit  容器id新的镜像名
  

• 查询相关的docker命令

  1.查看机器上所有的镜像
    docker image ls
    docker images 
  
  2.查看正在运行的docker容器（必须有一个进程在容器中，后台运行，这个容器才不会挂掉）
    docker ps  
  
  3.查看所有运行过的容器记录（挂掉的，和正在运行的记录）
    docker ps -a 
  
  4.查看容器内所有的日志
    docker  logs  容器id/容器名
  
  5.实时刷新容器内的日志
    docker logs -f  容器id 
  
  6.如何进入一个活着的容器
    docker  exec  -it  容器id  /bin/bash  
  
  7.查看docke状态
    systemctl status docker
  
  8.查看docker有哪些指令
    docker --help
  
  9.查看docker的版本
    docker version
  
  10.搜索centos相关的镜像
    docker search centos  
  
  11.查看docker的端口转发情况
    docker port 容器id
  
  12.查看镜像或者容器详细信息
    docker inspect
  
  13.查看容器基础系统的版本
    cat /etc/os-release
  

• 额外命令

  1.查看输入命令历史
    history
  2.查看docker在哪个位置
    which docker
  3.查看是什么类型(文件夹:d/文件:-)
    ls -l /usr/bin/docker
  4.查看安装了哪些源
    cd /etc/yum.repos.d/或者yum repolist
  5.查看文件大小
    du -sh /var/lib/docker
  6.查看端口开没开
    telnet
  7.查看内存大小
    free -h
  8.相当于看网页
    curl 127.0.0.1:8001/hello/
  9.查看所有进程
    ps aux
  10.在文件夹中开启一个ftp，在linux中可以用wget进行下载
    python  -m SimpleHTTPServer 8005
  

6. Dockerfile文件

• 构建镜像

  docker build . -f ./Dockerfile -t my-helloworld:20191110
  
  . 表示当前文件
  -f 指定Dockerfile文件的位置
  -t 对镜像构建成后，镜像的标签
  

• Dockerfile文件

  Dockerfile文件存放一堆指令，在docker build的时候，按照该指令进行操作，最终生成我们期望的镜像

  FROM 指定基础镜像，必须为第一个命令

  FROM centos:7   # 使用base image
  FROM ubuntu:14.04   # 带有tag的base image
  
  # FROM指令，是指定你的docker镜像以哪一个操作系统为基础去运行
  # 制作base image 基础镜像，尽量使用官方的image作为base image
  

  LABEL 容器元信息、镜像维护者的信息

  LABEL version=“1.0”   # 容器元信息，帮助信息，Metadata，类似于代码注释
  LABEL maintainer=“zhangsan@163.com"  # 镜像维护者信息
  

  RUN 构建镜像过程中执行命令

  RUN yum install nginx
  RUN pip install django
  RUN mkdir test && rm -rf /var/lib/unusedfiles
  
  注意：
    	RUN指令创建的中间镜像会被缓存，并会在下次构建中使用。如果不想使用这些缓存镜像，可以在构建时指定--no-cache参数，如：docker build --no-cache
  

  WORKDIR 工作目录

  格式：
  	WORKDIR /path/to/workdir
  示例：
      WORKDIR /a  (这时工作目录为/a)
  注意：
    	通过WORKDIR设置工作目录后，Dockerfile中其后的命令RUN、CMD、ENTRYPOINT、ADD、COPY等命令都会在该目录下执行
  

  COPY|ADD 添加本地文件到镜像中

  # ADD 作用就是把宿主机的文件，添加到容器空间内
  # ADD 除了有拷贝的作用，还有解压的作用
  ADD and COPY
  ADD hello /   # 把本地文件添加到镜像中，把本地的hello可执行文件拷贝到镜像的/目录
  ADD test.tar.gz /  # 添加到根目录并解压
  
  # ADD和COPY一样，都是把宿主机的代码，拷贝到容器内，COPY只是拷贝，ADD是拷贝+解压缩 
  
  WORKDIR /root
  ADD hello test/  #进入/root/ 添加hello可执行命令到test目录下，也就是/root/test/hello 一个绝对路径
  COPY hello test/  #等同于上述ADD效果
  
  ADD与COPY
     - 优先使用COPY命令
     -ADD除了COPY功能还有解压功能
  添加远程文件/目录使用curl或wget
  

  ENV 定义一个变量

  ENV # 环境变量，尽可能使用ENV增加可维护性
  ENV MYSQL_VERSION 5.6 # 设置一个mysql常量
  RUN yum install -y mysql-server=“${MYSQL_VERSION}”
  
  # ENV命令是定义一个变量,修改的时候只需要修改ENV的参数,下面使用该变量的会跟着改变
  ENV MYSQL_VERSION 5.7
  
  RUN yum install -y mysql-server=“${MYSQL_VERSION}”
  RUN yum install -y mysql-server=“${MYSQL_VERSION}”
  RUN yum install -y mysql-server=“${MYSQL_VERSION}”RUN
  

  EXPOSE

  格式：
        EXPOSE <port> [<port>...]
  示例：
        EXPOSE 80 443
        EXPOSE 8080
        EXPOSE 11211/tcp 11211/udp
  注意：
        EXPOSE并不会让容器的端口访问到主机。要使其可访问，需要在docker run运行容器时通过-p来发布这些端口，或通过-P参数来发布EXPOSE导出的所有端口
  

• 制作Dockerfile文件示例：自定义一个flask的Dockerfile，构建一个运行flask程序的docker镜像

  1、准备flask的代码：cat testflask.py

  #coding:utf8
  from flask import Flask
  app=Flask(__name__)
  @app.route('/')
  def hello():
      return "hello flask"
  if __name__=="__main__":
      app.run(host='0.0.0.0',port=8080)
  

  2、编写Dockerfile,必须是这个名字，这个dockerfile作用就是运行这个flask代码

  FROM python  				  # 指定以python为基础镜像，它提供了python3
  RUN pip3 install flask  	  # 在容器内安装flask
  ADD  testflask.py /tmp/	      # 添加代码到容器中
  WORKDIR /tmp/				  # 切换工作目录
  CMD ["python","testflask.py"] # 通过CMD指令，让容器运行命令是 python testflask.py
  

  3、执行构建镜像命令

  1.需要准备的文件如下
    [root@localhost mydocker]# ls
    Dockerfile  testflask.py
  2.执行构建命令
    docker build .
  3.执行镜像文件，生成容器示例
    docker run -d  -p 9999:8080  5e7
  

7. docker hub仓库、私有仓库的使用

• docker hub仓库的使用流程

  1.在服务器上登录docker hub
    docker login
    输入账户名密码
    a877348180
    nimei.. 
  
  2.推送镜像到dockerhub，需要指定镜像文件的名字，以账号开头
    docker tag   docker.io/hello-world   a877348180/s1-hello-world
    docker push  a877348180/s1-hello-world
  
  3.其他人就可以直接下载了
    docker pull a877348180/s1-hello-world
  

• 私有仓库的使用流程

  1.下载私有仓库的一个镜像
    docker run -d \
      -p 5000:5000 \
      -v /opt/data/registry:/var/lib/registry \
      registry
  
  2.此时可以访问一下私有仓库的api地址
    http://192.168.16.192:5000/v2/_catalog
  
  3.上传镜像到私有仓库
    # 修改标签
    docker tag b16 192.168.16.192:5000/s1-flask-images
    # 上传镜像
    docker push 192.168.16.192:5000/s1-flask-images
  
  4.此时推送镜像，还不行，私有仓库，默认只支持http方式的推送，不支持https加密的推送，需要修改配置文件支持http形式的推送
  
  5.修改docker的配置文件
   vim /etc/docker/daemon.json
   {"registry-mirrors": ["http://f1361db2.m.daocloud.io"]
   ,
   "insecure-registries":["192.168.16.85:5000"]
   }
  
  6.还得修改docker的加载配置文件
    vim  /lib/systemd/system/docker.service   # 打开docker的服务文件，添加如下配置
    [Service]
    Type=notify
    NotifyAccess=main
    EnvironmentFile=-/etc/docker/daemon.json  # 添加如下一行配置 
  
  7.重启docker方可生效
    systemctl daemon-reload
    systemctl restart docker
  
  8.由于重启了docker，还得重运行私有仓库的镜像，重新上传镜像
    docker run --privileged=true -d -p 5000:5000 -v /opt/data/registry:/var/lib/registry registry
    # --privileged=true  以特权运行docker仓库
  
  9.上传镜像到私有仓库
    docker push 192.168.16.192:5000/s1-flask-images
  
  10.重新下载这个镜像文件，只有内网中的人，才能下载
    docker pull 192.168.16.85:5000/s1-hello-world-images
  

8. crm制作docker镜像示例

• 流程如下/利用数据卷映射：

  1. mysql 的root远程访问权限
  	MariaDB [(none)]> grant all privileges on *.* to root@'%' identified by '';
  	MariaDB [(none)]> flush privileges;
  
  2.Dockerfile如下
  	[root@local-pyyu mycrm]# cat Dockerfile
  
  	FROM python:3.6.6
  
  	RUN  pip3 install -i https://pypi.douban.com/simple  django==1.11.9
  	RUN pip3 install -i https://pypi.douban.com/simple  pymysql
  	RUN pip3 install -i https://pypi.douban.com/simple  django-multiselectfield
  
  	CMD ["python3","/opt/crm01/manage.py","runserver","0.0.0.0:8000"]
  	EXPOSE 8000
  
  3.修改django的数据库连接地址，我这里是连接宿主机的数据库
  	DATABASES = {
  	    'default': {
  	        'ENGINE': 'django.db.backends.mysql',
  	        'NAME': 'crm01',
  	        'USER': 'root',
  	        'PASSWORD': '',
  	        'HOST': '192.168.178.180',
  	        'PORT': 3306
  	    }
  	}
  
  4.构建镜像
  	docker build .
  	docker images  # 查看镜像如下
  	[root@local-pyyu mycrm]# docker images
  	REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  	<none>              <none>              1c0af95d1cf5        12 minutes ago      955 MB
  	docker.io/python    3.6.6               8256ec07b2ad        14 months ago       918 MB
  
  5.启动容器的命令，进行数据卷映射，宿主机的/opt/mycrm/文件夹，映射到容器的/opt目录
  	因为我这里存放文件的路径如下
  	[root@local-pyyu mycrm]# pwd
  	/opt/mycrm
  	[root@local-pyyu mycrm]# ls
  	crm01  Dockerfile
  
  	# 因此启动容器的命令如下
  	docker run -d -P -v /opt/mycrm/:/opt/ 1c0
  
  6.此时crm运行在容器中了
  	[root@local-pyyu mycrm]# docker ps
  	CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                     NAMES
  	9107a276ffda        1c0                 "python3 /opt/crm0..."   4 minutes ago       Up 4 minutes        0.0.0.0:32781->8000/tcp   inspiring_borg
  
  7.可以访问宿主机的ip地址，即可看到容器内的crm代码
  	http://192.168.178.180:32781/sales/login/
  

• 镜像包含crm项目

  1. mysql 的root远程访问权限
  	MariaDB [(none)]> grant all privileges on *.* to root@'%' identified by '';
  	MariaDB [(none)]> flush privileges;
  
  2.Dockerfile如下
  	[root@local-pyyu mycrm]# cat Dockerfile
  
      FROM python:3.6.6
  
      RUN  pip3 install -i https://pypi.douban.com/simple  django==1.11.9
      RUN pip3 install -i https://pypi.douban.com/simple  pymysql
      RUN pip3 install -i https://pypi.douban.com/simple  django-multiselectfield   
  
      ADD  crm01.tar.gz  /opt/
      WORKDIR /opt
      WORKDIR crm01
      CMD ["python3","/opt/crm01/manage.py","runserver","0.0.0.0:8000"]
  
  3.修改django的数据库连接地址，我这里是连接宿主机的数据库
  	DATABASES = {
  	    'default': {
  	        'ENGINE': 'django.db.backends.mysql',
  	        'NAME': 'crm',
  	        'USER': 'root',
  	        'PASSWORD': '',
  	        'HOST': '192.168.16.192',
  	        'PORT': 3306
  	    }
  	}
  
  4.构建镜像
  	docker build .
  	docker images  # 查看镜像如下
  	[root@local-pyyu mycrm]# docker images
  	REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
  	<none>              <none>              1c0af95d1cf5        12 minutes ago      955 MB
  	docker.io/python    3.6.6               8256ec07b2ad        14 months ago       918 MB
  
  5.启动容器的命令
  docker run -d -p 9000:8000 1c0    # 做端口的映射
  
  6.此时crm运行在容器中了
  	[root@local-pyyu mycrm]# docker ps
  	CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                     NAMES
  	9107a276ffda        1c0                 "python3 /opt/crm..."   4 minutes ago       Up 4 minutes        0.0.0.0:32781->8000/tcp   inspiring_borg
  
  7.可以访问宿主机的ip地址，即可看到容器内的crm代码
  	http://192.168.178.180:32781/sales/login/
  

• 总结：

  测试方法：可以进入容器内部，执行python3 manage.py runserver，查看是否能够正常启动，如有报错也可以直观的看到相应的报错信息