docker_镜像的补充，，容器操作，，其他容器操作； 应用部署：mysql部署，redis部署 迁移备份；Dockerfile的介绍，，命令 ，，乌班图

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 镜像
    docker pull 名字:标签
    docker images
    docker rmi 镜像id
    ---------
    docker push 本地镜像 # 把本地镜像推送到自己仓库
     
# 容器：镜像运行起来成为一个个容器，一个容器，就当成是一个虚拟机装了个操作系统
    docker ps
    docker ps -a
    docker stop 容器id
    docker start 容器id
    docker rm 容器id
    

容器操作

 run

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# 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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 一次性删除所有容器
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# -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;  # 查看所有数据库

其他

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
# 启动容器
    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 部署

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 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部署

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 拉取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部署

?
1
2
3
4
5
6
7
8
9
# 拉取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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# 镜像从哪来的？
    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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 镜像从哪里来的？
    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     # 设置工作目录，运行起这个容器，来到的路径就是这个路径

小案例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 构建一个带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，和文件夹，文件是否存在

常用和不常用命令

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 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　

　　

　　

　　

　　

　　

　　

　　

 

　　

　　

　　

 

posted @   拆尼斯、帕丁顿  阅读(11)  评论(0)  编辑  收藏  举报
相关博文：
·  docker_迁移备份（镜像？） Dockerfile的介绍；常用命令，，案例1/2，，ARG演示，，docker私有仓库，，搭建
·  docker_项目演示，， docker介绍_虚拟化？ docker与传统虚拟机比较； docker架构---安装和配置 镜像/容器操作 ，，注册--远程仓库
·  迁移备份、Dockerfile、docker私有仓库
·  Docker 镜像创建之dockerfile
·  docker学习
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· .NET Core 中如何实现缓存的预热？
· 三行代码完成国际化适配，妙~啊~
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
点击右上角即可分享
微信分享提示
SQL AI 助手