docker 简要学习

一、docker的安装和启动

使用环境centos7

1. yum包更新到最新

   sudo yum update

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

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

3. 设置yum源为阿里云

   sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

4. 安装docker

   sudo yum install docker-ce

5. 安装查看docker版本

   docker -v

6. 设置 docker镜象拉取提供者

   编辑文件：vi  /etc/docker/daemon.json
   在该文件中输入：
      {
     "registry-mirrors":["https://docker.mirrors.ustc.edu.cn"]
      }

7. 启动、重启、停止、加入服务

     systemctl start docker  启动
     systemctl status docker 查看状态
     systemctl enable docker 开机自启动

8. 镜像相关的命令

     查看镜像
     docker images
     搜索
     docker search nginx
     拉取
     docker pull  nginx
     删除 （有运行的容器不能删除）
     docker rmi  镜像id
     删除所有
     docker rmi `docker imgaes -q`

   二、容器相关的命令

9. 查看运行中的容器

   docker ps
   docker ps -a 查看没有运行和运行的

10. 创建与启动容器
    2.1 创建容器命令：

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

    2.2 交互式方式创建容器

    docker run -it --name=容器名称 镜像名称：标签 /bin/bash
    例：docker run -it --name=mycentos centos:7 /bin/bash
    退出当前容器 exit

    2.3 守护式方式创建容器

    docker run -id --name=容器名称 镜像名称：标签
    例如： docker run -id --name=mycentos2 centos:7
    进入容器
    docker exec -it 容器名称  /bin/bash
    退出当前容器 exit
    例如：docker exec -it mycentos2 /bin/bash

    2.4 启动容器与停止容器

    停止容器： docker stop 容器名称（或者容器id）
    启动容器： docker start 容器名称 （或者容器id）

    2.5 文件拷贝（ 如果我们需要将宿主机文件拷贝到容器里面 ）

    宿主机 ---> 容器
    docker  cp  需要拷贝的文件或目录  容器名称：容器目录
    例：docker cp anaconda-ks.cfg mycentos2:/usr/local
    容器文件 ----> 宿主机器
    docker cp 容器名称：容器目录 需要拷贝的文件或目录
    例：docker cp mycentos2:/usr/local/anaconda-ks.cfg anaconda-ks.cfg

    2.6 目录挂载（将宿主的目录与容器内目录进行映射，这样我们就可以通过修改宿主机器某个目录的文件去影响容器的文件）

    创建容器 添加-v参数 后边为 宿主机器目录:容器目录，
    例： docker run -di --name=mycentos3 -v /home/myhtml:/home/myhtml centos:7
    如果权限不足提示：
    因为centos7的安全模块selinux把权限禁止掉了。我们需要添加参数 -privileged=true来解决目录没有权限的问题

    2.7 查看容器的ip

    查看容器信息：
    例：docker inspect  mycentos3
    查看容器的ip信息：（格式化提取）
    例：docker inspect --format="{{.networksettings.ipaddress}}" mycentos3
    移除容器 (不能移除正在运行的)
    例：docker rm mycentos3

    三、docker应用部署

11. mysql部署
    1.1 拉取mysql镜像
    docker pull centos/mysql-57-centos7
    1.2 创建容器
    docker run -di --name=cason_mysql -p 33306:3306 -e mysql_root_password=123456 mysql centos/mysql-57-centos7 -p 代表端口映射，格式为 宿主机映射端口：容器运行端口 -e 代表添加环境变量， mysql_root_password 是root用户的登陆密码
    1.3 进入mysql容器
    docker exec -it cason_mysql /bin/bash
    1.4 登陆mysql
    mysql -u root -p
    1.5 远程登陆mysql
    连接宿主机的ip，指定端口为33306
12. tomcat部署
    2.1 拉取镜像
    docker pull tomcat:7-jre7
    2.2 创建容器
    docker run -di --name=cason_tomcat -p 10001:8080 -v /home/local/webapps:/usr/local/tomcat/webapps tomcat:8-jre8
    • /home/local/webapps 代表宿主机目录
    • /usr/local/tomcat/webapps 容器tomcat的部署目录
13. 部署nginx
    3.1 拉取镜像 docker pull nginx
    3.2 创建镜像 docker run -di --name=mynginx -p 80:80 nginx

14. 部署redis
    4.1 拉取镜像 docker pull redis
    4.2 创建镜像 docker run -di --name=myredis -p 6379:6379 redis

四、docker迁移与备份

1. 容器保存为镜像
   docker commit cason_nginx caosn_nginx_1
2. 镜像备份(cason_nginx.tar文件导出在当前目录)
   docker save -o cason_nginx.tar cason_nginx_2
3. 镜像回复
   docker load -i cason_nginx.tar

六、dockerfile

1. 概念：dockerfile是由一系列命令和参数构成的脚本，这些命令应用于 基础镜像并最终创建一个新的镜像
   1、对于开发人员：可以为开发团队提供一个完全一致的开发环境
   2、对于测试人员：可以直接拿开发时构建的镜像或通过dockerfile构建一个新镜像
   3、对于运维人员：在部署时，可以实现应用的无缝一致

2. 常用命令：
   命令 作用
   from image_name:tag 定义了使用哪个基础镜像启动构建流程
   maintainer user_name 声明镜像的创建者
   env key value 设置环境变量（可以写多条）
   run command 是dockerrfile的核心部分（可以写多条）
   add source_dir/file 将宿主机的文件复制到容器。如果是一个压缩文件，将会复制到容器中自动解压
   copy source_dir/file 和add像是 。但如果有压缩文件并不能解压
   workdir path_dir 设置工作目录

3. 使用脚本创建镜像的
   例如构建一个jdk8的centos7镜像：
   dockerfile脚本如下：
   ```
   from centos:7
   maintainer cason
   workdir /usr
   run mkdir /usr/local/java
   add jdk-8u172-linux-x64.tar.gz /usr/local/java/

    env java_home /usr/local/java/jdk1.8.0_172
    env jre_home $java_home/jre
    env classpath $java_home/bin/dt.jar$java_home/lib/tools.jar:$jre_home/lib:$classpath
    env path $java_home/bin:$path

   ```
   同时在当前目录添加 jdk-8u172-linux-x64.tar.gz 安装包

4. 脚本完成后执行构建： docker build -t='jdk1.8' .
   -t 代表指定构建后的docker的名称
   . 点代表指定当前目录

5. docker 启动 web 示例报错如下：
   error response from daemon: cannot start container web: iptables failed: iptables -t nat -a docker -p tcp -d 0/0 --dport 32797 -j dnat --to-destination 172.17.0.30:5000 ! -i docker0: iptables: no chain/target/match by that name.
   解决办法：重建docker0网络恢复

   pkill docker  # 杀死docker进程
   iptables -t nat -f  # 清空规则链的(注意每个链的管理权限)
   ifconfig docker0 down # 停止docker0的ip连接
   brctl delbr docker0 # 重新桥接docker0的网络
   docker -d      # 开启daemon模式。
   service docker restart # 重启docker
   

   七、docker私有库

6. 私有仓库的搭建与配置
   1.1 拉取私有仓库镜像 docker pull registry
   1.2 创建私有仓库容器 docker run -di --name=registry -p 5000:5000 registry
   1.3 创建成功后 在浏览器输入：宿主机ip+5000端口 例如
   查看到了 {"repositories":[]} 表示成功并且内容为空
   1.4 修改daemon.json
   vi /etc/docker/daemon.json 添加内容
   {"insecure-registries":["192.168.110.141:5000"]}
   1.5 重启docker
   systemctl restart docker

7. 镜像上传至私有仓库
   2.1 标记镜像为私有仓库的镜像
   docker tag jdk1.8 192.168.110.141:5000/jdk1.8
   2.2 上传标记的镜像 (要保证私库的容器正在运行着)
   docker push 192.168.110.141:5000/jdk1.8

八、dockermaven插件

maven插件自动部署步骤：（配置：）

1. 修改宿主机器的docker的配置，让其可以远程访问
   vi /lib/systemd/system/docker.service
   添加部分是：-h tcp://0.0.0.0:2375 -h unix:///var/run/docker.sock
   修改为：
   execstart=/usr/bin/dockerd -h tcp://0.0.0.0:2375 -h unix:///var/run/docker.sock

2. 刷下docker配置

   systemctl daemon-reload
   systemctl restart docker
   docker start registry

3. 在pom.xml文件添加 docker配置

    <build>
        <finalname>app</finalname>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
            <!-- docker的maven插件，官网 https://github.com/spotify/docker-maven-plugin  -->
            <plugin>
                <groupid>com.spotify</groupid>
                <artifactid>docker-maven-plugin</artifactid>
                <version>0.4.13</version>
                <configuration>
                    <imagename>192.168.110.141:5000/${project.artifactid}:${project.version}</imagename>
                    <!--<dockerdirectory>src/main/docker</dockerdirectory>-->
                    <baseimage>java:8</baseimage>
                    <entrypoint>["java", "-jar", "/${project.build.finalname}.jar"]</entrypoint>
                    <resources>
                        <resource>
                            <targetpath>/</targetpath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalname}.jar</include>
                        </resource>
                    </resources>
                    <dockerhost>http://192.168.110.141:2375</dockerhost>
                </configuration>
            </plugin>
        </plugins>
    </build>

4. 以上配置会自动生成dockerfile

     from jdk1.8
     add aap.jar /
     entrypoint ["java","-jar","/app.jar"]

5. 在windows的命令提示符下，进入当前工程的目录 ，输入以下命令 打包上传镜像
   命令：mvn clean package docker:build -dpushimage

       i/o exception (java.io.ioexception) caught when processing request to {}->unix://localhost:80: broken pipe
      导致这个错误的原因是 project.artifactid 可能包含了大写

6. 创建容器
   docker run -di --name=base -p 8088:8088 192.168.110.141:5000/springboot-demo:1.0.0-snapshot
   端口8088 因为springboot-demo项目的端口就是8088

7. 直接浏览器输入 这就是访问docker里面的boot项目