1. 前提知识
    - linux
    - Git
2. 课程定位和范围（基于JavaEE方向）
    - JavaEE  java  SpringMVC/springBoot/mybatis ...        docker基础篇
    - Docker  Go    Swarm/compose/machine/mesos/k8s/---CI/CD jenkinds整合 docker高级篇

1.问题：为什么会有docker出现
    - 解决开发与运维之间，因在“环境和配置”上的差异而产生的问题
    - 开发将（代码/配置/系统/数据...）一整套，整体打包复制过去
    - 软件带环境安装
2. docker理念
    - Build ,Ship and Run Any app,Anywhere
    - 一次构建处处运行：一次性配置好部环境，换环境直接署运行

3. 一句话
    - 解决了运行环境和配置问题的软件容器，方便做持续集成，并有助于整体发布的容器虚拟化技术
    - 标准统一的打包、部署、运行方案

1. 之前的虚拟机技术
    一个操作系统里面运行另一种操作系统。
    模拟一整套操作系统、硬件、软件

    缺点：资源占用多、冗余步骤多、启动慢

2. 容器虚拟化技术
    针对虚拟机技术，Linux发展出了另一种虚拟化技术:Linux容器(Linux Containers,缩写LXC)。
    Linux容器不是模拟一个完整的操作系统，而是对进程进行隔离。

     比较Docker与传统虚拟化方式的不同之处：
        * 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上在运行所需应用进程。
        * 而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
        * 每个容器之间相互隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区别计算资源。

3.  开发/运维（DevOps）开发自运维
    一次构建、随处运行
        更快速的应用交付和部署
        更便捷的升级和扩缩容
        更简单的系统运维
        更搞笑的计算资源利用

4. 企业级
    业界趋势
    使大规模动态调度成为可能
    更轻量、更高效、更敏捷、更灵活

1. 官网
    docker.com
    docker-cn.com

2. 仓库(Docker Hub)
    hub.docker.com

1. ContOS Docker安装
    CentOS 7（64-bit）
    CentOS 6.5（64-bit）或更高的版本
    系统内核版本为2.6.32-431或者更高版本

2. 版本查看指令:
    uname -r                 m   			内核版本查看指令
    cat /etc/redhat-release      			系统版本查看指令

1. Docker的架构图
    * Client  --命令终端，类似于git
        docker build
        docker pull
        docker run

    * DOCKER_HOST  --服务端，类似于操作系统
        Docker Daemon  管理引擎，docker进程
            大管家

        Images镜像
            容器的模板
        Containers容器
            镜像的一个实例
            Docker利用容器独立运行一个或一组应用。容器是用镜像创建的运行实例。
            它可以被启动、开始、运行、删除。每个容器都是相互隔离的、保证安全的平台
            可看做一个简易版Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序（仅170m大小）

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

    * Registry  --仓库注册服务器，类似于github远程库
        repository镜像仓库
            集中存放image镜像的地方
            仓库(repository镜像仓库)和仓库注册服务器(Registry)是有区别的。
            仓库注册服务器往往存放着多个仓库，每个仓库中有包含了多个镜像，每个镜像有不同的标签(Tag)

            仓库分为公开库public和私有库private
                最大的公开库是Docker Hub
                存放了数量庞大的镜像供用户下载。国内公开库: 阿里云、网易云

1. CentOS 6.8安装Docker-io
    - Linux指令：
        * 安装依赖库：yum install -y epel-release
        * 安装docker：yum install -y docker-io
        * 安装后的配置文件（存在表示安装成功）：/etc/sysconfig/docker
        * 启动Docker后台服务：service docker start
        * 版本查询：docker version 验证

2. CentOS 7安装Docker-ce
    文档查看：docs.docker.com/install/linux/docker-ce/centso/
    版本:
        社区办（CE），免费
        企业版（EE），收费

1.配置加速器
    - 阿里云镜像加速：dev.aliyun.com 
       * 注册登录账户
       * 获得加速器地址（容器镜像服务、镜像库、镜像加速器）
       * 配置本机Docker运行镜像加速器（/etc/sysconfig/docker）6.5版本，修改默认配置，不使用Docker Hub镜像仓库
       * 重启本机Docker服务: service docker restart
       * 查看进程，检查是否生效: ps -ef |grep docker
    - 网易云加速

2. 启动Docker 后台容器
    docker run hello-world
        运行hello-world镜像
    run干了什么
        本机中寻找镜像
            有，生产实例运行
            没有，则在远程仓库中pull镜像
        远程仓库寻找镜像
            有，下载到本地，产生容器实例，运行容器
            没有，返回失败错误，查不到该镜像

1.Docker是怎么工作的？
    - docker是一个client-service结构的系统，Docker守护进程运行在主机上，然后通过socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。
2.Docker为什么比虚拟机快？
    - docker有更少的抽象层:docker不需要硬件资源的虚拟化。
    - docker利用的是宿主的内核。因此当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统内核。

- docker version            				版本号查看
- docker info               				docker信息展示
- docker inspect							以json格式描述docker信息
- docker --help             				命令介绍，帮助手册

- docker images             				镜像列表
              	-a        					列出本地所有的镜像（含中间映像层）
              	-q        					只显示镜像ID
              	-qa       					列出本地所有的镜像ID
              	--digests 					显示镜像的摘要信息
          		--no-trunc    				显示完整的镜像信息

- docker search <name>                  	在docker hub查询name镜像
                --no-trunc      			显示完整的镜像描述
                -s <s>          			点赞数n以上的镜像
                --automated     			只列出automated build 类型的镜像，自动构建

- docker pull <name><:latest>               从远程仓库下载镜像

- docker rmi <name/no><:latest>             删除某个镜像
                -f                          强制删除单个
                -f  name1 name2             删除多个         
                -f  $(docker images -qa)    删除全部

- docker commit								提交容器副本是指成为一个新的镜像
				-m="提交的描述信息" -a="作者" <容器ID>  新镜像名:[标签版本编号]

- docker run images                     	新建并启动容器
                -i          				以交互模式运行容器，通常与-t同时使用     -it
                -t          				为统一重新分配一个伪输入终端，通常与-i同时使用
                --name (newName)   			为容器指定一个新名字
                -d              			后台运行容器，并返回容器ID，也即启动守护式容器
                -P              			大写p，随机端口映射
                -p              			小写p,指定端口映射

- docker ps         						列出所有正在运行的容器
             	-a     						正在运行的和历史上运行过的
             	-l     						上一次运行的容器
             	-n 3   						近3此运行的容器
             	-qa    						只显示容器ID，便于后面删除所有正在运行的容器
             	--no-trunc     				不截断输出

- exit              						容器停止退出，关闭容器并退出
- Ctrl+P+Q          						容器不停止退出

- docker start id/name      				启动容器

- docker restart id/name    				重启容器

- docker stop id/name       				停止容器

- docker docker kill id/name 强制停止容器

- docker rm id/name         				删除容器
            	-n 3            			删除最近的3个容器
            	-f $(docker ps  -q -a)      删除所有容器
- docker ps -a -q | xargs docker rm       	删除所有容器

- !!重要
- docker run -d <容器名>						开启守护式进程，后台运行
                    						docker ps -a 进行查看，发现容器已经退出
                    						说明了一个问题: Docker容器后台运行，必须有一个前台进程
                    						docker的一个机制，当启动的容器没有被使用时，会自动删除容器
                    						最佳解决方式: 将要运行的程序以前台进程的形式运行
                							eg: docker run -d centos /bin/bash -c "while true; do ehco hello zzyy;sleep 2;done"
- docker logs -f -t --tail <容器ID>          查看容器日志
        		-t              			日志加入时间戳
            	-f              			跟随最新的日志打印
            	--tail <数字>       			显示最后多少条

- docker top <容器ID>         				查看容器里的进程

- docker inspect <容器ID>     				查看容器内部细节

- docker exec -it 容器ID bashShell			进入容器执行shell操作，直接返回结果
                   +  /bin/bash   			进入容器终端 
- docker attach 容器ID						进入容器终端

- docker cp 容器ID:/tep/yum.log  /root       拷贝容器内路径 到 宿主机路径

- Docker的三大特征
    容器
    镜像
    仓库

- Docker包含两方面技术
    - 镜像技术
        打破“代码即应用”的观念 ==》映像档即应用
        从系统环境开始，自底至上打包应用（内核、操作系统发行版、运行依赖包、运行环境、配置环境、运行文档）

- 是一种轻量级、可执行的独立软件包，用来打包 运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。
1. UnionFS（联合文件系统）
	是一种分层的、轻量级的、高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。nuion文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像，可以制作各种具体的应用镜像。
	特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会吧各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录.

2. Docker镜像加载原理
	- docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
	- bootfs主要包含bootLoader和kernel，bootLoader主要是应道加载kerner，linux刚启动时会加载bootfs文件系统，在docker镜像的最底层是bootfs。
	- rootfs，在bootfs之上。包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等

	- docker中的cenos镜像为什么这么小，因为不同版本的linux系统的bootfs是公用的，只有rootfs是不同的。

3. 分层的镜像
	- 一层包一层，kerner<centOs<jdk<tomcat
	- 
4. 为什么Docker镜像要采用这种分层结构呢

- Docker镜像都是只读的
- 当容器启动时，一个新的可写层被加载到镜像的顶部
- 这一层通常被称为“容器层”，“容器层”之下的都叫做“镜像层”

- 对容器里面的数据进行持久化
- 容器之间希望有可能共享数据

- 容器的持久化
- 容器间继承 + 数据共享
- 宿主机与容器之间的数据共享	

- 特点
	* 数据卷可容器之间共享或重用数据
	* 卷中国的更改可以直接生效
	* 数据卷中的更改不会包含在镜像的更新中
	* 数据卷的生命周期一直持续到没有容器使用它为止

- 容器内添加
	- 直接命令添加
		- 命令			
			- docker run -it -v /宿主机绝对路径目录：/容器内目录 镜像名			加容器数据卷
		- 两个目录（容器和宿主机）之间建立连接，达到数据共享
		- 查看数据卷是否挂载成功  		
			- docker info		Volumes、VolumesRW
		- 容器停止退出后，主机修改后数据是否同步
			- 是同步的
		- 命令（权限）
			- docker run -it -v /宿主机绝对路径目录：/容器内目录:ro 镜像名		加容器数据卷（容器中只读）		
	- DockerFile添加
		- 是什么
			- 镜像的描述文件
		- 步骤：
			1. 根目录下新建mydocker文件并进入，添加并编辑Dockerfile文件
			2. 可在Dokcerfile中使用VOLUME指令来给镜像添加一个或多个数据卷
			3. File构建  
					# volume test
					FROM centos
					VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2","/dataVolumeContainer3"]
					CMD echo "finished ,---------success1"
					CMD /bin/bash
			4. build后生成镜像
				docker build -f /mydocker/Dockerfile -t myip_father .
			5. run容器，docker容器信息查看分析
				1. 宿主机自动指定容器卷地址
				2. 容器中指定地址生成容器卷
				3. 两个容器卷地址可以实现数据共享
		- 
	- 备注
		- 如果Docker挂载主机目录Docker访问出现cannot open directory.:permission denied 异常，权限异常
			- 解决办法，在挂载目录(run -v 路径)后多加一个 --privileged=true 参数即可

- 是什么
	- 命名的容器挂载数据卷，其它容器通过挂载这个（父容器）实现数据共享，挂载数据卷的容器，称之为数据容器卷
	- 链式数据传递共享
- 
- 容器间传递共享(--volumes-from)
	1. 启动一个父容器
		- docker run -it --name dc01 zzyy/centos	启动一个容器并进入，进入数据卷添加数据
	2. dc02/dc03继承自dc01  --volumes-from	达到多容器的数据共享
		- docker run -it --name dc02 --volumes-from dc01 zzyy/centos
		- docker run -it --name dc03 --volumes-from dc01 zzy y/centos
	3. 删除dc01，dc02与dc02里的数据卷依旧保留，并且相互之间共享数据
	4. 启动dc04容器，继承dc03。可以继承dc03中所有数据卷
	5. 删除dc03，dc04与dc02里的数据卷依旧保留，并且相互之间共享数据

1. Dockerfile是用来构建docker镜像的构建文件，是由一系列命令和参数构成的脚本
2. 构建3步骤
	- 手动编写一个dockerfile文件，必须要符合file的规范
	- 直接docker build命令执行，获得一个自定义的镜像

- DockerFile内容基础知识
	1. 每条保留字指令必须为大写且后面要跟至少一个参数
	2. 指令按照从上到下顺序执行
	3. #表示注释
	4. 每条指令都会创建一个新的镜像层，并对镜像进行提交 **
- Docker执行Dockerfile的大致流程
	1. docker从基础镜像运行一个容器
	2. 执行一条指令并对容器做出修改
	3. 执行类似docker commit的操作提交一个新的镜像
	4. docker在基于刚提交的镜像运行一个新容器
	5. 执行dockerfile中的下一条指令直到所有指令都执行完成
- 小总结
	- 从应用软件的角度来看，Dockerfile、Docker镜像、Docker容器分别代表软件的三个不同阶段
		- DockerFile是软件的原材料
		- Docker镜像是软件的交付品
		- Docker容器是则可以任务是软件的运行态
	- Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合理充当Docker体系的基石

- FROM						当前新镜像是基于哪个镜像的
			- scratch		Docker基础镜像
- MAINTAINER				镜像维护者的姓名和邮箱地址
- RUN						容器构建过程中需要运行的linux命令
- EXPOSE					当前容器对外暴露出的端口
- WORKDIR					指定在创建容器后，进入终端时，默认进入的工作路径
- ENV						在构建镜像过程中，设置环境变量
- ADD						将宿主机目录下的文件拷贝进镜像，且ADD命令会自动处理URL和解压tar压缩包	
- COPY						类似于ADD，拷贝文件和目录到镜像中
			- COPY src dest
			- COPY  ["src","dest"]
- VOLUME					添加容器数据卷，用于数据保存和持久化工作
- CMD						指定一个容器启动时要运行的命令
							Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换
- ENTRYPOINT				指定一个容器启动时要运行的命令
							ENTRYPOINT的作用类似CMD，但会追加指令，不是替换
- ONBUILD					触发器,此Dockerfile构建的镜像，在被子镜像继承(FROM)时,hui 触发onbuild指令后的操作指令

* 使用Dockerfile创建Centos(tomcat+jdk)镜像
    #指定操作的镜像
    FROM centos
    # 维护者信息
    MAINTAINER biubiu
    #执行命令：创建目录
    RUN mkdir -p /usr/local/soft
    #将jdk1.8.0_171添加到镜像centos的/usr/local/soft/目录下，并命名为jdk
    ADD jdk1.8.0_171 /usr/local/soft/jdk
    #将apache-tomcat-8.5.31添加到镜像centos的/usr/local/soft/目录下，并命名为tomcat
    ADD apache-tomcat-8.5.31 /usr/local/soft/tomcat
    #添加环境变量
    ENV JAVA_HOME /usr/local/soft/jdk
    ENV CATALINA_HOME /usr/local/soft/tomcat
    ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin
    #暴露8080端口
    EXPOSE 8080
    #启动时运行tomcat
    CMD ["/usr/local/soft/tomcat/bin/catalina.sh","run"]

- 搜
- 拉
- 看
- 启
- 停
- 删

-

- docker pull mysql:5.6
- docker run -p 3306:3306 --name mysql                              #端口映射
            -v /devlop/mysql/conf:/etc/mysql/conf.d                #配置
            -v /devlop/mysql/logs:/logs                            #日志
            -v /devlop/mysql/data:/var/lib/mysqls                  #数据
            -e MYSQL_ROOT_PASSWORD=123456                           #配置环境
            -v /etc/localtime:/etc/localtime                 # 共享主机时间
            -d mysql:5.6                                            #配置环境

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

docker run -p 3306:3306 --name mysql -v /home/mysql/conf:/etc/mysql/conf.d  -v /home/mysql/logs:/logs   -v /home/mysql/data:/var/lib/mysqls  -v /etc/localtime:/etc/localtime  -e MYSQL_ROOT_PASSWORD=foco123123. -d mysql

- 数据库备份至宿主机路径中：
    docker exec 容器ID sh -c ' exec mysqldump --all-databases-uroot -p"123456" '> /zyyuse/all-databases.sql

docker pull mysql:5.7

docker run -p 3306:3306 --name mysql5.7 \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
-d mysql:5.7                                     #配置环境

-p 3306:3306 --name mysql \             # 将容器的3306端口映射到主机的3306端口，'\'指换行符，下同
-v /mydata/mysql/log:/var/log/mysql \   # 将配置文件夹挂载到主机,冒号左边为Linux的目录结构，右边为docker内部的
-v /mydata/mysql/data:/var/lib/mysql \  # 将日志文件夹挂戟到主机
-v /mydata/mysql/conf:/etc/mysql \      # 将配置文件夹挂载到主机
-e MYSQL_ROOT_PASSWORD=123456 \         # 初始化root用户的密码为：123456
-d mysql:5.7


docker run -d -p 3306:3306 --privileged=true -v /docker/mysql/conf/my.cnf:/etc/my.cnf -v /docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name lcoal_mysql_5.7 mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci

- mac安装指令
docker run -p 3306:3306 -v /Users/xxxxx/devlop/mysql/logs:/logs -v /Users/xxxxx/devlop/mysql/conf/my.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf -v /Users/xxxxx/devlop/mysql/data:/var/lib/mysql -v /etc/localtime:/etc/localtime -e MYSQL_ROOT_PASSWORD=123456 --name lcoal_mysql_5.7 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci

*** 2022-06-08使用，本地新建/Users/xxxxx/devlop/mysql/conf/my.cnf配置后使用挂载
docker run -p 3306:3306  --privileged=true -d  -v /Users/xxxxx/devlop/mysql/conf/my.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf  -v /Users/xxxxx/devlop/mysql/logs:/logs -v /Users/xxxxx/devlop/mysql/data:/var/lib/mysql -v /etc/localtime:/etc/localtime -e MYSQL_ROOT_PASSWORD=123456 --name lcoal_mysql_5.7  mysql:5.7 



- WARNING: IPv4 forwarding is disabled. Networking will not work.
    解决方法如下：
    vim /etc/sysctl.conf
    
    #配置转发
    net.ipv4.ip_forward=1

    #重启服务，让配置生效
    systemctl restart network
    
    #查看是否成功,如果返回为“net.ipv4.ip_forward = 1”则表示成功
    sysctl net.ipv4.ip_forward




- MySQL跟随docker启动而启动
docker update mysql --restart=always


- 数据库备份至宿主机路径中：
    docker exec 容器ID sh -c ' exec mysqldump --all-databases-uroot -p"123456" '> /zyyuse/all-databases.sql


- 挂载参考：
- https://blog.csdn.net/ytsydmx/article/details/119741639
- https://blog.51cto.com/suyanzhu/2447815



*** 2022-08-02使用，windows系统 本地挂在启动


docker run -p 13306:3306  -v C:\z-dev\docker\mysql\logs:/logs -v C:\z-dev\docker\mysql\data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=dev.2022 --name lcoal_mysql_5.7 -d   mysql:5.7 




*** 2023-04使用Mac新mysql容器
docker run -p 3306:3306  --privileged=true -d  -v /Users/xxxxx/devlop/mysql/conf/my.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf  -v /Users/xxxxx/devlop/mysql/logs:/logs -v /Users/xxxxx/devlop/mysql/data:/var/lib/mysql -v /etc/localtime:/etc/localtime -e MYSQL_ROOT_PASSWORD=123456 --name lcoal_mysql_5.7_new  mysql:5.7

- docker pull redis
- docker run -p 6379:6379
            -v /zzyyuse/myredis/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
            
- 修改配置文件
    - 在主机/zzyyuse/myredis/conf/redis.conf目录下新建redis.conf文件
    /zzyyuse/myredis/conf/redis.conf/redis.conf         编辑redis配置
                
    -p 6379:6379 : 将容器的6379端口映射到主机的6379端口

    -v $PWD/data:/data : 将主机中当前目录下的data挂载到容器的/data
        
    redis-server --appendonly yes : 在容器执行redis-server启动命令，并打开redis持久化配置

# 创建并运行一个名为 myredis 的容器
docker run \
-p 6379:6379 \
-v $PWD/data:/data \
-v $PWD/conf/redis.conf:/etc/redis/redis.conf \
--privileged=true \
--name myredis \
-d redis redis-server /etc/redis/redis.conf

docker run \
-p 6379:6379 \
-v /Users/fenggs/devlop/redis/data:/data \
-v /Users/fenggs/devlop/redis/conf/redis.conf:/etc/redis/redis.conf \
--privileged=true \
--name myredis \
-d redis redis-server /etc/redis/redis.conf


# 命令分解
docker run \
-p 6379:6379 \ # 端口映射 宿主机:容器
-v $PWD/data:/data:rw \ # 映射数据目录 rw 为读写
-v $PWD/conf/redis.conf:/etc/redis/redis.conf:ro \ # 挂载配置文件 ro 为readonly
--privileged=true \ # 给与一些权限
--name myredis \ # 给容器起个名字
-d redis redis-server /etc/redis/redis.conf # deamon 运行 服务使用指定的配置文件

- 查看活跃的容器
    # 查看活跃的容器
    docker ps
    # 如果没有 myredis 说明启动失败 查看错误日志
    docker logs myredis
    # 查看 myredis 的 ip 挂载 端口映射等信息
    docker inspect myredis
    # 查看 myredis 的端口映射
    docker port myredis

- IP 查看
    docker inspect e60da5191243|grep -i add
    
- docker exec -it 容器ID redis-cli  进入redis客户端
- SHUTDOWN         退出客户端



---- redis配置外网访问：

更改redis.conf 文件
bind 127.0.0.1
protected-mode yes
更改为:
# bind 127.0.0.1
protected-mode no

redis通过配置文件设置密码
# requirepass foobared
requirepass yourpassword

//linux方式
docker run --name mynginx -d -p 80:80 
-v /usr/data/nginx/www:/usr/share/nginx/html
-v /usr/data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
-v /usr/data/nginx/logs:/var/log/nginx
-d docker.io/nginx

//mac上,存在nginx.conf文件、夹文件问题,
docker run --name mynginx -d -p 88:80 -v /Users/fenggs/devlop/nginx/www:/usr/share/nginx/html -v /Users/fenggs/devlop/nginx/config:/etc/nginx/nginx.conf -v /Users/fenggs/devlop/nginx/logs:/var/log/nginx
 docker.io/nginx

# -management 表示有管理界面的
docker pull rabbitmq:management
docker run -d -p 5672:5672 -p 15672:15672 --name rabbitmq rabbitmq:management
# 用户名/密码： guest/guest

1. docker pull mongo

2. 使用自定义配置文件启动mongo
    docker run --name some-mongo -v /my/custom:/etc/mongo -p 27017:27017  -d mongo --config /etc/mongo/mongod.conf
    
3. 使用环境变量配置初始化账号密码
    docker run -d --name some-mongo -p 27017:27017  -e MONGO_INITDB_ROOT_USERNAME=mongoadmin -e MONGO_INITDB_ROOT_PASSWORD=secret mongo
    
4. 数据持久化
    docker run --name some-mongo -v /my/own/datadir:/data/db -d mongo
    
5. 数据导出
    docker exec some-mongo sh -c 'exec mongodump -d <database_name> --archive' > /some/path/on/your/host/all-collections.archive
    
    
    
结合：

    docker run --name mymongo -v /my/custom:/etc/mongo   -v /my/own/datadir:/data/db  -e MONGO_INITDB_ROOT_USERNAME=root -e MONGO_INITDB_ROOT_PASSWORD=123456   -d mongo --config /etc/mongo/mongod.conf
    
    
   docker run --name mymongo -v /Users/fenggs/devlop/mongodb/etc/mongo:/etc/mongo   -v /Users/fenggs/devlop/mongodb/data/db:/data/db -p 27017:27017  -d mongo

- 将本地images镜像push到阿里云Dockers Registry或者私有Docker Registry

- dockers commit -a 作者名 -m "注释信息" 容器ID+版本号 新镜像名

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
OPTIONS说明：
-a :提交的镜像作者；
-c :使用Dockerfile指令来创建镜像；
-m :提交时的说明文字；
-p :在commit时，将容器暂停。
eg:docker commit -a "runoob.com" -m "my apache" a404c6c174a2  mymysql:v1

- 登录阿里云账号，进入镜像列表
- 新建仓库，设置命名空间和仓库名称等信息
- 将镜像推送到阿里云里新建的仓库
    1. 连接阿里云远程仓库
        $ sodo my docker login --username=registry.cn-hangzhou.aiyuncs.com
    2. 输入账户密码
    3. 选择镜像
        docker tag 镜像ID registy.cn-hangzhou.aliyuncs.com/zzyybuy/mycentos:1.5.1
    4. 推送镜像
        docker push registry.cn-hangzhou.aliyuncs.com/zzyybuy/mycentos:1.5.1
    5. 阿里云dockethub里可以搜到上传的镜像

- 通过dockers pull拉取远程仓库的docker镜像