学习Docker学习笔记

一、centos6.8安装Docker

1.yum install -y epel-release

Docker使用EPEL发布，RHEL系的OS首先要确保已经持有EPEL仓库，否则检查OS的版本，然后安装相应的EPEL包。

2.yum install -y docker-io

3.安装后的配置文件：/etc/sysconfig/docker

 

4.启动Docker后台服务：service docker start

5.docker version 验证

二、centos7阿里云镜像加速器配置

1.是什么：https://dev.aliyun.com/search.html

2.注册一个属于自己的阿里云账户(可复用淘宝账号)

3.获取加速器地址

    (1)登录阿里云开发者平台

    (2)配置阿里云加速地址

/etc/docker/daemon.json

 

4.配置本机Docker运行镜像加速器

5.重新启动Docker后台服务：service docker restart

6.Linux系统下配置完加速器需要检查是否生效

 

Docker 架构图

 

 

由于本地没有hello-world这个镜像，所以会下载一个hello-world的镜像，并在容器内运行 

run是干什么：

Docker底层原理

1.Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到集装箱

运行主机

三、为什么Docker比较比VM快

(1)docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

(2)docker利用的宿主机的内核，而不需要GuestOS。因此，当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程，当新建一个虚拟机时，虚拟机软件需要加载Guest OS，返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统，则省略了返个过程，因此新建一个docker容器只需要几秒钟。

Docker 常用命令

docker version

docker info

docker --help

Docker 镜像命令

docker image 

         列出本地主机上的镜像

         OPTIONS说明： 

                               -a:列出本地所有的镜像(包含中间映像层)

                               -q:只显示镜像ID。

                               --digests:显示镜像的摘要信息

                                --no-trunc:显示完整的镜像信息

docker search某个xxx镜像名字

                      网站：https://hub.docker.com

                     命令->docker search[OPTIONS]镜像命令

                     OPTIONS说明： --no-trunc:显示完整的镜像描述

                                               -s:列出收藏数不小于指定值的镜像

                                              --automated:只列出automated build类型的镜像；

docker pull 某个xxx镜像名字

下载镜像： docker pull 镜像名字[:TAG]

docker rmi某个xxx镜像名字ID ：删除某个镜像

 docker rmi -f 镜像名1:TAG 镜像名2：TAG

docker rmi -f $(docker images -qa) 删除全部

Docker容器命令

容器简介：

Docker 利用容器(Container) 独立运行的一个或一组应用。 容器是用镜像创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

可以吧容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。

容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

1.阿里云下载centos :有镜像才能创建容器，这是根本前提(下载一个centos镜像演示) docker pull centos

2.新建并启动容器

                            docker run [OPTIONS]IMAGE[COMMAND][ARG...]

                             docker run - it -- name mycentos115

                                               OPTIONS说明

                                                                         OPTIONS说明（常用）：有些是一个减号，有些是两个减号

                                                                            -- name="容器新名字"：为容器指定一个名称；

                                                                            - d:后台运行容器，并返回容器ID，也即启动守护式容器；

                                                                            - i:以交互式模式运行容器，通常与-t同时使用；

                                                                           - t: 为容器重新分配一个为输入终端，通常与-i同时使用；

                                                                         - P:随机端口映射; 

                                                                         - p:指定端口映射，有以下四种格式

                                                                                    ip:hostPort:containerPort

                                                                                    ip::containerPort

                                                                                    hostPort:containerPort

                                                                                    containerPort 

                                                启动交互式容器

                                                   

3.列出当前所有正在运行的容器

       查看所有docker中启动容器命令： docker ps 常用命令

                        

4.退出容器

                        两种退出方式 1:exit:容器停止退出；2.ctrl+P+Q:容器不停止退出

5.启动容器

                 docker start 容器名或者容器ID

6.重启容器

                 docker restart 容器名或者容器ID

7.停止容器

              docker stop 容器名或者容器ID

8.强制停止容器

          docker kill 容器名或者容器ID

9.删除已停止的容器

  1.docker rm 容器ID 2. 一次性删除多个容器 docker rm -f $(docker ps -a -q)       docker ps -a -q | xargs docker rm 

10.重要

                （1）   启动守护式容器      —> docker run -d 容器名

              

                  （2） 查看容器日志 docker logs -f -t --taill 容器ID

                                                           -t：是加入时间戳

                                                           -f:跟随最新的日志打印

                                                           --tail 数字显示最后多少条

                  （3）  查看容器内运行的进程

                                         docker top 容器ID

                  （4）查看容器内部细节

                                           docker inspect 容器ID 

                  （5）进入正在运行的容器并以命令行交互

                                  docker exec -t  10baseses809 ls -l /tmp

                                docker exec -t 容器ID bashShell

                           

                                重新进入docker attach 容器ID

                                 R上述两个区别                  

                                                              (1)attach 直接进入容器启动命令的终端，不会启动新的进程

                                                           （2）exec是在容器中打开新的终端，并且可以启动新的进程

                  （6）从容器内拷贝文件到主机上

                                    docker cp 容器ID：容器内路径目的主机路径

 

 

一、Docker镜像commit 操作补充 

             1.docker commit :提交容器副本使之成为一个新的镜像

             2.docker commit -m="提交的描述信息"-a="作者"容器ID要创建的目标镜像名：【标签名】

             3.案例演示

                （1）从hub上下载tomcat镜像到本地并成功运行

                       docker run -it -p 8080:8080 tomcat 

                                                                                      -p:主机端口:docker容器端口

                                                                                     -P：随机分配端口

                                                                                      i:交互

                                                                                     t:终端

                 （2）故意删除上一步镜像生产tomcat容器的文档

                      

                 （3）也即当前的tomcat运行实例是一个没有文档内容的容器，以它为模板commit

                        一个没有doc的tomcat新镜像atguigu/tomcat02

                       

                   (4) 启动我们的新镜像并和原来的对比

                        docker run -d -p 6666:8080 tomcat

二、Docker 容器数据卷

 2.能干嘛：(1) 容器的持久化

                    (2) 容器间继承+共享数据

3.数据卷

容器内添加  

                     直接命令添加 

                     命令： docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

                     DockerFile添加

                     

4.数据卷容器

直接命令添加 
(1)命令:docker run -it -v /宿主机绝对路径目录：容器内目录 镜像名
(2)查看数据卷是否挂载成功
(3)容器和宿主机之间数据共享
(4)容器停止退出后，主机修改后数据是否同步
(5)命令(带权限) docker run -it -v/宿主机绝对路径目录:/容器内目录:ro镜像名
例子：docker run -it -v /myDataVolume:/dataVolumeContainer:ro centos
创建文件命令：touch

容器数据卷用DockerFile
1、DockerFile增加
  (1)根目录下新建mydocker文件夹
 (2)可在Docker中使用VOLUME指令来给镜像添加一个或多个数据卷
 VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]

#volume test

FROM centos

VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]

CMD echo "finished,------------------------------------success1"

CMD /bin/bashS 
 (3) File构建
 (4)build后生成镜像 ->获得一个新镜像zzyy/centos

打包centos : docker build /mydocker/DockerFile -t /zssy/centos

(5)run运行生成镜像

docker run -it -v /myDataVolume:/dataVolumeContainer --privileged=true 镜像名

 (5)run容器
 (6)通过上述步骤，容器内的卷目录地址已经知道对应的主机目录地址那?
 (7)主机对应默认地址

数据卷容器

总体介绍

    以上一步新建的镜像zzyy/centos为模板并运行容器dc01/dc02/dc03

    它们已经具有容器卷    /dataVolumeContainer1

                                        /dataVolumeContainer2

docker attach dc02 进入命令

 

 

容器间传递共享(--volumes-from)

结论：容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止。

 

DockerFile保留字指令

 Base镜像(scratch)

自定义镜像mycentos

CMD指令

CMD:Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run 之后的参数替换

 

Docker语法格式：
1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2：指令按照从上到下，顺序执行
3：#表示注解
4：每条指令都会创建一个新的镜像层，并对镜像进行提交
例子：
FROM scratch
ADD centos-7.7-x86_64-docker.tar.xz /

LABEL org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20191024"

CMD ["/bin/bash"]

DokcerFile构建步骤：
 编写DockerFile文件
 docker build(打包)
 docker run(运行)

 DockerFile体系结构(保留字指令)
 FROM:基础镜像，当前新镜像是基于那个镜像的
 MAINTAINER: 镜像维护者的姓名和邮箱地址
 RUN: 容器构建时需要运行的命令
 EXPOSE: 当前容器对外暴露出的端口
 WORKDIR: 指定在创建容器后，终端默认登录的进来工作目录，一个落脚点
 ENV: 用来在构建镜像过程中设置环境变量
 例子：ENV MY_PATH/usr/mytest
 这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；也可以在其它指令中直接使用这些环境变量，
 比如： WORKKDIR $MY_PATH
 ADD: 将宿主机目录下的文件拷贝进镜像且ADD命令自动处理URL和解压tar压缩包
 COPY: 类似ADD,拷贝文件和目录到镜像中。
 将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
 VOLUME: 容器数据卷，用于数据保存和持久化工作
 CMD: (1)指定一个容器启动时要运行的命令
      CMD容器启动命令
     CMD 指令的格式和RUN相似，也是两种格式：
     (1) shell 格式: CMD命令
    （2）exec 格式： CMD["可执行文件","参数1","参数2"......]
    参数列表格式：CMD["参数1","参数2"......],
    在指定了ENTRYPOINT指令后，用CMD指定具体的参数。
      (2)DockerFile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run 之后的参数替换
 ENTRYPOINT: (1)指定一个容器启动时要运行的命令
             (2)ENTRYPOINT的目的和CMD一样，都是在指定容器启动程序及参数
 ONBUILD: 当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

 

1.新建DockerFile: vim DockerFile
2.编辑DockerFile:
FROM centos
MAINTAINER zzyy<zzyy@126.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim 
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "success-------------ok"
CMD /bin/bash
3.打包dockerFile
docker build -f /mydocker/Dockerfile2 -t mycentos:1.3

4.运行打包好的新镜像
docker run -it mycentos:1.3(新镜像名字：TAG)
5.列出镜像的变更历史
docker history mycentos:1.3(镜像名)

 

配置Dockerfile
FROM centos 
MAINITAINER zzyy<javawebservlet@126.com>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim 
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_171
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_BASE /usr/local/apache_tomcat-9.0.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
#ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
#CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && 
tail -f /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out
打包dockerfile文件
docker build -t zzyytomcat9 .
运行dockerfile
docker run -d -p 9080:8080 --name myt9 -v /zzyyuse/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/
test -v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs --privileged=true zzyytomcat9
 

安装 MYSQL
docker pull mysql
启动docker中mysql
docker run -p 3307:3306 --name mysql
-v /zzyyuse/mysql/conf:/etc/mysql/conf.d
-v /zzyyuse/mysql/logs:/logs
-v /zzyyuse/mysql/data:/var/lib/mysql
-d mysql:5.6

下载最新的mysql镜像

docker pull mysql

下载完毕之后启动容器

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

然后进入交互页面

docker exec -it mysql01 /bin/bash

登录mysql,然后输入你的初始密码123456

mysql -u root -p

修改root用户的初始密码

alter user 'root'@'localhost' identified by 'root123';

如果你用navicat等工具连接数据库发生2059-caching_sha2_password xxx的错误（这个错误是mysql高版本的密码验证规则发生了改变导致），再次登录到mysql上，输入下面这行

ALTER  USER  'root'  IDENTIFIED  WITH  mysql_native_password  BY  'root123';   

至此mysql启动完毕，并设置了开机启动，并且可以使用navicat等软件操作数据库

进入mysql容器
docker exec -it MYSQL运行成功后的容器ID /bin/bash
docker中mysql数据库备份
docker exec -it MYSQL运行成功后的容器ID sh -c ` exec mysqldump --all-databases -uroot -p"123456" ` > /zzyyuse/all-databases.sql

在主机/zzyyuse/myredis/conf/redis.conf目录下新建redis.conf文件
vim /zzyyuse/myredis/conf/redis.conf/redis.conf

启动docker中redis
docker run -p 6379:6379 -v/zzyyuse/mysqlredis/data:/data -v /zzyyuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d
redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

本地镜像推送到阿里云

 

1.本地镜像素材原型

 2.阿里云开发者平台 

 

3.创建仓库镜像 

4.将镜像推送到registry

5.查看详情

 

设置阿里云安装镜像