Docker

Docker

1 docker介绍

1.1 虚拟化

在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。
 
在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件  对资源充分利用
 
虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。
 
 
# kvm,VMware,openstack,docker,k8s
	-kvm,vmware:虚拟化软件
    -openstack，阿里飞天：虚拟化软件管理web项目 -- python
    
    -docker：容器化
    -k8s：容器管理编排

image-20240620154409479

1.2 docker

Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 加了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在上进行维护。
 
容器化技术，区分于虚拟机，又类虚拟机，兼具虚拟机隔离的优点，又有速度快的优点
容器资源隔离，网络隔离
把容器当成一个虚拟机即可
 
docker 容器管理 
	-docker swarm
	-k8s
 
Docker 的基础是 Linux 容器（LXC）等技术

1.3 docker和其他虚拟机比较

# docker 不需要虚拟化出操作系统这一层---》更轻量级--占空间更小---》还能实现隔离
 
# 虚拟机技术的缺点：
    1.资源占用太多
    2.冗余步骤多
    3.启动很慢
 
# 容器化技术
1.服务器资源利用率高
2.比较轻量化
3.打包镜像测试，一键运行
 
 
 
比较Docker和虚拟机技术不同：
​ 1.传统虚拟机，虚出一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
​ 2.容器内的应用之间运行在 宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
​ 3.每个容器间是互相隔离的，每个容器内都有属于自己的文件系统，互不影响
​ 4.安全性，docker的安全性更弱
​ 5.与虚拟机相比，docker隔离性更弱，docker属于进程之间的隔离，虚拟机可实现系统级别隔离
​ 6.docker创建时秒级的，docker的快速迭代性，无论是开发、测试、部署都可以节约大量时间

image-20240620154509458

1.4 docker架构

# cs 架构---》客户端服务端
	- c 端：用户操作，输入命令
    - s 端：接收用户命令，执行
    - c、s通信，使用http协议，遵循restful规范
    	-mysql：tcp---》自定义的  
        -redis：tcp---》自定义的  
        
        
  # 架构
	1 client：客户端，输入命令
    2 服务端：
    	containers：容器
        images:镜像--》从注册中心下来下来的
        
    3 register：注册中心
    	-放了很多镜像--》redis，nginx，mysql

image-20240620154547869

1.5 docker命令

systemctl start docker  # 启动docker服务
 
systemctl stop docker  # 停止docker服务
 
systemctl restart docker  # 重启docker服务
 
docker -v # 查看docker版本

2 docker安装和配置

2.1 centos安装

windows-docker : https://www.docker.com/products/docker-desktop/

# 1 卸载
# yum remove docker docker-common  docker-selinux docker-engine
# rm -rf /var/lib/docker
yum update  # 更新yum仓库
 
# 2 安装
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum install docker-ce -y
 
 
# 3 查看安装的版本
docker --version
 
# 4 目前我们只装了 docker-ce，
	-只有：c  和 s端
    -没有docker-compose
    -没有图形化界面
    -跟docker-destop的区别
    
    
# 5 启动docker
systemctl start docker
 
# 6 查看docker状态
systemctl status docker
 
 
# 7 镜像--》从远程下载下来的---》hub.docker.com -->仓库下的
	-有非常多镜像：可以搜索，搜到以后，镜像有不同版本
    -目前：访问不到了，拉取不下来
    -配置：国内镜像站：阿里云
    -https://cr.console.aliyun.com/cn-shanghai/instances/mirrors
        
    sudo mkdir -p /etc/docker # 如果有，就不需要创建了
    vi /etc/docker/daemon.json 
    
    # 加入
    {
        "registry-mirrors": [
            "https://registry.docker-cn.com",
            "http://hub-mirror.c.163.com",
            "https://docker.mirrors.ustc.edu.cn",
            "https://dockerhub.azk8s.cn",
            "https://mirror.ccs.tencentyun.com",
            "https://registry.cn-hangzhou.aliyuncs.com",
            "https://docker.mirrors.ustc.edu.cn"
        ]
    }
    
    systemctl daemon-reload   # 重新加载docker配置
    systemctl restart docker  # 重启docker

2.2 ubuntu安装

# 卸载原有Docker（如果已安装）
sudo apt-get remove docker docker-engine docker.io containerd runc
# 更新软件包列表
sudo apt-get update
# 安装Docker依赖
sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
# 添加GPG密钥
# 从Docker官方获取GPG密钥
# 官方获取GPG密钥出现timeout问题，可以从阿里云源获取GPG密钥
# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
# 从阿里云源获取GPG密钥：
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
# 添加Docker软件源 添加Docker官方软件源到APT源列表（这里使用的是阿里云的Docker镜像源）：
sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
# 注意：
# $(lsb_release -cs) 需要替换成自己的ubuntu版本
# 查看自己的ubuntu版本，终端输入以下命令：
lsb_release -c
 
# 安装Docker CE
# 更新软件包列表
sudo apt-get update
# 安装Docker CE
sudo apt-get install docker-ce docker-ce-cli containerd.io
# 验证Docker安装
docker -v
# 配置阿里云镜像加速
https://cr.console.aliyun.com/cn-shanghai/instances/mirrors
 
sudo mkdir -p /etc/docker
sudo nano /etc/docker/daemon.json
{
  "registry-mirrors": ["https://dxef3ui7.mirror.aliyuncs.com"]
}
sudo systemctl daemon-reload
sudo systemctl restart docker
# 重启docker服务
sudo systemctl restart docker
 
# 拉取镜像
sudo docker pull mysql:5.7 # 下载mysql 5.7镜像
sudo docker pull redis:latest # 下载redis最新的镜像
sudo docker pull nginx:latest  # 下载 nginx最新的镜像
sudo docker pull centos:centos7  # 下载 nginx最新的镜像

3 docker镜像操作

3.1 镜像和容器

# 镜像：images
	-一堆文件---》目前咱们从register---》下载---》放在宿主机（centos 7.9机器）
    -类比：虚拟上装系统
    	- 操作系统文件 xx.iso--->装在虚拟机上
        - 镜像你当成 xx.iso 操作系统文件
        - 把iso装在不同虚拟机中---》启动---》多台有操作系统的机器
# 容器：container
	-镜像运行---》运行成容器
    -类比：
    	-容器当成一个正在运行的操作系统
    -一个镜像，可以运行成多个容器
    
    
    
# python面向对象
	类：镜像
    对象：实例化得到多个对象，每个对象间独立的
    
    
    
# 以后一个容器，你们当成 ：一个操作系统+软件--》正在运行

3.2 镜像操作

docker search : 搜索

docker pull : 拉取镜像

docker images : 查看镜像

docker rmi : 删除镜像

docker rmi `docker images -q` : 一次性删除所有镜像
# 0 搜索镜像
	-去网站搜：https://hub.docker.com/ 
	-使用命令行搜：docker search mysql
    
# 1 获取镜像，拉取镜像---》从register下载到本地--》阿里云镜像站--》加速拉取
	docker pull mysql:5.7 # 下载mysql 5.7镜像
	docker pull redis:latest # 下载redis最新的镜像
    docker pull nginx:latest  # 下载 nginx最新的镜像
    docker pull centos:centos7  # 下载 nginx最新的镜像
    
# 2 查看镜像
	docker images
    
# 查看所有镜像的id号
	docker images -q
 
# 3 删除镜像
	docker rmi redis:latest
        
# 一次性删除所有镜像
	docker rmi `docker images -q`

4 容器操作

镜像运行，变成容器，一个镜像可以运行处多个容器，把一个容器当成一个虚拟机

一个容器可以有操作系统、文件、软件、网络等

4.1 run

-id ：启动容器，不进入容器内部

-it ：启动容器，进入容器内部

--name ： 指定容器名字，容器名字不能重复，如果重复就报错，可以随便起

centos:centos7 ：基于哪个镜像运行成容器

# 1 把镜像运行成容器 
# 运行，如果镜像没有，会去远程仓库下载
docker run -id --name=centos7 centos:centos7
 
# 2 查看正在运行的容器
docker ps
 
# 3 执行：docker run -it  centos:centos7
进入到容器内部，可以执行centos的命令，但是它是最精简的系统，很多命令可能没有，用的话需要安装
退出容器，回到宿主机：exit
 
# 4 容器需要创建然后运行，其实直接run就可以，最后一步会把前面没有写的给补完
	-创建：create命令
    -运行：run
 
# 5 容器要运行，内部必须有个前台进程阻塞，否则容器就会停掉
 
# 6 docker ps -a   #查看所有容器，包括停止的
 
# 7 删除容器
docker rm 容器名字/容器id
docker rm `docker ps -a -q` 一次性删除所有容器

image-20240620160819916

4.2 run的参数

-i : 表示运行容器

-d : 以守护式容器在后台运行，用这个参数创建出来的容器，命令行还在宿主机上，没有进入到容器内部

-t : 表示容器启动后会进入容器命令行。加入这参数后，容器创建就能登录进去。即分配一个伪终端

--name : 指定容器名字，如果不指定，会随机一个名字

-p : 表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

-v : 表示目录映射关系（前者是宿主机目录，后者是容器的目录），可以使用多个－v做多个目录或文件映射

注意：最好做目录映射，在宿主机上做修改，然后共享到容器上

4.2.1 几个小案例 docker exec

docker exec : 在宿主机连接容器执行命令，把结果返回给宿主机

# 1 启动一个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
    
    
# 2 docker exec  命令
	在宿主机连接容器执行命令，把结果返回给宿主机
    docker exec 容器名字/id ls
    
    
# 3  进入到容器内部
	# 在容器上执行命令
	docker exec 容器名字/id  命令
    # 利用这个特性-->进入到容器内部
    docker exec -it 容器名字/id /bin/bash
    docker exec -it python sh
    # 退出，结束掉 /bin/bash
	exit

4.3 -v 目录映射

-v : 运行容器时，跟宿主机的文件目录做映射

# 1 -v 参数表示运行容器时，跟宿主机的文件目录做映射
 
#2 小案例
    # 运行出一个 centos77 容器，不进入，做目录映射
    # 把宿主机的 /root/lqz文件夹  映射到 容器内部的 /lqz文件夹  容器如果没有文件夹会自动创建
    # -v可以写多个，可以是文件或文件夹
 
    1 cd # 回家 前提是你是root用户
    2 mkdir heart  # 在root目录下创建heart文件夹
    3 运行容器，做目录映射
    docker run -id --name=centos77 -v /root/heart:/heart centos:centos7
    4 在宿主机的 /root/heart 下新建 123.txt
    vim 123.txt
 
    5 来到容器内部：看这个文件在不在
    cat 123.txt
 
    6 他们是相互影响的：
        容器内部修改文件---》会影响外部
        外部修改文件---》影响内部
 
 
 
# 3 目录映射好处是，后期咱们部署django项目
	1 有个django容器，做好映射，代码放在宿主机上即可，以后更新了代码，只要重启容器，代码就是最新了
    2 运行mysql容器---》mysql配置文件，数据data目录，放在宿主机上做好映射
    	如果 mysql容器---》表数据，放到容器中---》如果删了容器---》数据库全没了
    	表数据，放在宿主机上---》把容器删除---》表数据还在----》再启动一个容器做好映射---》数据都还在

4.4 -p 端口映射

# 1  -p参数：端口映射  容器中启动一个mysql5.7 --》容器中的3306监听，宿主机3306没人监听，做端口映射后，宿主机的3306就被docker的这个容器监听了
 
# 2 小案例，运行一个mysql容器--》做端口映射
docker run -id --name=mysql5.7 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
#  -p ： 启动mysql容器  -p 宿主机端口:容器端口
#  -e ： 启动的mysql的root密码是123456
# 以后台守护进程运行mysql容器，mysql的root用户密码是123456，宿主机和容器做了端口映射
	宿主机 3307 映射容器 3306
 
    
## 2.1 查看宿主机 3307端口占用情况
 
    #  netstat -nlp |grep 3307 查看本机80端口占用情况
    # 查看宿主机 3307端口占用情况
    yum install net-tools -y
    netstat -nlp | grep 3307 # 被docker占了
 
## 2.2 远程链接宿主机的3307端口
	以后访问宿主机3307端口就等于访问容器的3306端口
 
    # win机器可以远程链接 mysql
        -命令行链接：mysql -h 10.0.0.110 -P 3307 -uroot -p
        -Navicate： 链接，创建lqz数据库
 
    # 宿主机--》进入到容器内部--》进入到mysql，查看有没有创建lqz这个库
        docker exec -it mysql5.7 /bin/bash # 进入容器内部
        mysql -uroot  -p  # 进入mysql
        show databases;  # 查看所有数据库

4.5 其他操作

#1 启动容器
	docker start 容器id
#2 停止容器
	docker stop 容器id
 
#3 mysql的容器底层的操作系统是 debian 装软件需要用 
    apt-get update
    apt-get install vim -y
 
 
#4 文件拷贝(宿主机执行)
	# 容器的文件copy到宿主机上（不是在容器内执行）
    docker cp 容器名称:容器目录 需要拷贝的文件或目录
    docker cp  0a9633190cb9:/xx.txt /root/lqz/lqz.txt
    
    # 宿主机的文件copy到容器中
    docker cp 需要拷贝的文件或目录 容器名称:容器目录
    docker cp /root/lqz/xx.txt  0a9633190cb9:/xx.txt
 
        
# 5 查看容器IP地址    
	docker inspect 容器名称  # 查看容器的详细描述，很多
    docker inspect 容器id/名称 --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
    
    
# 6 在多个容器之间是可以ping通的(容器和宿主机也可以)
    # python:172.17.0.3
 
    # mysql5.7:172.17.0.2
 
    # 宿主机--》ping 它俩
    # 容器--》容器
    apt-get install iputils-ping
     ping 172.17.0.2
 
# 7 删除容器（删除已停止的容器）
	docker rm 容器id  
    docker rm `docker ps -a -q`
    
   
# 8 无状态的服务（在容器中尽量运行无状态的服务）
    -mysql reids   有状态，运行过程中产生数据，保存，容器删除，数据就没了
    -uwsgi+django  无状态的服务
 
    
# 9 补充
	1 ip地址  ip 
    	10.0.88.110
        10.0.0.111
        10.0.0.1
        10.0.11.1
    2 子网掩码 mask
    	255.255.0.0
        
    3 网关 gatway
    	10.0.0.1

5 应用部署

5.1 mysql 部署

#0 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/
vi /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 -id -v /mysql5.7/data/:/var/lib/mysql -v /mysql5.7/conf.d:/etc/mysql/conf.d -v /mysql5.7/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 
 
 
 
# 补充  -e参数--》环境变量
	-不同镜像提供不同参数
    -传入后放入环境变量
    echo $MYSQL_ROOT_PASSWORD # 查看值

5.2 redis部署

#1  拉取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操作

5.3 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 8008:80 -v /root/html:/usr/share/nginx/html nginx
# 以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的

6 迁移与备份

容器保存为镜像

# 容器保存为镜像步骤
# 运行一个centos容器
docker run -id --name centos centos:centos7
# 在容器中装vim
docker exec -it centos /bin/bash
yum install vim -y
# 把容器做成镜像（centos+vim）
			 (容器名字)
docker commit centos centos_vim_image
# 基于新构建的镜像，运行成容器
docker run -id --name centos_vim centos_vim_image:latest
# 进入到容器中，查看，软件都在
docker exec -it bc83707ed025 /bin/bash
 
# 上传镜像步骤
# 给镜像打个tag
docker tag 镜像id  镜像新名字(账号名/镜像名)
# 登录账号
docker login
# 上传
docker push 镜像新名字
# 镜像备份和恢复 备份成tar压缩包
docker save -o centos_vim_image.tar centos_vim_img
# 把备份的镜像load恢复
docker load -i centos_vim_image.tar

7 Dockerfile

Dockerfile是由一系列命令和参数构成的脚本文件

这些命令应用于基础镜像并最终创建一个新的镜像

FROM 基础镜像 	      # 基于哪个基础镜像来构建
 
MAINTAINER heart 	 # 声明镜像的创建者
 
ENV key value 	     # 设置环境变量 (可以写多条)
 
RUN command 	     # 是Dockerfile的核心部分(可以写多条)
 
ADD source_dir/file dest_dir/file 	# 将宿主机的文件复制到镜像内，如果是一个压缩文件，将会在复制后自动解压
 
COPY source_dir/file dest_dir/file 	# 和ADD相似，但是如果有压缩文件并不能解压
 
WORKDIR heart 	# 设置工作目录，运行起这个容器，来到的路径就是这个路径
 
CMD   # 启动并运行容器执行的命令

image-20240621152453316

image-20240621152508358

案例1

vim Dockerfile
 
FROM centos:centos7
MAINTAINER heart
ENV name heart
ARG age 18
RUN mkdir /heart
RUN touch /heart/test.py
RUN echo 'print(1)' > /heart/test.py
RUN echo $name
RUN echo $age
WORKDIR /heart
 
# 基于dockerfile构建镜像,不要忘了 .   基于当前路径下的Dockerfile 构建镜像
docker build -t='centos_heart_vim' . 
docker images
 
# 基于这个镜像运行容器
docker run -id --name centos77 centos_heart_vim
 
# 进入到容器
docker exec -it xx /bin/bash
 
# 验证vim，和文件夹，文件是否存在

案例2

FROM centos:centos7
MAINTAINER heart
ENV name heart
RUN mkdir /heart
RUN touch /heart/test1.py
RUN echo 'input()' > /heart/test1.py
WORKDIR /heart
CMD ['python' ,'./test1.py'] # 运行容器时会默认加上 /bin/sh -c
 
 
 
 
# 基于dockerfile构建镜像，不要忘了 .
docker build -t='centos_py' . 
docker images
# 基于这个镜像运行容器
docker run -id --name yy centos_py python /heart/ss.py
# 进入到容器
docker exec -it xx /bin/bash
# 查看环境变量
# python看
os.environ.get('name')
# shell看
echo $name

7.1 常用和不常用命令

# 1 所有命令
https://zhuanlan.zhihu.com/p/419175543?utm_id=0
 
FROM: 指定基础镜像
RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
LABEL：表明镜像的作者。将被遗弃，被LABEL代替。
EXPOSE：设置对外暴露的端口。
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
COPY：将本地文件或目录拷贝到镜像的文件系统中。
VOLUME：添加数据卷
USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
WORKDIR：设置工作目录
 
 
# 2 docker logs 容器名字/id号  查看镜像运行成容器时，错误日志
	-如果容器没起来，看日志排查错误
 
    
# 3 CMD  ENTRYPOINT  --https://zhuanlan.zhihu.com/p/548188679
#相同点：
只能写一条，如果写了多条，那么只有最后一条生效。
容器启动时才运行，运行时机相同。
# 不同点：
ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数
 
 
# 4 ARG 和 ENV 
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失

7.2 dockerfile构建一个djagno项目

# 以图书管理系统为例---》公司使用docker流程
 
# 公司中，使用Docker开发的工作流程
# 1 有一个项目，pycharm开发着，开发完后
# 2 在项目路径下新建Dockerfile，写入
FROM python
LABEL author="heart"
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"]
# 3 把代码提交到git
 
# 4 在上线机器上，把代码克隆下来
git clone https://gitee.com/heart99999/bbs.git
    
# 5 构建镜像
docker build -t='bbs' . # 要在目录中build 我这里是在project/books中
 
# 6 运行容器
docker run -id --name=bbs -v /home/heart/bbs:/soft -p 8088:8080 bbs:latest
            
# 7 其它人访问宿主机的8080端口就能看到项目了
# 8 开发人员继续提交代码
# 9 运维人员pull代码，重启容器，用户就可以看到最新的了
# 重启docker容器即可
docker restart 名字
# 如果第三方依赖变了，必须重写构建镜像，再运行容器

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

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

8 docker 私有仓库

8.1 镜像传到官方仓库

# 第0步：在远端创建仓库
# 第一步：给镜像打标签
	docker tag 086e6b3e71c0 heart99/heart_books:v1
# 第二步：登录到远程
	docker login
    
# 第三步：提交
	docker push heart99/heart_books:v1
        
# 第四步：别人就可以下载了
	docker pull heart99/heart_books:v1

8.2 镜像分层

# 每一个Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完命令后，将容器进行提交,通过查看下载下来的镜像，发现历史层信息的层ID是missing，其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID
 
 
# 只要执行一个命令就会多一层
RUN yum install vim -y
RUN yum install git -y
 
 
# 查看镜像分层的命令
docker history heart99/heart_books:v1
# 好处：
构建快，分发方便，如果本地有某一层了，这一层就不需要下载了
 
 
# 补充：Dcokerfile写命令，建议多条命令合为一条---》只会生成一层
RUN python -m pip install --upgrade pip &&\
python -m pip install --upgrade setuptools &&\
pip install -r requirements.txt

8.3 私有仓库搭建

# 自己搭建私有仓库
	-harbor：企业级私有仓库---》（有图形化界面--》跟hub.docker 很像）		https://blog.csdn.net/weixin_47085247/article/details/129237979
    
 
    
-registry：用docker搭建私有仓库(没有图形化界面)
    
# 搭建步骤：(使用docker搭建docker私有仓库
 
# 1 拉取镜像 docker pull registry
 
# 2 运行容器 就是一个web服务端 从浏览器中访问它
docker run -id --name=registry -p 5000:5000 registry
 
# 3 打开浏览器 输入地址http://10.0.0.101:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
 
# 4 修改daemon.json
vi /etc/docker/daemon.json
{
    "insecure-registries":["10.0.0.101:5000"]
} 
 
# 5 重启docker 让配置生效
systemctl restart docker
docker start registry
 
# 6 把某个镜像tag成私有仓库的镜像
docker tag 镜像名字/id 10.0.0.101:5000/django_books:v1
docker tag django_books:latest 10.0.0.101:5000/django_books:v1
            
# 7 提交到私有仓库
docker push 10.0.0.101:5000/django_books:v1
        
# 8 其他人，只要配置了私有仓库就可以直接拉取
docker pull 10.0.0.101:5000/django_books:v1
docker run -id --name=books -v /root/project/books:/soft -p 8080:8080 10.0.0.101:5000/django_books:v1

9 harbor私有仓库搭建

https://blog.csdn.net/weixin_47085247/article/details/129237979

9.1 CentOS7安装DockerCompose

# linux下载
curl -L https://github.com/docker/compose/releases/download/1.29.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# 修改文件权限
chmod +x /usr/local/bin/docker-compose
# Base自动补全命令
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
# 如果这里出现错误，需要修改自己的hosts文件：
# echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

9.2 Harbor安装与部署

harbor github地址 : https://github.com/goharbor/harbor/releases

这里我使用的是v2.4.1版本

# wget下载 (不推荐)
wget https://github.com/goharbor/harbor/releases/download/v2.4.1/harbor-offline-installer-v2.4.1.tgz
# 下载完scp到服务器中
scp C:\Users\heart\Desktop\harbor-offline-installer-v2.4.1.tgz root@192.168.126.128:/home/harbor/

9.2.1 安装

# 解压下载好的包 在同目录下会生成一个harbor文件夹
tar xvf harbor-offline-installer-v2.4.1.tgz
# 如果有证书，还需要解压证书包
unzip 证书.zip
# 解压后会生成一个证书文件和密钥文件
# 将证书文件和密钥文件全部移到harbor文件夹里
# mv 证书 harbor
# mv 密钥 harbor
# 进入harbor文件夹，会看到harbor.yml.tmpl文件，重命名它
mv harbor.yml.tmpl harbor.yml
# 打开
vi harbor.yml

image-20240622145713215

注：证书密钥路径为绝对路径，例如：

image-20240622145729964

9.2.2 执行

执行预备工具

./prepare

执行脚本

./install.sh

一共是9个容器

docker ps #查看容器

image-20240622145835085

9.2.3 访问

http://192.168.126.128/ 文件里配置的地址 80端口

用户名 : admin

密码 : 文件中配置的密码

image-20240622145853815

添加域名

vi /etc/hosts

image-20240622145955075

前面是ip地址，后面是域名

9.3 Harbor使用

9.3.1 修改docker daemon.json文件

vi /etc/docker/daemon.json
cat /etc/docker/daemon.json
{
    "insecure-registries":["#域名或者IP地址"]
}

重启加载daemon.json配置

systemctl daemon-reload

重启docker

systemctl restart docker

查看docker容器个数

docker ps

发现只启动了5个容器

回到harbor文件

cd /home/harbor

把已经启动的容器停下来并删除

docker-compose down

启动docker容器，并在后台进行

docker-compose up -d

重新数一下docker容器个数

docker ps

如果其他主机要使用harbor，也要修改docker daemon.json文件并重启

9.3.2 镜像上传与拉取

镜像打包

docker tag centos:latest 域名或IP地址/项目库名/centos:版本号
 
# docker tag 需要打标签的镜像 域名或者ip地址/库名/新名字
# docker tag django_books:latest 192.168.126.128/library/books:latest

镜像推送到Harbor，要先登录

docker login 域名或ip地址

推送

这个地方直接写刚才打标签的新名字即可

docker push 192.168.126.128/library/books:latest

image-20240622150753007

拉取

直接复制

docker pull 192.168.126.128/library/books@sha256:6511a562ecca0ad2d04f8a562679396e86cb7933b29ebaed726f0c0e579932b5

image-20240622150810225

10 docker-compose

使用docker会面临一个比较大的问题：如果一个djagno项目使用mysql、redis，不要一次性把所有服务都放到一个容器

中，每个服务一个容器，批量的管理多个容器，比较难以操作，于是有了docker-compose。

Docker Compose是一个能一次性定义和管理多个Docker容器的工具，单机容器编排【定义和管理】

Docker Compose概念

Compose中定义和启动的每一个容器都相当于一个服务(service)

Compose中能定义和启动多个服务，且它们之间通常具有协同关系

管理方式：

使用YAML文件来配置我们应用程序的服务。

使用单个命令（docker-compose up），就可以创建并启动配置文件中配置的所有服务。

10.1 安装

https://github.com/docker/compose/releases

#wget https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64 (不推荐)
 
# 直接 命令行中 rz 上传
cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose # 想在任意路径下执行docker-compose都有相应----》需要把可执行文件放到环境变量所在的目录下
chmod +x /usr/local/bin/docker-compose
# 以后在任意位置敲docker-compose都可以
 
 
  r--    ---    ---
# rwx    rwx    rwx
  属主   属组    其他
  r：read 读权限 
  w：wirte 写权限
  x ：执行权限
 
 属主   属组  所有人
 chmod 777 文件名
 chmod +x 
 
    
  rwx  r-x   -wx
  111  101   011 
  chmod 753 文件名
 
# epel源
	-yum install centos仓库下载
    -软件不全
    -epel源 扩展源 
    	nginx
        redis
        python

10.2 常用命令

# 启动管理容器
docker-compose up                                 # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d                              # 后台执行，一般我们看日志输出，不用这个
docker-compose stop                               # 停止，不会删除容器和镜像
docker-compose down                               # 停止，并删除关联的容器
docker-compose start                              # 启动yml文件管理的容器
docker-compose ps                                 # 正在运行的容器
docker-compose images                             # docker-compose管理的镜像
docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内
docker-compose up -d --build 		              # 启动容器但是重新构建镜像，基于重新构建的镜像启动
docker-compose version 				              # 查看docker版本

10.3 部署flask

10.3.1 新建flask项目

from flask import Flask
from redis import Redis
import os
 
app = Flask(__name__)
# redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
redis = Redis(host='redis', port=6379,decode_responses=True) # 容器的主机名---》flask容器和redis容器是能ping通的，可以通过ip ping 也可以通过主机名ping
 
@app.route('/')
def hello():
    redis.incr('hits')
    return '你好! 查看 %s 次\n' % (redis.get('hits'))
 
 
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

10.3.2 编写Dockerfile

FROM python:3.8
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
EXPOSE 5000
CMD [ "python", "app.py" ]
 
# 构建出镜像---》一会统一使用 docker-compose构建

10.3.3 编写yml文件

version: "3"
services:
  redis: # 启动一个redis容器
    image: redis
  web:   # 启动web容器
    build: # 构建镜像
      context: .
      dockerfile: Dockerfile
    ports: # -p 端口转发
      - 8080:5000
    environment: # 环境变量
      REDIS_HOST: redis

10.3.4 编写requirements.txt

flask
redis

10.3.5 一键启动

docker-compose up

image-20240624190420755

image-20240624190408705

10.4 一键部署django项目

# 一台服务器：
	-python3.8 环境 djagno +uwsgi+代码
    -nginx软件
    -mysql 5.7
    -redis 
 
# 每个都做成一个容器
	-djagno项目容器：python3.8 构建的django，项目依赖模块，uwsgi，代码
    -nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
    -mysql 容器：创建，创用户，密码，luffy库，做目录映射，保存数据，跑起来
    -redis 容器，做目录映射，保存数据，跑起来

目录结构

luffy
    docker_compose_files    # 放数据的文件夹（配置，目录映射）
    luffy_api  				# 后台项目
    	luffy_api           # 后台项目
    	Dockerfile          # 构建镜像文件
    luffy_front  			# 前端项目 删除node_modules和dist 重新构建
    docker-compose.yml 		# ymal文件

image-20240624192210688

修改前端，后端的地址

前端 settings.js

const BASE_URL = 'http://192.168.126.128:8080/api/v1/'

后端 pro.py

BACKEND_URL = "http://192.168.126.128:8080/"
 
LUFFY_URL = "http://192.168.126.128"

编译前端文件

编译完成后提交到git

cnpm install
cnpm run build

git clone https://gitee.com/heart99999/docker-compose-luffy.git

docker-compose up

10.4.1 docker_compose_files 配置文件

docker_compose_files/nginx/default.conf

server {
  listen 80; # 监听80端口，用于处理HTTP请求
  server_name 127.0.0.1; # 服务器名为127.0.0.1，本地地址
  charset utf-8; # 设置字符编码为UTF-8
 
  location / {
    root /var/www/html; # 设置根目录为/var/www/html
    index index.html; # 默认首页文件为index.html
    try_files $uri $uri/ /index.html; # 解决单页面应用刷新404问题，尝试找到文件，如果找不到则返回index.html
  }
}
 
server {
  listen 8000; # 监听8000端口，用于处理HTTP请求
  server_name 127.0.0.1; # 服务器名为127.0.0.1，本地地址
  charset utf-8; # 设置字符编码为UTF-8
 
  location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # 设置X-Forwarded-For头部，记录客户端的原始IP地址
    proxy_set_header Host $http_host; # 设置Host头部，保留原始主机头
    proxy_redirect off; # 关闭代理重定向
    proxy_pass http://luffy_django:8080; # 将请求转发到http://luffy_django:8080
  }
 
  location /static {
    alias /home/project/luffy_api/luffy_api/static; # 将/static路径下的请求映射到/home/project/luffy_api/luffy_api/static目录
  }
}

docker_compose_files/redis/redis.conf

bind 0.0.0.0
# 绑定所有网络接口，使得 Redis 可以接受来自任何网络接口的连接
 
port 6379
# 设置 Redis 服务器监听的端口号为 6379
 
daemonize no
# 指定是否以守护进程方式运行 Redis，如果设置为 "no"，Redis 将在前台运行
 
pidfile /var/run/redis_6379.pid
# 指定 Redis 进程的 PID 文件路径
 
databases 16
# 设置 Redis 实例中的数据库数量，默认是 16 个数据库
 
save 900 1
# 如果 900 秒（15 分钟）内至少有 1 个键发生变更，则执行一次持久化操作
 
save 300 10
# 如果 300 秒（5 分钟）内至少有 10 个键发生变更，则执行一次持久化操作
 
save 60 10000
# 如果 60 秒（1 分钟）内至少有 10000 个键发生变更，则执行一次持久化操作
 
dbfilename dump.rdb
# 指定持久化文件的名字，默认是 "dump.rdb"
 
dir ./
# 指定持久化文件的存储路径，"./" 表示当前目录

docker_compose_files/mysql.env

MYSQL_ROOT_PASSWORD=heart12345
# 设置 MySQL root 用户的密码为 "heart12345"
 
MYSQL_DATABASE=luffy
# 创建一个名为 "luffy" 的数据库
 
MYSQL_USER=luffy
# 创建一个名为 "luffy" 的用户
 
MYSQL_PASSWORD=Luffy123?
# 设置 "luffy" 用户的密码为 "Luffy123?"
 
TZ=Asia/Shanghai
# 设置时区为亚洲/上海

10.4.2 luffy_api

luffy_api/Dockerfile

# 依赖镜像名称和id
FROM python:3.8
# 使用 Python 3.8 作为基础镜像
 
# 指定镜像创建者信息
LABEL name="heart"
# 添加一个标签，标记镜像创建者为 "heart"
 
RUN mkdir /soft
# 创建一个名为 /soft 的目录
 
WORKDIR /soft
# 设置工作目录为 /soft
 
COPY ./requirements.txt /soft/requirements.txt
# 将本地的 requirements.txt 文件复制到镜像的 /soft 目录中
 
RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.doubanio.com/simple
# 使用 Douban 的镜像源安装 requirements.txt 中列出的 Python 依赖项，不使用缓存
 
CMD ["uwsgi","./luffy.ini"]
# 使用 uwsgi 启动应用，使用配置文件 luffy.ini

luffy_api/luffy.ini

[uwsgi]
chdir = /soft
# 设置工作目录为 /soft
 
master = true
# 启用主进程管理模式
 
wsgi-file = luffy_api/wsgi.py
# 指定 WSGI 文件为 luffy_api/wsgi.py
 
http = 0.0.0.0:8080
# 监听 0.0.0.0 地址的 8080 端口
 
chmod-socket = 755
# 设置 socket 文件的权限为 755
 
processes = 2
# 启动 2 个工作进程
 
pidfile = /soft/luffy_api/uwsgi.pid
# 将 uWSGI 服务器的 PID 文件保存到 /soft/luffy_api/uwsgi.pid
 
# 设置缓冲
post-buffering = 4096
# 启用 4096 字节的 POST 数据缓冲区

luffy_api/requirements.txt

amqp==5.2.0
asgiref==3.8.1
async-timeout==4.0.3
billiard==4.2.0
celery==5.4.0
certifi==2024.2.2
cffi==1.16.0
charset-normalizer==3.3.2
click==8.1.7
click-didyoumean==0.3.1
click-plugins==1.1.1
click-repl==0.3.0
colorama==0.4.6
cron-descriptor==1.4.3
cryptography==42.0.7
Django==3.2
django-celery-beat==2.6.0
django-celery-results==2.5.1
django-cors-headers==4.3.1
django-filter==24.2
django-redis==5.4.0
django-simpleui==2024.4.1
django-timezone-field==6.1.0
djangorestframework==3.15.1
djangorestframework-simplejwt==5.3.1
dnspython==2.6.1
eventlet==0.36.1
flower==2.0.1
gevent==24.2.1
greenlet==3.0.3
humanize==4.9.0
idna==3.7
kombu==5.3.7
loguru==0.7.2
mysqlclient==2.2.4
pillow==10.3.0
prometheus_client==0.20.0
prompt-toolkit==3.0.43
pycparser==2.22
pycryptodomex==3.20.0
PyJWT==2.8.0
pyOpenSSL==24.1.0
python-alipay-sdk==3.3.0
python-crontab==3.0.0
python-dateutil==2.9.0.post0
pytz==2024.1
redis==5.0.4
requests==2.31.0
six==1.16.0
sqlparse==0.5.0
tencentcloud-sdk-python==3.0.1145
tornado==6.4
typing_extensions==4.11.0
tzdata==2024.1
urllib3==2.2.1
vine==5.1.0
wcwidth==0.2.13
win32-setctime==1.1.0
zope.event==5.0
zope.interface==6.4
uwsgi

10.4.3 docker-compose.yml

version: "3"
# Docker Compose 文件的版本
 
services:
  nginx:
    image: nginx
    # 使用官方的 Nginx 镜像
 
    container_name: luffy_nginx
    # 设置容器名称为 luffy_nginx
 
    ports:
      - "80:80"
      # 将主机的 80 端口映射到容器的 80 端口
 
      - "8000:8000"
      # 将主机的 8000 端口映射到容器的 8000 端口
 
    restart: always
    # 配置容器总是重启
 
    volumes:
      - ./luffy_front/dist:/var/www/html
      # 将主机的 ./luffy_front/dist 目录挂载到容器的 /var/www/html 目录
 
      - ./docker_compose_files/nginx:/etc/nginx/conf.d
      # 将主机的 ./docker_compose_files/nginx 目录挂载到容器的 /etc/nginx/conf.d 目录
 
    depends_on:
      - django
      # 依赖于 django 服务
 
    networks:
      - web
      # 使用名为 web 的网络
 
  django:
    build:
      context: ./luffy_api
      # 构建上下文为 ./luffy_api 目录
 
      dockerfile: Dockerfile
      # 使用 Dockerfile 文件
 
    container_name: luffy_django
    # 设置容器名称为 luffy_django
 
    # command: python manage_pro.py makemigrations && python manage_pro.py migrate && uwsgi ./luffy.ini
    # 注释掉的命令，用于在启动时进行数据库迁移和启动 uwsgi 服务
 
    restart: always
    # 配置容器总是重启
 
    ports:
      - "8080:8080"
      # 将主机的 8080 端口映射到容器的 8080 端口
 
    volumes:
      - ./luffy_api:/soft
      # 将主机的 ./luffy_api 目录挂载到容器的 /soft 目录
 
    environment:
      - TZ=Asia/Shanghai
      # 设置环境变量，时区为亚洲/上海
 
    depends_on:
      - mysql
      - redis
      # 依赖于 mysql 和 redis 服务
 
    networks:
      - web
      # 使用名为 web 的网络
 
  redis:
    image: redis:6.0-alpine
    # 使用 Redis 6.0 Alpine 版镜像
 
    container_name: luffy_redis
    # 设置容器名称为 luffy_redis
 
    ports:
      - "6379:6379"
      # 将主机的 6379 端口映射到容器的 6379 端口
 
    volumes:
      - ./docker_compose_files/redis/data:/data
      # 将主机的 ./docker_compose_files/redis/data 目录挂载到容器的 /data 目录
 
      - ./docker_compose_files/redis/redis.conf:/etc/redis/redis.conf
      # 将主机的 ./docker_compose_files/redis/redis.conf 文件挂载到容器的 /etc/redis/redis.conf
 
    command: redis-server /etc/redis/redis.conf
    # 使用指定的配置文件启动 Redis 服务器
 
    networks:
      - web
      # 使用名为 web 的网络
 
  mysql:
    image: mysql:8.0
    # 使用 MySQL 8.0 镜像
 
    container_name: luffy_mysql
    # 设置容器名称为 luffy_mysql
 
    restart: always
    # 配置容器总是重启
 
    ports:
      - "3306:3306"
      # 将主机的 3306 端口映射到容器的 3306 端口
 
    env_file:
      - ./docker_compose_files/mysql.env
      # 使用主机的 ./docker_compose_files/mysql.env 文件作为环境变量
 
    volumes:
      - ./docker_compose_files/mysql/data:/var/lib/mysql
      # 将主机的 ./docker_compose_files/mysql/data 目录挂载到容器的 /var/lib/mysql 目录
 
      - ./docker_compose_files/mysql/logs:/var/log/mysql
      # 将主机的 ./docker_compose_files/mysql/logs 目录挂载到容器的 /var/log/mysql 目录
 
      - ./docker_compose_files/mysql/conf:/etc/mysql/conf.d
      # 将主机的 ./docker_compose_files/mysql/conf 目录挂载到容器的 /etc/mysql/conf.d 目录
 
    networks:
      - web
      # 使用名为 web 的网络
 
networks:
  web:
    # 定义一个名为 web 的网络

11 远程连接linux开发

vscode连接需要pylance才会有代码提示

ssh 用户名@ip地址
posted @   ssrheart  阅读(25)  评论(0)  编辑  收藏  举报
相关博文：
· luffy
· redis
· docker
· docker
· docker和虚拟化、docker安装和配置、镜像操作、容器操作、应用部署
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理 了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
点击右上角即可分享
微信分享提示