# 镜像
	docker pull 名字:标签
    docker images
    docker rmi 镜像id
    ---------
    docker push 本地镜像 # 把本地镜像推送到自己仓库
    
# 容器：镜像运行起来成为一个个容器，一个容器，就当成是一个虚拟机装了个操作系统
	docker ps
    docker ps -a
    docker stop 容器id
    docker start 容器id
    docker rm 容器id
    

容器操作

 run

# run ：运行容器
	-如果容器不存在，会先创建再运行
    -create 容器，run运行
    - 创建并运行容器
    
    
# 运行一个centos7容器
	docker run -id --name=容器名字 镜像:标签   # 创建并运行容器，命令行在宿主机上
    docker run -it --name=容器名字 镜像:标签   #创建并运行容器，命令行在容器内部
    
    
#### 容器要运行，内部必须有个前台进程阻塞，否则容器就会停掉###




#1 docker run 把镜像运行成容器
	-docker run 参数
    	-i 表示运行容器
        -d 以守护式容器在后台运行，用这个参数创建出来的容器，命令行还在宿主机上，没有进入到容器内部
        -t 表示容器启动后会进入容器命令行。加入这参数后，容器创建就能登录进去。即分配一个伪终端。
        --name 指定容器名字，如果不指定，会随机一个名字
        -p 表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
        -v 表示目录映射关系（前者是宿主机目录，后者是容器的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上
        
        
        
# 2 案例 -id
	docker run -id --name=centos centos:7  # 执行完，命令在宿主机上，可以通过命令查看正在运行的容器
        
# 3 案例  -it
docker run -it --name=centos centos:7 # 执行完，命令行在容器内，容器很干净，几乎啥软件都没有，可以exit退出到宿主机---》只要退出，容器就停了
    

    
# 4 创建一个python3.9容器---》不进入
	docker run -id --name=python python:3.9
        
        
# 5 启动一个centos容器并且进入,名字叫mycentos，在内部装个vim，然后退出
	1 docker run -id --name=mycentos centos:centos7
    2 在宿主机
    3 docker exec -it mycentos /bin/bash  # 新开了一个bash进程
    4 yum install vim -y
    5 exit
    6 容器停还是没有停？没有，因为容器运行时的 bash 进程没有结束
    
    

# 6 重点：
	如果创建容器并进入---》只要退出---》容器就停了
    容器要运行，必须有个前台进程在运行，并且是夯住（阻塞）的，否则容器就停了
    
# 7 进入到容器内部
	# 在容器上执行命令
	docker exec 容器名字/id  命令
    # 利用这个特性-->进入到容器内部
    docker exec -it 容器名字/id /bin/bash
    docker exec -it python sh
    # 退出，结束掉 /bin/bash
	exit

-v

# 一次性删除所有容器
docker rm `docker ps -a -q`
# 一次性删除所有镜像
docker rmi `docker images -q`


###################
# 运行出一个 centos77 容器，不进入， 做目录映射
# 把宿主机的 /root/lqz文件夹  映射到 容器内部的 /lqz文件夹
# -v可以写多个，可以是文件或文件夹

1 cd # 回家 前提是你是root用户
2 mkdir lqz  # 在root目录下创建lqz文件夹
3 运行容器，做目录映射
docker run -id --name=centos77 -v /root/lqz:/lqz centos:centos7
4 在宿主机的 /root/lqz 下新建 xx.txt
vim xx.txt

5 来到容器内部：看这个文件在不在
cat xx.txt

6 他们是相互影响的：
    容器内部修改文件---》会影响外部
    外部修改文件---》影响内部



# 目录映射好处是，后期咱们部署django项目
	1 有个django容器，做好映射，代码放在宿主机上即可，以后更新了代码，只要重启容器，代码就是最新了
    2 运行mysql容器---》mysql配置文件，数据data目录，放在宿主机上做好映射
    	如果 mysql容器---》表数据，放到容器中---》如果删了容器---》数据库全没了
    	表数据，放在宿主机上---》把容器删除---》表数据还在----》再启动一个容器做好映射---》数据都还在

-p

# -p参数：端口映射  容器中启动一个mysql5.7 --》容器中的3306监听，宿主机3306没人监听，做端口映射后，宿主机的3306就被docker的这个容器监听了

# 启动的mysql的root密码是123456

# 启动mysql容器  -p 宿主机端口:容器端口
# 以后台守护进程运行mysql容器，mysql的root用户密码是123456，宿主机和容器做了端口映射
docker run -id --name=mysql5.7 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7


#  netstat -nlp |grep 3307 查看本机80端口占用情况
# 查看宿主机 3307端口占用情况
yum install net-tools -y
netstat -nlp | grep 3307 # 被docker占了

# 以后访问宿主机3307端口就等于访问容器的3306端口

# win机器可以远程链接 mysql
	-命令行链接：mysql -h 10.0.0.110 -P 3307 -uroot -p
    -Navicate： 链接，创建lqz数据库
    -python：
    
# 宿主机--》进入到容器内部--》进入到mysql，查看有没有创建lqz这个库
	docker exec -it mysql5.7 /bin/bash # 进入容器内部
    mysql -uroot  -p  # 进入mysql
    show databases;  # 查看所有数据库

其他

# 启动容器
	docker start 容器id
# 停止容器
	docker stop 容器id

    
### mysql的容器底层的操作系统是 debian 装软件需要用 
apt-get update
apt-get install vim -y



# 文件拷贝(宿主机执行)
	# 容器的文件copy到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  0a9633190cb9:/xx.txt /root/lqz/lqz.txt
    # 宿主机的文件copy到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp /root/lqz/xx.txt  0a9633190cb9:/xx.txt

        
        
        
# 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
    docker inspect 0a9633190cb9 --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
    
    
# 在多个容器之间是可以ping通的(容器和宿主机也可以)
# python:172.17.0.3

# mysql5.7:172.17.0.2

# 宿主机--》ping 它俩
# 容器--》容器
apt-get install iputils-ping
 ping 172.17.0.2

    
    
    
    
# 删除容器（删除已停止的容器）
	docker rm 容器id  
    docker rm `docker ps -a -q`
    
    

    

    
# 无状态的服务（在容器中尽量运行无状态的服务）
    -mysql reids   有状态，运行过程中产生数据，保存，容器删除，数据就没了
    -uwsgi+django  无状态的服务
    
  
    
    
    
    
# 补充
	1 ip地址  ip 
    	10.0.0.110
        10.0.0.111
        10.0.0.1
        10.0.110.1
    2 子网掩码 mask
    	255.255.0.0
        
    3 网关 gatway
    	10.0.0.1

应用部署

 mysql 部署

# dokcer 中部署mysql，以后不需要在宿主机上装mysql
	

#1  没有做目录映射---》配置文件--》表数据都在容器中---》一旦删除--》所有都没了
docker run -di --name=mysql -p 3308:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7


# 2 做目录(配置文件和数据文件)和端口映射

# 做目录映射：data文件，配置文件
# 创建文件夹
mkdir /mysql
mkdir /mysql/conf.d
mkdir /mysql/data/
vim /mysql/my.cnf
[client]
default-character-set=utf8
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000

docker run  -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3306:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7      
        
     
    
# 创建库，创建表，插入数据

# 关闭容器，删除容器，myslq的容器没了，但是数据在宿主机上放着
 docker stop mysql2
 docker rm mysql2
##docker rm mysql -f  容器之间删了

# 再运行起一个容器，做好目录映射，数据都回来了
docker run  -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3307:3306 --name mysql2 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

redis部署

# 拉取redis镜像
docker pull redis  #最新
mkdir /root/data
vim /root/redis.conf

bind 0.0.0.0
daemonize NO
protected-mode yes
requirepass 123456



# 运行
#启动容器时，运行的命令是什么 redis-server /etc/redis/redis.conf

docker run -id  -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf
       
    
# 在容器运行时，可以自己定制运行命名 举例：docker run -id centos:centos7 ls

            
     
    
# 远程链接redis操作

nginx部署

# 拉取nginx镜像
docker pull nginx

# run起容器
# docker run -id --name nginx -p 80:80 nginx
    
# /usr/share/nginx/html
docker run -id --name nginx1 -p 8088:80 -v /root/html:/usr/share/nginx/html nginx
# 以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的

迁移备份

# 镜像从哪来的？
	1 docker pull 拉的
    2 通过容器打包成镜像
    	-centos镜像运行成容器---》装了vim
        -把装了vim的容器---》打包成镜像
        -以后拿到这个镜像--》再运行成容器，都会带vim命令
        
    3 Dockerfile构建
    


# 容器保存为镜像
	-运行一个centos容器
    docker run -id --name centos_vim centos:centos7
    -在容器中装vim
    docker exec -it a6e240 /bin/bash
	yum install vim -y
    
    -把容器做成镜像（centos+vim）
    docker commit centos_vim centos_vim_image

    -把centos_vim 容器删除
    docker rm centos_vim -f
    -基于新构建的镜像，运行成容器
    docker run -id --name centos_vim centos_vim_image:latest
    -进入到容器中，查看，软件都在
    docker exec -it c3e633bd1 /bin/bash

    
 
# 本地镜像---推送到远端docker仓库中---》私有仓库
	-早期 这个是免费的---》后期好像收费
    
    -给镜像打个tag 
    docker tag 镜像id  镜像新名字(账号名/镜像名)
    -登录到你账号中  docker login  输入账号密码
    
    
    -docker push 镜像名字
    	docker push 镜像新名字
    -别人就可以下载了
     
 
    
# 镜像备份和恢复
	docker save -o centos_vim_image.tar centos_vim_image
    -删除容器，删除镜像
    -把备份的镜像恢复
    docker load -i centos_vim_image.tar

Dockerfile

 dockerfile介绍和常用命令

# 镜像从哪里来的？
	1 远程仓库拉取的 docker pull   （hub.docker---》搭建私有仓库）
    2 用容器做成的镜像 docker commit 
    3 把备份的恢复 docker load
    4 使用Dockerfile来构建(这种多)
    


    
# 什么是Dockerfile
	Dockerfile是由一系列命令和参数构成的脚本文件，这些命令应用于基础镜像并最终创建一个新的镜像
    
    
    # centos7中，装了vim，在根路径下新建了一个文件 lqz.txt,写了写内容
    
# Dockerfile的命令
	FROM 基础镜像 	       #基于哪个基础镜像来构建
    MAINTAINER lqz 	     # 声明镜像的创建者
    ENV key value 	     # 设置环境变量 (可以写多条)
    RUN command 	     #是Dockerfile的核心部分(可以写多条)
    ADD source_dir/file dest_dir/file 	#将宿主机的文件复制到镜像内，如果是一个压缩文件，将会在复制后自动解压
    COPY source_dir/file dest_dir/file 	# 和ADD相似，但是如果有压缩文件并不能解压
    WORKDIR lqz 	# 设置工作目录，运行起这个容器，来到的路径就是这个路径

小案例

# 构建一个带vim的centos:7镜像,根路径下有/lqz/ss.py


vim Dockerfile

FROM centos:7
MAINTAINER lqz
ENV name lqz
RUN yum install vim -y
RUN mkdir /lqz
RUN touch /lqz/ss.py
RUN echo 'print(1)' > /lqz/ss.py
COPY ./aa.txt /lqz/aa.txt
WORKDIR /lqz




# 基于dockerfile构建镜像,不要忘了 .   基于当前路径下的Dockerfile 构建降序
docker build -t='centos_lqz_vim' . 
docker images
# 基于这个镜像运行容器
 docker run -id --name xx centos_lqz_vim
# 进入到容器
docker exec -it xx /bin/bash
# 验证vim，和文件夹，文件是否存在

常用和不常用命令

# https://zhuanlan.zhihu.com/p/419175543?utm_id=0

FROM: 指定基础镜像
RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
EXPOSE：设置对外暴露的端口。
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
COPY：将本地文件或目录拷贝到镜像的文件系统中。
VOLUME：添加数据卷
USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
WORKDIR：设置工作目录





# docker logs 容器名字/id号  查看镜像运行成容器时，错误日志


# CMD  ENTRYPOINT
#相同点：
只能写一条，如果写了多条，那么只有最后一条生效。
容器启动时才运行，运行时机相同。
# 不同点：
ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数


# 案例Dockerfile

FROM centos:7
ARG age=19   # 一定要等于
RUN echo $age
CMD /bin/bash

# docker build -t='xxxx' . 

dockerfile构建一个djagno项目（books图书管理系统）

# 以图书管理系统为例---》公司使用docker流程



# 公司中，使用Docker开发的工作流程
第一步：有一个项目，pycharm开发着，开发完后
第二步：在项目路径下新建Dockerfile，写入
FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requirements.txt /soft/requirements.txt
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
CMD ["python","manage.py","runserver","0.0.0.0:8080"]
第三步：把代码提交到git



------------------
第四步：上线人员：在上线机器上，把代码啦下来
git clone https://gitee.com/liuqingzheng/books.git
第五步：构建镜像
docker build -t='django_books' .
第六步：运行容器
docker run -id --name=books -v /root/lqz/books:/soft -p 8080:8080 django_books:latest
第七步：其它人访问宿主机的8080端口就能看到项目了

---------
第八步：开发人员继续提交代码
第九步：运维人员pull代码，重启容器，用户就可以看到最新的了

重启docker容器即可(第三方依赖变了)--》重写构建镜像，运行容器

乌班图构建redis（跟底层宿主机无关）

https://zhuanlan.zhihu.com/p/623811065