云计算

云计算

云计算指通过计算机网络(多指因特网)形成的计算能力极强的系统，可存储、集合相关资源并可按需配置，向用户提供个性化服务。

目前云计算服务模式主要包括以下几类：

基础设施即服务（Infrastructure as a Service, IaaS）

• 云平台提供各类基础设施类能力的服务类别，包括计算、存储、网络等资源服务能力。您无需购买和部署服务器、存储、网络设备等硬件基础设施就可以灵活部署自己的业务系统。

平台即服务（Platform as a Service, PaaS）

• 提供应用程序所需要的硬件和软件部署平台的服务类别。您无需管理和维护复杂的底层基础架构和操作系统，只需要关注自己的业务逻辑，加速开发效率。

软件即服务（Software as a Service, SaaS）

• 提供软件的服务类别，包括协同软件、客户关系管理、企业资源计划、人力资源系统等。您无需经过传统的研发流程，而是通过互联网即可使用软件服务，节约了管理基础设施和研发软件的工作。
• 邮箱、微信、支付宝、钉钉、在线文档、小程序

模型即服务（MaaS）

• 把 AI 模型当作生产的重要元素，从模型预训练到二次调优，最后到模型部署，围绕模型的生命周期来提供相应的服务。您可以通过低成本的方式访问、使用、集成模型，提升您的业务智能化能力。

云主机ECS

云主机就是云平台上的"虚拟机";

• 收费模式:包年,包月,按需购买,"抢购"模式
• 镜像:公共镜像,私有镜像...
• 快照:手动快照,自动快照
• VPC:专有网络,虚拟局域网,实现负载均衡高可用
• 安全组:入口规则(访问服务器),出口规则(访问其他网站)
• 存储:块存储,OSS对象存储

存储相关概念

• 块存储:物理硬盘,虚拟硬盘
  • 可以自由的分区,格式化,建立文件系统,挂载,LVM逻辑卷,RAID
• 文件存储:NFS(网络文件系统)共享目录
  • 将网络文件系统挂载到本机,实现多台服务器之间的文件共享;
  • 可以像使用本地文件一样使用网络文件系统;
• 对象存储:网盘
  • 对象(文件名,描述,唯一id)
  • 分布式存储(网络版RAID10)
  • 本地搭建CEPH\MinIO\HDFS...

容器化技术

• 1.什么是容器化技术？优势是什么？
• 2.Docker简介？
• 3.容器与镜像？
• 4.容器与虚拟机的区别？
• 5.容器的底层技术是什么？

Docker简介

容器化技术：一种操作系统级的虚拟化技术；简单理解为“微型虚拟机”；

功能与优势：

1. 实现应用间隔离运行；
2. 实现应用的一键"打包",将应用服务,依赖环境打包成镜像;
3. 让应用可以在不同的系统中拥有一致运行环境;
4. 对容器进行资源限制;
5. 一键运行容器;

Docker

• Docker是使用go语言开发的一种容器管理工具，容器运行时（run time）；

• RUNC、Podman、Containerd、LXC、CRI-0
• Docker 诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。

容器和镜像：

• 容器：一个运行中的镜像，类似于一个进程；

• 镜像：容器的模板，是静态文件，类似一个安装包；

镜像仓库:存放各种镜像的下载站点;官方docker hub;公司内部可以搭建私有仓库;

主机虚拟化和容器虚拟化特点

主机虚拟化

• 优点
  • 应用程序运行环境强隔离
  • 虚拟机操作系统与底层操作系统无关化
  • 虚拟机内部操作不会影响到物理机
• 缺点
  • 拥有操作系统会占用部署资源及存储
  • 网络传输效率低
  • 当应用程序需要调用硬件响应用户访问时间延迟大

容器虚拟化

• 可以实现应用程序的隔离
• 直接使用物理机的操作系统可以快速响应用户请求
• 不占用部署时间
• 占用少量磁盘空间

Docker的底层技术：

1. Namespaces：Linux内核中提供命名空间功能，隔离进程、网络、文件系统；
2. Cgroup：资源限制，CPU、内存;
3. OverlayFS:镜像文件分层技术;

Docker可以做什么?

1.快速部署应用服务;

2.可以统一开发,测试,生产环境,避免由于环境问题导致的服务运行异常;

安装Docker

配置Docker镜像加速

Docker常用命令

镜像常用命令:

docker search ubuntu     # 查找镜像
docker pull  镜像:版本   # 下载镜像
docker images            # 查看本地镜像
docker save 镜像:版本 -o 镜像.tar  # 将镜像保存为文件
docker rmi  镜像名       # 删除镜像
docker load -i 镜像.tar # 将镜像文件加载到本地镜像仓库
docker inspect 镜像：版本 # 查看镜像的详细信息
docker rmi $(docker images -aq) # 删除所有镜像
# 批量导入所有镜像
for img in `ls *.tar`;do docker load -i $img;done

容器管理命令:

docker ps		 # 查看正在运行容器
docker ps -a 	# 查看运行与曾经运行的容器
docker run 		# 使用镜像运行容器
--name 			#给容器起名
-i				 # 交互式启动
-t				 # 分配终端
-d				 # 后台执行容器
-v	--volume			# 目录映射 真机路径:容器路径
 -p          # 指定端口映射  真机端口:容器端口
 -P          # 随机端口
 -e          # 设置容器中的环境变量
 --network    # 指定网络模式
--rm         # 容器停止时，自动删除容器和容器中的数据
-u           # 以什么用户的身份创建容器
-h           # 指定容器的主机名，默认容器ID前N位
-m           # 设置容器内存的最大值
docker run --name -itd -p 80:80 nginx:1.26

# 进入容器，执行命令与操作
docker exec -it nginx-test /bin/bash

# 将容器导出为镜像文件
docker export -o mynginx.tar nginx-test

# 将镜像容器生成的文件导入本地镜像仓库
docker import mynginx.tar mynginx:1.0

# 直接将容器生成镜像到本地仓库
docker commit nginx-test mynginx:2.0

# 停止容器
docker stop nginx-test

# 删除容器
docker rm nginx-test

仓库管理命令:

Docker实战

Docker实战

Docker安装部署MySQL一主二从集群

• 单台电脑 Docker 部署 MySQL 一主二从集群（终极成功版·命令单独标注）

  核心逻辑：解决「密码插件不兼容」「DNS 解析不稳定」「非交互式命令格式」三大坑，所有命令单独标注，可直接复制执行，确保一次成功。

  前置条件

  • 已安装 Docker（Windows/Mac/Linux 均可）
  • 验证 Docker 安装：📌 命令：docker -v
  • 实验环境临时关闭宿主机防火墙（避免端口限制）

  ---

  第一步：拉取 MySQL 5.7 镜像（固定版本）

  📌 命令：docker pull mysql:5.7

  ---

  第二步：创建主库（Master）容器

  2.1 创建主库配置和数据目录（持久化）

  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/master/conf
  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/master/data

  2.2 编写主库配置文件（my.cnf）

  在 ~/docker/mysql/master/conf 目录下创建 my.cnf 文件，内容如下：

  [mysqld]
  server-id=1  # 集群唯一ID，主库固定为1
  log-bin=mysql-bin  # 开启二进制日志（主从复制核心）
  binlog-ignore-db=mysql  # 忽略同步系统库
  binlog-ignore-db=information_schema
  bind-address=0.0.0.0  # 允许所有IP访问（容器内安全）
  

  2.3 启动主库容器

  📌 命令：

  docker run -d \
    --name mysql-master \
    -p 3306:3306 \
    -v ~/docker/mysql/master/conf/my.cnf:/etc/mysql/conf.d/my.cnf \
    -v ~/docker/mysql/master/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=123456 \
    -e TZ=Asia/Shanghai \
    --privileged=true \
    mysql:5.7
  

  2.4 进入主库容器，创建同步用户（指定兼容密码插件）

  📌 命令1：docker exec -it mysql-master bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（创建同步用户）：CREATE USER 'repl'@'%' IDENTIFIED WITH mysql_native_password BY 'repl123';
  📌 命令4（授予复制权限）：GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';
  📌 命令5（刷新权限）：FLUSH PRIVILEGES;
  📌 命令6（查看主库状态，记录File和Position）：SHOW MASTER STATUS;

  记录结果示例（以实际输出为准）：
  File: mysql-bin.000004，Position: 1652

  📌 命令7（退出MySQL）：exit
  📌 命令8（退出主库容器）：exit

  2.5 查询主库容器IP（用于从库直连）

  📌 命令：docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' mysql-master

  记录结果示例：172.17.0.2（下文统称「主库IP」）

  ---

  第三步：创建从库1（Slave1）容器

  3.1 创建从库1配置和数据目录

  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/slave1/conf
  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/slave1/data

  3.2 编写从库1配置文件（my.cnf）

  在 ~/docker/mysql/slave1/conf 目录下创建 my.cnf 文件，内容如下：

  [mysqld]
  server-id=2  # 唯一ID，区别于主库（1）
  relay-log=relay-log  # 开启中继日志
  log-slave-updates=1  # 从库同步后记录日志（可选）
  read-only=1  # 从库设为只读（root用户不受限）
  

  3.3 启动从库1容器

  📌 命令：

  docker run -d \
    --name mysql-slave1 \
    -p 3307:3306 \
    -v ~/docker/mysql/slave1/conf/my.cnf:/etc/mysql/conf.d/my.cnf \
    -v ~/docker/mysql/slave1/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=123456 \
    -e TZ=Asia/Shanghai \
    --privileged=true \
    mysql:5.7
  

  3.4 从库1关联主库（同步配置）

  方式1：手动进入容器执行（推荐，成功率100%）

  📌 命令1：docker exec -it mysql-slave1 bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（停止同步）：STOP SLAVE;
  📌 命令4（关联主库，替换主库IP、File、Position）：

  CHANGE MASTER TO
  MASTER_HOST='主库IP',
  MASTER_USER='repl',
  MASTER_PASSWORD='repl123',
  MASTER_LOG_FILE='mysql-bin.000004',
  MASTER_LOG_POS=1652;
  

  📌 命令5（启动同步）：START SLAVE;
  📌 命令6（验证状态，需看到两个Yes）：SHOW SLAVE STATUS\G;
  📌 命令7（退出MySQL）：exit
  📌 命令8（退出从库1容器）：exit

  方式2：非交互式批量执行（外面直接跑）

  📌 命令（替换主库IP、File、Position）：

  docker exec -i mysql-slave1 bash -c '
  mysql -uroot -p123456 -e "
  STOP SLAVE;
  CHANGE MASTER TO MASTER_HOST=\'主库IP\', MASTER_USER=\'repl\', MASTER_PASSWORD=\'repl123\', MASTER_LOG_FILE=\'mysql-bin.000004\', MASTER_LOG_POS=1652;
  START SLAVE;
  SHOW SLAVE STATUS\G;
  "
  '
  

  ---

  第四步：创建从库2（Slave2）容器

  4.1 创建从库2配置和数据目录

  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/slave2/conf
  📌 命令（Linux/Mac）：mkdir -p ~/docker/mysql/slave2/data

  4.2 编写从库2配置文件（my.cnf）

  在 ~/docker/mysql/slave2/conf 目录下创建 my.cnf 文件，内容如下：

  [mysqld]
  server-id=3  # 唯一ID，区别于主库（1）和从库1（2）
  relay-log=relay-log  # 开启中继日志
  log-slave-updates=1  # 从库同步后记录日志（可选）
  read-only=1  # 从库设为只读（root用户不受限）
  

  4.3 启动从库2容器

  📌 命令：

  docker run -d \
    --name mysql-slave2 \
    -p 3308:3306 \
    -v ~/docker/mysql/slave2/conf/my.cnf:/etc/mysql/conf.d/my.cnf \
    -v ~/docker/mysql/slave2/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=123456 \
    -e TZ=Asia/Shanghai \
    --privileged=true \
    mysql:5.7
  

  4.4 修复从库2数据目录权限（避免启动失败）

  📌 命令：sudo chown -R 999:999 ~/docker/mysql/slave2/data

  4.5 从库2关联主库（同步配置）

  方式1：手动进入容器执行（推荐，成功率100%）

  📌 命令1：docker exec -it mysql-slave2 bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（停止同步）：STOP SLAVE;
  📌 命令4（关联主库，替换主库IP、File、Position）：

  CHANGE MASTER TO
  MASTER_HOST='主库IP',
  MASTER_USER='repl',
  MASTER_PASSWORD='repl123',
  MASTER_LOG_FILE='mysql-bin.000004',
  MASTER_LOG_POS=1652;
  

  📌 命令5（启动同步）：START SLAVE;
  📌 命令6（验证状态，需看到两个Yes）：SHOW SLAVE STATUS\G;
  📌 命令7（退出MySQL）：exit
  📌 命令8（退出从库2容器）：exit

  方式2：非交互式批量执行（外面直接跑）

  📌 命令（替换主库IP、File、Position）：

  docker exec -i mysql-slave2 bash -c '
  mysql -uroot -p123456 -e "
  STOP SLAVE;
  CHANGE MASTER TO MASTER_HOST=\'主库IP\', MASTER_USER=\'repl\', MASTER_PASSWORD=\'repl123\', MASTER_LOG_FILE=\'mysql-bin.000004\', MASTER_LOG_POS=1652;
  START SLAVE;
  SHOW SLAVE STATUS\G;
  "
  '
  

  ---

  第五步：验证集群可用性（主从同步测试）

  5.1 主库插入测试数据

  📌 命令1：docker exec -it mysql-master bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（创建测试库）：CREATE DATABASE test_cluster;
  📌 命令4（使用测试库）：USE test_cluster;
  📌 命令5（创建测试表）：CREATE TABLE user (id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(20));
  📌 命令6（插入测试数据）：INSERT INTO user (name) VALUES ('主从同步测试1'), ('主从同步测试2');
  📌 命令7（退出MySQL）：exit
  📌 命令8（退出主库容器）：exit

  5.2 从库1验证同步数据

  📌 命令1：docker exec -it mysql-slave1 bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（使用测试库）：USE test_cluster;
  📌 命令4（查询数据，应看到主库插入的2条记录）：SELECT * FROM user;
  📌 命令5（退出MySQL）：exit
  📌 命令6（退出从库1容器）：exit

  5.3 从库2验证同步数据

  📌 命令1：docker exec -it mysql-slave2 bash
  📌 命令2（登录MySQL）：mysql -uroot -p123456
  📌 命令3（使用测试库）：USE test_cluster;
  📌 命令4（查询数据，应看到主库插入的2条记录）：SELECT * FROM user;
  📌 命令5（退出MySQL）：exit
  📌 命令6（退出从库2容器）：exit

  ---

  第六步：集群常用管理命令（单独标注）

  6.1 查看所有MySQL容器状态

  📌 命令：docker ps | grep mysql-

  6.2 启动所有容器

  📌 命令：docker start mysql-master mysql-slave1 mysql-slave2

  6.3 停止所有容器

  📌 命令：docker stop mysql-master mysql-slave1 mysql-slave2

  6.4 查看容器日志（排查问题）

  📌 命令（主库）：docker logs mysql-master
  📌 命令（从库1）：docker logs mysql-slave1
  📌 命令（从库2）：docker logs mysql-slave2

  6.5 删除所有容器（重置集群）

  📌 命令：docker stop mysql-master mysql-slave1 mysql-slave2 && docker rm mysql-master mysql-slave1 mysql-slave2
  📌 命令（清空所有数据）：sudo rm -rf ~/docker/mysql/*

  ---

  关键避坑总结

  1. 主库同步用户必须指定 mysql_native_password 插件，否则从库无法识别密码；
  2. 从库关联主库用「主库IP」而非容器名，避免Docker DNS解析问题；
  3. 非交互式执行命令需用「单引号外层包裹+内层转义」，否则命令解析失败；
  4. 从库数据目录需设置权限（chown -R 999:999），避免MySQL启动失败。

  ---

  要不要我帮你整理一份 集群一键执行脚本，把所有启动、配置、验证命令整合在一起，你直接复制到宿主机终端，无需手动分步执行？

Docker安装项目：Blog、电商、游戏、网盘、视频网站(任选其一)

• Docker 安装 WordPress 博客（Blog）项目（命令单独标注·直接执行版）

  核心逻辑：Docker 容器化部署 WordPress（主流开源博客系统），搭配 MySQL 数据库，实现「应用+环境」一键搭建，所有命令单独标注，步骤清晰无坑。

• 前置条件

  • 已安装 Docker（Windows/Mac/Linux 均可）

  • 验证 Docker 安装：📌 命令：docker -v

  • 确保宿主机 8080 端口（可自定义）未被占用（验证：netstat -tuln | grep 8080，无输出则可用）

    第一步：拉取所需镜像（WordPress + MySQL）

    1.1 拉取 MySQL 镜像（WordPress 依赖数据库）

    📌 命令：docker pull mysql:5.7（选择 5.7 稳定版，兼容性强）

    1.2 拉取 WordPress 官方镜像

    📌 命令：docker pull wordpress:latest（最新稳定版，无需手动配置环境）

    第二步：创建 MySQL 容器（Blog 数据库服务）

    2.1 创建 MySQL 数据目录（持久化，避免容器销毁数据丢失）

    📌 命令（Linux/Mac）：mkdir -p ~/docker/wordpress/mysql/data

    2.2 启动 MySQL 容器（配置数据库账号密码、端口）

    📌 命令：

  docker run -d
  --name wp-mysql
  -p 3309:3306
  -v ~/docker/wordpress/mysql/data:/var/lib/mysql
  -e MYSQL_ROOT_PASSWORD=wp123456
  -e MYSQL_DATABASE=wordpress
  -e MYSQL_USER=wpuser
  -e MYSQL_PASSWORD=wpuser123
  -e TZ=Asia/Shanghai
  --privileged=true
  mysql:5.7

  
  ### 2.3 验证 MySQL 容器是否启动成功
  
  📌 命令：`docker ps | grep wp-mysql`（输出中显示「Up」则正常）
  
  
  ## 第三步：创建 WordPress 容器（Blog 应用服务）
  
  ### 3.1 创建 WordPress 数据目录（主题、插件、上传文件持久化）
  
  📌 命令（Linux/Mac）：`mkdir -p ~/docker/wordpress/app`
  
  ### 3.2 启动 WordPress 容器（关联 MySQL 数据库）
  
  📌 命令：
  
  ```bash
  
  docker run -d \
  --name wordpress-blog \
  -p 8080:80 \
  -v ~/docker/wordpress/app:/var/www/html \
  -e WORDPRESS_DB_HOST=wp-mysql:3306 \
  -e WORDPRESS_DB_NAME=wordpress \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wpuser123 \
  -e TZ=Asia/Shanghai \
  --link wp-mysql:mysql \
  --privileged=true \
  wordpress:latest
  

  3.3 验证 WordPress 容器是否启动成功

  📌 命令：docker ps | grep wordpress-blog（输出中显示「Up」则正常）

  第四步：配置 WordPress 博客（浏览器操作）

  4.1 访问 Blog 初始化页面

  📌 操作：打开浏览器，输入 http://宿主机IP:8080（宿主机IP：Linux/Mac 用 ifconfig/ip addr 查询，Windows 用 ipconfig 查询）

  4.2 初始化 WordPress 配置

  1. 选择语言：默认「简体中文」，点击「继续」；
  2. 填写站点信息（自定义）：
     - 站点标题：例如「我的 Docker 博客」
     - 用户名：自定义（如 `admin`）
     - 密码：自定义（如 `admin123456`）
     - 电子邮箱：自定义（如 `test@xxx.com`）
  3. 点击「安装 WordPress」，等待 10 秒完成安装；
  4. 安装完成后，点击「登录」，输入用户名密码，进入博客后台。
  

  4.3 验证 Blog 可用性

  • 前台访问：http://宿主机IP:8080（查看博客首页，默认已生成示例文章）；
  • 后台管理：http://宿主机IP:8080/wp-admin（可发布文章、安装主题/插件）。

  第五步：常用管理命令（单独标注）

  5.1 查看容器状态

  📌 命令：docker ps | grep -E "wp-mysql|wordpress-blog"

  5.2 启动/停止容器

  📌 启动命令：docker start wp-mysql wordpress-blog
  📌 停止命令：docker stop wp-mysql wordpress-blog

  5.3 查看容器日志（排查问题）

  📌 MySQL 日志：docker logs wp-mysql
  📌 WordPress 日志：docker logs wordpress-blog

  5.4 进入容器（手动操作）

  📌 进入 MySQL 容器：docker exec -it wp-mysql bash
  📌 进入 WordPress 容器（修改配置文件等）：docker exec -it wordpress-blog bash

  5.5 重置项目（删除容器+数据，谨慎执行）

  📌 命令：

• 停止并删除容器

  docker stop wp-mysql wordpress-blog && docker rm wp-mysql wordpress-blog

  清空所有数据

  sudo rm -rf ~/docker/wordpress/*

  ## 关键避坑总结（命令+操作·直接执行/检查）
  
  ### 1. 端口冲突
  
  📌 检查命令：`netstat -tuln | grep 8080`（或 `netstat -tuln | grep 3309`）  
  📌 解决：若端口被占用，修改 `docker run` 中 `-p` 参数（如 `8081:80`、`3310:3306`），再重启容器。
  
  ### 2. 数据库连接失败
  
  📌 检查点：确保 `WORDPRESS_DB_HOST=wp-mysql:3306`（容器名+端口），且 `--link wp-mysql:mysql` 未省略。  
  📌 解决：重启 WordPress 容器：`docker restart wordpress-blog`。
  
  ### 3. 数据丢失
  
  📌 检查点：必须通过 `-v` 挂载数据目录（如 `~/docker/wordpress/mysql/data`、`~/docker/wordpress/app`）。  
  📌 预防：非必要不执行「重置项目」命令。
  
  ### 4. 权限问题（Linux/Mac）
  
  📌 报错特征：容器日志显示「Permission denied」。  
  📌 解决命令：`sudo chown -R 999:999 ~/docker/wordpress/`（给数据目录赋权，999 是容器内用户 UID）。
  
  ### 5. 浏览器无法访问
  
  📌 检查点1：宿主机防火墙开放 8080 端口（如 `ufw allow 8080` 或 Windows 防火墙入站规则）。  
  📌 检查点2：云服务器需配置安全组开放 8080 端口（如阿里云安全组入方向添加 TCP 8080）。
  

​

通过Docker命令创建一个自己的镜像

• 通过 Docker 命令创建自定义镜像（以「带个人页面的 Nginx 镜像」为例·命令单独标注）

  核心逻辑：基于官方基础镜像（Nginx），通过 Dockerfile 定义自定义配置/文件，再用 docker build 构建镜像，步骤可复现、命令直接执行。

• 第一步：准备自定义镜像的「构建材料」

• 1.1 创建工作目录（存放 Dockerfile 和自定义文件）

  📌 命令（Linux/Mac）：

  mkdir -p ~/my-docker-image  # 创建目录
    cd ~/my-docker-image        # 进入目录
  

  1.2 创建自定义页面（镜像内要展示的内容，比如个人主页）

  📌 命令（创建 index.html 文件，内容可自定义）：

  echo '<h1>My First Custom Docker Image!</h1>'' > index.html
  

  • 作用：镜像启动后，访问 Nginx 会显示这个页面，区别于官方 Nginx 默认页面。

  第二步：编写 Dockerfile（定义镜像构建规则）

  2.1 创建 Dockerfile 文件

  📌 命令（用 echo 快速生成，或用 vim 编辑）：

  
  cat > Dockerfile << EOF
  
  

1. 指定基础镜像（基于官方 Nginx 稳定版，省去自己装 Nginx 的步骤）

FROM nginx:stable-alpine

2. 把本地的 index.html 复制到镜像内的 Nginx 默认页面目录（覆盖官方默认页面）

COPY index.html /usr/share/nginx/html/index.html

3. 暴露镜像的 80 端口（Nginx 默认端口，告诉 Docker 这个镜像用 80 端口）

EXPOSE 80

4. 启动镜像时自动运行 Nginx 服务（继承官方镜像的启动命令，可省略，此处为清晰展示）

CMD ["nginx", "-g", "daemon off;"]
EOF
```

- 每个指令作用：`FROM` 定基础镜、`COPY` 加自定义文件、`EXPOSE` 声明端口、`CMD` 定启动命令。


## 第三步：构建自定义镜像（核心命令 `docker build`）

### 3.1 执行构建命令

📌 命令（`-t` 给镜像打标签：`镜像名:版本`，`.` 表示从当前目录读取 Dockerfile）：

```bash

docker build -t my-nginx:v1 .
```

- 示例标签：`my-nginx` 是镜像名（自定义），`v1` 是版本（方便后续区分）。

### 3.2 验证镜像是否构建成功

📌 命令（查看本地镜像列表，找 `my-nginx:v1`）：

```bash

docker images | grep my-nginx
```

- 成功标志：输出包含 `my-nginx` 和 `v1` 的行，说明镜像已生成。

**纠错**：若构建报错「COPY failed: no source files were specified」，检查 `index.html` 是否和 `Dockerfile` 在同一目录（`~/my-docker-image`），且文件名无拼写错误。


## 第四步：运行自定义镜像（验证功能是否正常）

### 4.1 启动容器（基于自定义镜像）

📌 命令（`-p` 映射宿主机 8082 端口到容器 80 端口，避免和其他服务冲突）：

```bash

docker run -d --name my-nginx-container -p 8082:80 my-nginx:v1
```

### 4.2 验证容器和页面

  1. 检查容器是否运行：📌 命令 `docker ps | grep my-nginx-container`（显示「Up」则正常）；
  2. 访问自定义页面：  
     - 宿主机本地访问：📌 命令 `curl http://127.0.0.1:8082`，输出 `<h1>My First Custom Docker Image!</h1>` 即成功；
     - 外部访问（如浏览器）：输入 `http://宿主机IP:8082`，能看到自定义标题。

**纠错**：若访问失败，检查端口是否被占用（`netstat -tuln | grep 8082`），若占用则更换端口（如 `8083:80`）重新启动容器。


## 第五步：自定义镜像管理命令（删除/重命名）

### 5.1 删除容器（先停再删，避免占用镜像）

📌 命令：

```bash

docker stop my-nginx-container # 停止容器
docker rm my-nginx-container # 删除容器
```

### 5.2 删除自定义镜像（容器删除后才能删镜像）

📌 命令：

```bash

docker rmi my-nginx:v1
```

### 5.3 给镜像重命名（可选，比如改版本号）

📌 命令（将 `my-nginx:v1` 重命名为 `my-nginx:v2`）：

```bash

docker tag my-nginx:v1 my-nginx:v2
```

## 关键总结

  1. 自定义镜像核心：`Dockerfile` 定义规则 + `docker build` 执行构建；
  2. 基础镜像选择：优先选 `alpine` 版本（体积小，适合快速构建）；
  3. 调试技巧：构建失败看日志（`docker build` 输出的 ERROR 信息），运行失败看容器日志（`docker logs 容器名`）。

按这个流程，你可以基于任何官方镜像（如 Python、Node.js）创建带自定义代码/配置的镜像，比如「带自己脚本的 Python 镜像」「带自定义配置的 Redis 镜像」等～

要不要我帮你扩展一个「带自定义 Python 脚本的镜像」教程？步骤类似，只需修改 Dockerfile 和自定义文件即可。

1

Docker网络

root@Docker:~# docker network ls

NETWORK ID          NAME                DRIVER              SCOPE
a2424329464c        bridge              bridge              local
2c91da5e815c        host                host                local
b63ed9722f30        none                null                local



# bridge 桥接模式(默认模式),创建docker0网卡,每个容器都有一个自动分配的IP地址,建立虚拟局域网,容器间可以通过ip+port通信,外部访问容器通过宿主机的ip+port,端口映射;
172.17.0.1/16
# host 主机模式,让容器直接使用主机的网络(ip地址和端口);
# 优点:网络效率最高
# 缺点:占用主机端口

# none 无网络模式,不联网没有ip

# overlay network 层叠网络,跨主机通信,vxlan(隧道技术),容器的集群部署中使用该模式


#查看当前的 docker 网络
docker network ls
# 创建docker网络,使用桥接模式
docker neowork create test-network -d bridge
# 使用docker网络，启动容器时，指定--network参数
docker run -itd --network=test-network  --name ubuntu-test ubuntu:latest
# 将创建好的容器添加到docker网络中
docker network connect test-network 容器名称或ID
# 当docker网络不在被使用时，可以删除
docker network rm    test-network

Docker存储

docker 数据卷（Data Volume）是一个可供容器使用的特殊目录，它将主机操作系统目录直接映射进容器，类似于 Linux 的 mount 操作。

数据卷创建、挂载、删除、数据共享；

• docker volume create 数据卷名称
  • /var/lib/docker/volumes/数据卷名称
• 直接指定系统目录作为数据卷
  • -v系统目录:容器目录

# 查看所有数据卷
docker volume ls
# 创建数据卷
docker volume create test_volume
# 在运行容器时候直接挂载数据卷
docker run -itd --name nginx-test -p 8080:80 -v test_volume:/etc/nginx nginx:1.26
# 多个容器共享同一个数据卷
docker run -itd --name nginx-test-2 -p 9090:80 -v test_volume:/etc/nginx nginx:1.26
# 查看数据卷的详细信息
docker volume inspect  test_volume
# 当数据卷未被占用时，可以删除,y
docker volume rm test_volume

1

DockerFile

Docker常用指令

指令	功能
FROM	指定基础镜像(父镜像)
LABEL	添加新建镜像的元数据(坐着,简介)
RUN	在容器中执行linux命令
ENV	在容器中设置环境变量
ADD	复制本地文件并自动解压缩,支持URL下载
COPY	只有复制功能
YOLUME	指定持久化目录
CMD
ENTRYPOINT	容器启动时执行的命令，但不会被覆盖
WORKDIR	工作目录，等价执行 cd
EXPOSE	指定对外暴露

通过Dockerfile创建镜像

docker build -t nginx-test .

• 使用Dockerfile制作MySQL镜像

以下是使用 Dockerfile 制作自定义 MySQL 镜像的完整笔记，包含环境准备、配置编写、问题解决及验证步骤，适用于 Linux 环境（以阿里云 ECS 为例）：


### **一、环境准备**
1. **基础环境**  
   - 系统：Linux（如 Ubuntu、CentOS）  
   - 已安装 Docker：`docker --version` 验证（未安装需先安装 Docker）。  
   - 工作目录：`/root`（所有文件放在此目录下，可自定义）。  


### **二、核心文件准备**
#### 1. Dockerfile（镜像构建脚本）
创建 `Dockerfile` 文件（`vim Dockerfile`），内容如下：  
```dockerfile
# 基础镜像：使用 MySQL 8.0 官方镜像（固定版本更稳定）
FROM mysql:8.0

# 维护者信息（可选）
LABEL maintainer="your-name <your-email@example.com>"

# 环境变量配置（非敏感信息固定，密码建议启动时传入）
ENV TZ=Asia/Shanghai \                  # 时区（避免日志时间偏移）
    MYSQL_DATABASE=app_db \             # 自动创建的数据库
    MYSQL_USER=app_user                 # 额外创建的应用用户

# 复制自定义 MySQL 配置文件（覆盖默认配置）
COPY ./conf/my.cnf /etc/mysql/conf.d/
RUN chmod 644 /etc/mysql/conf.d/my.cnf  # 配置文件权限（必需）

# 复制初始化脚本（首次启动时自动执行）
COPY ./init-scripts/ /docker-entrypoint-initdb.d/
RUN chmod -R 755 /docker-entrypoint-initdb.d/  # 脚本可执行权限（必需）

# 暴露端口
EXPOSE 3306 33060
```


#### 2. 自定义 MySQL 配置文件（my.cnf）
- 创建 `conf` 目录及配置文件：  
  ```bash
  mkdir -p ./conf  # 创建目录
  vim ./conf/my.cnf  # 编辑配置
  ```  
- 配置内容（示例）：  
  ```ini
  [mysqld]
  character-set-server=utf8mb4  # 支持 emoji 的字符集
  collation-server=utf8mb4_unicode_ci
  max_connections=500           # 最大连接数
  default-time-zone=+08:00      # 数据库时区
  lower_case_table_names=1      # 表名不区分大小写（Linux 环境生效）

  [client]
  default-character-set=utf8mb4
  ```


#### 3. 初始化脚本（创建表和数据）
- 创建 `init-scripts` 目录及脚本文件：  
  ```bash
  mkdir -p ./init-scripts  # 创建目录
  ```  

- 脚本 1：创建表结构（`vim ./init-scripts/01_create_table.sql`）：  
  ```sql
  USE app_db;  # 使用自动创建的数据库
  CREATE TABLE IF NOT EXISTS users (
      id INT PRIMARY KEY AUTO_INCREMENT,
      username VARCHAR(50) NOT NULL UNIQUE,
      create_time DATETIME DEFAULT CURRENT_TIMESTAMP
  );
  ```  

- 脚本 2：插入初始数据（`vim ./init-scripts/02_insert_data.sql`）：  
  ```sql
  USE app_db;
  INSERT INTO users (username) VALUES ('test_user');
  ```  


### **三、构建镜像（关键步骤）**
#### 1. 修复 Docker 镜像源（避免拉取失败）
默认镜像源可能访问缓慢或失效，需配置国内源（阿里云 ECS 优先用阿里云源）：  
- 编辑配置文件：  
  ```bash
  sudo vim /etc/docker/daemon.json
  ```  
- 配置内容（替换为阿里云专属加速地址，获取方式：阿里云控制台 → 容器镜像服务 → 镜像加速器）：  
  ```json
  {
    "registry-mirrors": ["https://你的阿里云加速地址.mirror.aliyuncs.com"]
  }
  ```  
- 重启 Docker 生效：  
  ```bash
  sudo systemctl daemon-reload
  sudo systemctl restart docker
  ```  


#### 2. 构建自定义 MySQL 镜像
在工作目录执行构建命令：  
```bash
docker build -t my-mysql:v1.0 .  # 镜像名:版本号 自定义
```  

**常见错误及解决**：  
- `E212: Can't open file for writing`：目录不存在，先创建 `conf` 或 `init-scripts` 目录（`mkdir -p 目录名`）。  
- `Syntax error in ENV`：`ENV` 指令中 `\` 后有空格/注释，需删除（`\` 必须是行尾最后一个字符）。  
- `镜像拉取失败`：检查 `daemon.json` 格式是否正确（JSON 语法严格），重启 Docker 后重试。  


### **四、启动容器并验证**
#### 1. 启动 MySQL 容器
```bash
# 启动命令（数据持久化，避免容器删除后数据丢失）
docker run -d \
--name my-mysql-container \  # 容器名称
-p 3306:3306 \               # 端口映射（宿主:容器）
-v mysql-data:/var/lib/mysql \  # 数据卷挂载
-e MYSQL_ROOT_PASSWORD=root123 \  # 传入 root 密码（生产环境用强密码）
-e MYSQL_PASSWORD=user123 \      # 传入应用用户密码
my-mysql:v1.0                   # 使用自定义镜像
```  

**常见错误**：  
- `invalid reference format`：命令中 `\` 后有注释，删除注释或写成一行命令。  


#### 2. 验证容器状态
```bash
# 查看容器是否运行（状态为 Up 即正常）
docker ps | grep my-mysql-container

# 查看启动日志（排查初始化问题）
docker logs my-mysql-container
```  


#### 3. 验证 MySQL 配置及数据
- 进入容器并连接 MySQL：  
  ```bash
  docker exec -it my-mysql-container bash  # 进入容器
  mysql -u root -p  # 输入密码 root123 连接
  ```  

- 执行 SQL 验证：  
  ```sql
  -- 验证数据库是否创建
  show databases;  # 应包含 app_db

  -- 验证表和数据是否初始化
  use app_db;
  show tables;  # 应包含 users 表
  select * from users;  # 应显示 test_user 数据

  -- 验证字符集配置
  show variables like 'character_set%';  # 应显示 utf8mb4
  ```  


### **五、生产环境优化建议**
1. **敏感信息管理**：密码等敏感信息通过 `docker run -e` 传入，避免硬编码在 Dockerfile 中。  
2. **固定镜像版本**：`FROM mysql:8.0.36`（具体版本），避免自动更新导致兼容问题。  
3. **健康检查**：Dockerfile 中添加 `HEALTHCHECK` 监控服务状态：  
   ```dockerfile
   HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
     CMD mysqladmin ping -h localhost -u root -p"${MYSQL_ROOT_PASSWORD}" || exit 1
   ```  
4. **数据备份**：定期备份数据卷 `mysql-data`（`docker volume inspect mysql-data` 查看路径）。  


### **总结**
通过以上步骤，可完成自定义 MySQL 镜像的构建、容器启动及验证，核心包括：  
- 正确编写 Dockerfile 及配套配置/脚本；  
- 解决镜像源、权限、语法等常见问题；  
- 确保数据持久化和服务可访问性。  
适用于开发环境快速部署，生产环境需进一步优化安全和稳定性。

• 使用Dockerfile制作Redis镜像
• 使用Dockerfile制作Tomcat镜像

DockerCompose

单机容量编排,一键批量管理多个容器

Docker私有镜像站-Harbor

私有镜像站,方便管理,下载部署自己的镜像;

cd /opt
wget http://192.168.57.200/Software/harbor-offline-installer-v2.14.0.tgz
tar -xvf harbor-offline-installer-v2.14.0.tgz
cd harbo
cp harbor.yml.tmpl harbor.yml
vim harbor.yml
hostname
passwrod
ssl
/etc/docker/d
docker compose up -d

容器化技术是现代软件开发、交付和运维（DevOps）体系中的核心技术之一，其核心目标是解决“软件在开发环境能跑，在生产环境跑不起来”的环境一致性问题，并提升资源利用率与部署效率。以下针对你的问题逐一展开说明：

## 1. 什么是容器化技术？优势是什么？

### （1）定义

容器化技术是一种**操作系统级虚拟化技术**，它通过对应用程序及其所有依赖（如库、配置文件、环境变量等）进行“打包”，形成一个独立的“容器”单元。容器共享宿主机的操作系统内核，但拥有独立的文件系统、网络空间和资源配额，从而实现“**一次打包，到处运行**”的效果。

简单来说，容器就像一个“轻量级的隔离盒子”，里面装着应用和它需要的所有“配件”，无论放在哪台支持容器的机器上，都能以相同的方式运行。


### （2）核心优势

- **环境一致性**：彻底解决“开发环境能跑，生产环境崩了”的问题。容器将应用与依赖打包，确保在开发、测试、生产等不同环境中运行环境完全一致。
- **资源高效利用**：容器共享宿主机内核，无需像虚拟机那样为每个实例分配独立的操作系统（Guest OS），资源占用极低（通常以MB为单位），一台宿主机可运行成百上千个容器。
- **快速启动与部署**：容器启动时间通常在**秒级**（甚至毫秒级），远快于虚拟机的分钟级启动；同时支持自动化部署，可快速扩缩容，适应业务流量波动。
- **强可移植性**：容器可在任意支持容器引擎（如Docker）的环境中运行，包括物理机、虚拟机、公有云（AWS/Azure/阿里云）、私有云等，无需修改应用代码。
- **轻量隔离**：容器间通过技术手.段实现资源（CPU、内存、网络）和文件系统的隔离，既保证了应用间互不干扰，又避免了虚拟机的重量级开销。


## 2. Docker简介

Docker是**容器化技术的主流开源实现**，由Docker Inc.（后被Mirantis收购）于2013年推出，它极大地简化了容器的创建、管理和分发流程，让容器技术从“小众技术”走向了主流。


### （1）核心定位

Docker的核心使命是“**Build, Ship, Run Any App, Anywhere**”（构建、分发、运行任意应用，随时随地），其本质是一个“容器引擎”——负责管理容器的生命周期（创建、启动、停止、销毁）。


### （2）核心组件

- **Docker Engine**：Docker的核心运行组件，包含守护进程（dockerd）、命令行工具（docker CLI）和API接口，负责与宿主机内核交互，实现容器的创建和管理。
- **Docker Image（镜像）**：容器的“模板”，包含应用及其依赖的静态文件（如代码、库、配置），是创建容器的基础（下文会详细说明）。
- **Docker Container（容器）**：镜像的“运行实例”，是动态的、可执行的单元（类比“类”与“对象”的关系）。
- **Docker Registry（仓库）**：用于存储和分发镜像的平台，类似“代码仓库”（如GitHub）。最常用的公共仓库是**Docker Hub**，包含数百万个官方/第三方镜像（如Nginx、MySQL镜像）。


### （3）生态优势

Docker拥有庞大的生态系统，支持与Kubernetes（容器编排工具）、Jenkins（CI/CD工具）、Prometheus（监控工具）等主流DevOps工具无缝集成，成为企业级容器化落地的“标准工具链”之一。


## 3. 容器与镜像：“模板”与“实例”的关系

容器和镜像是Docker（及其他容器技术）中最核心的两个概念，二者是“**静态模板**”与“**动态实例**”的关系，类比编程中的“**类（Class）** ”与“**对象（Object）** ”。


### （1）Docker Image（镜像）：静态的“模板”

- **定义**：镜像是一个**只读的、分层的文件集合**，包含运行应用所需的所有依赖（代码、库、环境变量、配置文件等），以及应用的启动命令。
- **核心特性**：
  - **只读性**：镜像一旦构建完成，就无法修改（若需修改，需基于原镜像创建新镜像）；
  - **分层结构**：镜像由多个“层（Layer）”组成（如基础层、依赖层、应用层），不同镜像可共享相同的层（如多个应用都基于“Ubuntu 22.04”基础层），极大节省存储空间和拉取时间。
- **示例**：我们从Docker Hub拉取的`nginx:alpine`就是一个镜像，它包含了Nginx服务和轻量级的Alpine Linux系统依赖。


### （2）Docker Container（容器）：动态的“实例”

- **定义**：容器是镜像的**可运行实例**——当我们通过`docker run`命令启动镜像时，Docker会在镜像的只读层之上添加一个“**可写层**”，容器的所有修改（如创建文件、修改配置）都只发生在这个可写层，不会影响原镜像。
- **核心特性**：
  - **可写性**：容器的可写层允许动态修改数据；
  - **独立性**：每个容器有独立的网络、进程空间和资源配额，即使基于同一个镜像启动多个容器，它们也互不干扰。
- **示例**：通过`docker run -d nginx:alpine`启动后，就会生成一个运行Nginx的容器，我们可以通过`docker exec`进入容器操作，或通过`docker stop`停止容器。


### （3）二者关系总结

| 维度     | Docker镜像（Image）        | Docker容器（Container）  |
| -------- | -------------------------- | ------------------------ |
| 状态     | 静态（只读）               | 动态（可运行、可修改）   |
| 作用     | 作为容器的“模板”           | 作为应用的“运行载体”     |
| 生命周期 | 构建后长期存在（除非删除） | 启动后存在，停止后可销毁 |
| 数据修改 | 不可修改                   | 可在“可写层”修改         |


## 4. 容器与虚拟机的区别：轻量级vs重量级

容器和虚拟机（VM）都是虚拟化技术，核心目标都是“隔离应用”，但二者的虚拟化层级、资源占用和效率有本质区别，具体对比如下：

| 对比维度          | 容器（Container）                          | 虚拟机（Virtual Machine）                          |
| ----------------- | ------------------------------------------ | -------------------------------------------------- |
| **虚拟化层级**    | 操作系统级（共享宿主机内核）               | 硬件级（模拟物理硬件）                             |
| **核心组件**      | 容器引擎（如Docker）+ 宿主机OS             | Hypervisor（如VMware/KVM）+ Guest OS（每个VM独立） |
| **资源占用**      | 极低（MB级，共享内核）                     | 较高（GB级，需独立OS资源）                         |
| **启动速度**      | 秒级（甚至毫秒级）                         | 分钟级（需启动Guest OS）                           |
| **隔离性**        | 轻量隔离（共享内核，隔离文件/网络/资源）   | 强隔离（完全独立的OS，安全性更高）                 |
| **镜像/文件大小** | 小（通常几十MB~几百MB，如Nginx镜像约20MB） | 大（通常几GB~几十GB，如Windows Server VM约10GB）   |
| **适用场景**      | 微服务、DevOps、高频部署场景               | 需强隔离的场景（如运行不同OS、敏感业务）           |


### 关键总结

- 容器是“**共享内核的轻量级隔离**”，适合追求效率和密度的场景；
- 虚拟机是“**独立OS的重量级隔离**”，适合追求强安全性和跨OS的场景。


## 5. 容器的底层技术（以Linux为例）

容器的“轻量级隔离”和“资源控制”能力，本质依赖于Linux内核的三大核心技术：**Namespace**、**Cgroups** 和 **Union File System（UnionFS）**。


### （1）Namespace：实现“隔离”的核心

Namespace（命名空间）是Linux内核提供的一种“**环境隔离机制**”，它能让容器内的进程“误以为”自己是系统中唯一的进程，从而实现网络、进程ID、文件系统等维度的隔离。

常见的Namespace类型及作用：

- **PID Namespace**：隔离进程ID（容器内的PID从1开始，与宿主机PID不冲突）；
- **NET Namespace**：隔离网络（容器有独立的网卡、IP、端口，与宿主机网络隔离）；
- **Mount Namespace**：隔离文件系统挂载点（容器内的`/`根目录与宿主机不同）；
- **UTS Namespace**：隔离主机名和域名（容器可设置独立的主机名）；
- **IPC Namespace**：隔离进程间通信（如信号量、消息队列，容器间无法直接通信）；
- **User Namespace**：隔离用户ID（容器内的root用户在宿主机中可能是普通用户，提升安全性）。


### （2）Cgroups：实现“资源限制”的核心

Cgroups（Control Groups，控制组）是Linux内核提供的“**资源配额管理机制**”，它能限制容器对CPU、内存、磁盘IO、网络带宽等资源的使用，避免单个容器过度占用资源影响其他容器。

常见的Cgroups控制能力：

- **CPU限制**：限制容器使用的CPU核心数或CPU时间占比（如限制容器最多使用1个CPU核心）；
- **内存限制**：限制容器的最大内存使用量（如限制容器最多使用512MB内存，超出则OOM）；
- **IO限制**：限制容器对磁盘的读写速率（如限制写入速率为100MB/s）；
- **PID限制**：限制容器内可创建的最大进程数。


### （3）UnionFS：实现“镜像分层”的核心

UnionFS（联合文件系统）是一种“**分层文件系统**”，它能将多个只读的文件层（镜像层）和一个可写层（容器层）“联合”成一个统一的文件系统，从而实现镜像的分层复用和容器的可写性。

Docker中常用的UnionFS实现：

- **OverlayFS**：Docker默认的存储驱动（高效、稳定），将镜像的只读层作为“lowerdir”，容器的可写层作为“upperdir”，联合后对外呈现为“merged”目录（容器内的`/`）；
- **AUFS**：早期Docker使用的存储驱动，功能类似OverlayFS，但兼容性稍弱。


### 总结

容器的底层技术本质是“**Namespace隔离环境 + Cgroups限制资源 + UnionFS管理文件**”——三者协同工作，共同支撑了容器的轻量级、高效、可移植特性。



# 1.Docker简介

Docker 是一个开源的应用容器引擎，基于 Go 语言开发，遵循 Apache 2.0 协议开源。它能让开发者将应用及其依赖打包到一个轻量级、可移植的 “容器” 中，然后发布到任何支持 Docker 的环境（Linux、Windows、macOS）中，实现 “一次构建，到处运行”。

## 1.1 Docker 核心概念

Docker 生态有 3 个最核心的组件，理解它们是入门的关键：
镜像（Image）：容器的 “模板”，是一个只读的文件集合（包含应用代码、依赖、环境变量、配置文件等）。例如 nginx:alpine、mysql:8.0 都是官方镜像。
容器（Container）：镜像的 “运行实例”，是一个可读写的沙箱环境。容器之间相互隔离，拥有独立的网络和文件系统，可被启动、停止、删除。
仓库（Repository）：存放镜像的 “仓库”，类似代码仓库（如 GitHub）。分为公开仓库（如 Docker Hub，全球最大的公开镜像库）和私有仓库（如 Harbor，企业内部使用）。

## 1.2 为什么要用 Docker？

环境一致性：解决 “开发环境能跑，生产环境跑不了” 的经典问题（依赖、配置统一）。
轻量级：容器基于宿主机内核运行，无需像虚拟机（VM）那样模拟完整操作系统，启动快（秒级）、资源占用少（单宿主机可运行上千容器）。
隔离性：容器间相互隔离，避免应用间的依赖冲突（如 A 应用用 Python 3.8，B 应用用 Python 3.10）。
可移植性：容器可在任何支持 Docker 的环境中运行（物理机、云服务器、本地电脑）。
自动化部署：与 CI/CD 工具（Jenkins、GitLab CI）无缝集成，实现自动化构建、测试、发布。

# 2.安装Docker



#### 2.1.2 Ubuntu 20.04 安装

1. 卸载旧版本：

   ```bash
   sudo apt-get remove docker docker-engine docker.io containerd runc
   2. 安装依赖包：

   ```bash
   sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common3. 添加 Docker 官方 GPG 密钥：

   

   ```bash
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
   ```

4. 配置 Docker 仓库：

   

   ```bash
   sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
   ```

5. 安装 Docker CE：

   

   ```bash
   sudo apt-get update && sudo apt-get install -y docker-ce docker-ce-cli containerd.io
   ```

6. 启动 Docker 并设置开机自启：

   ```bash
   sudo systemctl start docker
   sudo systemctl enable docker
   ```

7. 验证安装：

   ```bash
   sudo docker --version  # 查看版本
   sudo docker run hello-world  # 运行测试容器（会自动拉取 hello-world 镜像）
   ```

# 3.配置Docker镜像加速

Docker 默认拉取镜像的源是 Docker Hub（国外服务器），国内访问速度极慢，需配置**国内镜像加速器**（如阿里云、网易云）。

### 3.1 主流国内加速源

| 加速源名称     | 加速地址                                                     |
| -------------- | ------------------------------------------------------------ |
| 阿里云（推荐） | https://<你的阿里云 ID>.[mirror.aliyuncs.com](https://mirror.aliyuncs.com/) |
| 网易云         | [https://hub-mirror.c.163.com](https://hub-mirror.c.163.com/) |
| DaoCloud       | [https://docker.m.daocloud.io](https://docker.m.daocloud.io/) |
| 腾讯云         | [https://mirror.ccs.tencentyun.com](https://mirror.ccs.tencentyun.com/) |

> 阿里云加速需注册阿里云账号，在「容器镜像服务」->「镜像加速器」中获取专属地址（免费）。

### 3.2 配置步骤（以 Linux 为例）

1. 创建 Docker 配置目录（若不存在）：

   ```bash
   sudo mkdir -p /etc/docker
   ```

2. 编写配置文件

    

   ```
   daemon.json
   ```

   

   ```bash
   sudo tee /etc/docker/daemon.json <<-'EOF'
   {
     "registry-mirrors": ["https://hub-mirror.c.163.com"]  # 替换为你的加速地址
   }
   EOF
   ```

3. 重启 Docker 服务使配置生效：

   

   ```bash
   sudo systemctl daemon-reload
   sudo systemctl restart docker
   ```

4. 验证配置：

   

   ```bash
   sudo docker info | grep "Registry Mirrors"
   ```

   

   若输出包含你配置的加速地址，说明配置成功。

# 4. Docker 常用命令

Docker 命令按功能可分为**镜像命令**、**容器命令**、**仓库命令**、**网络命令**等，以下是高频使用的核心命令。


### 4.1 镜像命令（操作 Image）

| 命令                                            | 作用                                       | 示例                                        |
| ----------------------------------------------- | ------------------------------------------ | ------------------------------------------- |
| `docker pull <镜像名>`                          | 拉取镜像（默认最新版，加 `:tag` 指定版本） | `docker pull nginx:1.24`                    |
| `docker images`                                 | 查看本地所有镜像                           | `docker images -a`（显示所有镜像）          |
| `docker rmi <镜像名>`                           | 删除镜像                                   | `docker rmi -f nginx:1.24`（强制删除）      |
| `docker build -t <镜像名:tag> <DockerFile路径>` | 基于 DockerFile 构建镜像                   | `docker build -t my-nginx:v1 .`（当前目录） |
| `docker save -o <压缩包名>.tar <镜像名>`        | 导出镜像为压缩包                           | `docker save -o nginx.tar nginx:1.24`       |
| `docker load -i <压缩包名>.tar`                 | 从压缩包导入镜像                           | `docker load -i nginx.tar`                  |


### 4.2 容器命令（操作 Container）

| 命令                                 | 作用                           | 示例                                                |
| ------------------------------------ | ------------------------------ | --------------------------------------------------- |
| `docker run <参数> <镜像名>`         | 基于镜像创建并启动容器         | `docker run -d -p 80:80 --name my-nginx nginx:1.24` |
| `docker ps`                          | 查看运行中的容器               | `docker ps -a`（查看所有容器，包括停止的）          |
| `docker start/stop <容器名/ID>`      | 启动/停止容器                  | `docker start my-nginx`                             |
| `docker restart <容器名/ID>`         | 重启容器                       | `docker restart my-nginx`                           |
| `docker exec -it <容器名/ID> <命令>` | 进入运行中的容器（交互模式）   | `docker exec -it my-nginx /bin/bash`                |
| `docker rm <容器名/ID>`              | 删除容器                       | `docker rm -f my-nginx`（强制删除运行中的容器）     |
| `docker logs <容器名/ID>`            | 查看容器日志                   | `docker logs -f my-nginx`（实时跟踪日志）           |
| `docker inspect <容器名/ID>`         | 查看容器详细信息（IP、配置等） | `docker inspect my-nginx`                           |


### 4.3 仓库命令（操作 Repository）

| 命令                                          | 作用                             | 示例                                              |
| --------------------------------------------- | -------------------------------- | ------------------------------------------------- |
| `docker login <仓库地址>`                     | 登录镜像仓库（默认 Docker Hub）  | `docker login`（登录 Docker Hub，需输入账号密码） |
| `docker logout <仓库地址>`                    | 退出镜像仓库                     | `docker logout`                                   |
| `docker tag <原镜像名> <仓库地址/镜像名:tag>` | 给镜像打标签（用于推送私有仓库） | `docker tag nginx:1.24 192.168.1.100/my-nginx:v1` |
| `docker push <仓库地址/镜像名:tag>`           | 推送镜像到仓库                   | `docker push 192.168.1.100/my-nginx:v1`           |

# 5. Docker 实战

通过 3 个经典实战案例，巩固 Docker 命令的使用。


### 5.1 实战 1：部署 Nginx 服务

目标：启动 Nginx 容器，通过宿主机 IP 访问 Nginx 首页。

1. 拉取 Nginx 镜像：

   ```bash
   docker pull nginx:1.24
   ```

2. 启动容器（端口映射：宿主机 80 端口 -> 容器 80 端口）：

   ```bash
   docker run -d \
     --name my-nginx \
     -p 80:80 \
     -v /opt/nginx/html:/usr/share/nginx/html \  # 挂载宿主机目录到容器（自定义首页）
     nginx:1.24
   ```

3. 验证：在浏览器输入宿主机 IP（如 `http://192.168.1.100`），若显示 Nginx 欢迎页，说明部署成功。

4. 自定义首页：在宿主机 `/opt/nginx/html` 目录下创建 `index.html`，内容如下，刷新浏览器即可看到自定义页面：

   ```html
   <h1>Hello Docker Nginx!</h1>
   ```


### 5.2 实战 2：部署 MySQL 服务

目标：启动 MySQL 容器，设置root密码，挂载数据卷（持久化数据）。

1. 拉取 MySQL 镜像：

   ```bash
   docker pull mysql:8.0
   ```

2. 启动容器（设置密码、挂载数据卷）：

   ```bash
   docker run -d \
     --name my-mysql \
     -p 3306:3306 \
     -e MYSQL_ROOT_PASSWORD=123456 \  # 设置 root 密码
     -v /opt/mysql/data:/var/lib/mysql \  # 挂载数据卷（持久化数据）
     mysql:8.0
   ```

3. 验证：通过 MySQL 客户端连接（如 Navicat、命令行）：

   ```bash
   # 宿主机安装 mysql-client 后连接
   mysql -h 127.0.0.1 -u root -p123456
   ```

   若能成功登录，说明 MySQL 部署成功。


### 5.3 实战 3：部署 Spring Boot 应用

目标：将本地 Spring Boot 项目打包为 Docker 镜像，启动容器并访问。

1. 准备 Spring Boot 项目：确保项目能正常运行（如提供 `/hello` 接口），打包为 JAR 包（`demo.jar`）。

2. 在 JAR 包同级目录创建 `DockerFile`：

   ```dockerfile
   # 基础镜像（Java 11）
   FROM openjdk:11-jre-slim
   # 作者信息
   MAINTAINER demo <demo@example.com>
   # 创建目录
   WORKDIR /app
   # 复制 JAR 包到容器
   COPY demo.jar /app/demo.jar
   # 暴露端口（项目端口）
   EXPOSE 8080
   # 启动命令
   CMD ["java", "-jar", "demo.jar"]
   ```

3. 构建镜像：

   ```bash
   docker build -t demo-app:v1 .
   ```

4. 启动容器：

   ```bash
   docker run -d --name demo-app -p 8080:8080 demo-app:v1
   ```

5. 验证：访问 `http://宿主机IP:8080/hello`，若返回接口数据，说明部署成功。

# 6. Docker 网络

Docker 容器间的通信、容器与宿主机的通信，依赖 Docker 网络。Docker 内置 5 种网络模式，默认使用 `bridge` 模式。


### 6.1 5 种网络模式对比

| 网络模式         | 特点                                      | 适用场景                                        |
| ---------------- | ----------------------------------------- | ----------------------------------------------- |
| `bridge`（默认） | 容器使用独立 IP，通过宿主机网桥与外界通信 | 多容器在同一宿主机内通信（如 Nginx 连接 MySQL） |
| `host`           | 容器共享宿主机网络（无独立 IP）           | 需使用宿主机端口，追求性能（如高性能服务）      |
| `none`           | 容器无网络（仅本地环路）                  | 无需网络的容器（如仅处理本地文件的脚本）        |
| `container`      | 容器共享另一个容器的网络（同 IP、端口）   | 需复用其他容器网络的场景（如 sidecar 模式）     |
| `overlay`        | 跨宿主机的容器网络（多宿主机容器通信）    | 分布式应用（如 Docker Swarm、K8s 集群）         |


### 6.2 常用网络命令

| 命令                                          | 作用                               | 示例                                            |
| --------------------------------------------- | ---------------------------------- | ----------------------------------------------- |
| `docker network ls`                           | 查看所有 Docker 网络               | `docker network ls`                             |
| `docker network create <网络名>`              | 创建自定义网络（默认 bridge 类型） | `docker network create my-network`              |
| `docker network connect <网络名> <容器名>`    | 将容器加入指定网络                 | `docker network connect my-network my-nginx`    |
| `docker network disconnect <网络名> <容器名>` | 将容器从网络移除                   | `docker network disconnect my-network my-nginx` |
| `docker network rm <网络名>`                  | 删除网络                           | `docker network rm my-network`                  |


### 6.3 实战：自定义网络实现容器通信

目标：创建自定义网络，让 Nginx 容器和 MySQL 容器在该网络内通信（无需端口映射）。

1. 创建自定义网络：

   ```bash
   docker network create demo-network
   ```

2. 启动 MySQL 容器并加入网络：

   ```bash
   docker run -d \
     --name demo-mysql \
     -e MYSQL_ROOT_PASSWORD=123456 \
     --network demo-network \  # 加入自定义网络
     mysql:8.0
   ```

3. 启动 Nginx 容器并加入网络：

   ```bash
   docker run -d \
     --name demo-nginx \
     --network demo-network \
     nginx:1.24
   ```

4. 验证通信：进入 Nginx 容器，ping MySQL 容器（用容器名作为 hostname）：

   ```bash
   docker exec -it demo-nginx /bin/bash
   ping demo-mysql  # 若能 ping 通，说明通信正常
   ```

# 7. DockerFile

DockerFile 是一个**文本文件**，包含一系列指令（如 `FROM`、`COPY`、`RUN`），用于定义“如何构建 Docker 镜像”。通过 DockerFile，可实现镜像构建的标准化和自动化。


### 7.1 DockerFile 核心指令

| 指令                       | 作用                                                         | 示例                                                         |
| -------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| `FROM <镜像名>`            | 指定基础镜像（必须是第一条指令）                             | `FROM openjdk:11-jre-slim`（基于 Java 11 镜像）              |
| `WORKDIR <路径>`           | 设置容器的工作目录（后续指令的默认目录）                     | `WORKDIR /app`                                               |
| `COPY <源路径> <目标路径>` | 复制宿主机文件到容器（源路径是相对 DockerFile 的路径）       | `COPY demo.jar /app/demo.jar`                                |
| `ADD <源路径> <目标路径>`  | 类似 COPY，但支持远程文件和压缩包自动解压                    | `ADD https://xxx/demo.tar.gz /app`（不推荐远程，用 COPY + wget 更灵活） |
| `RUN <命令>`               | 构建镜像时执行的命令（如安装依赖）                           | `RUN apt-get update && apt-get install -y curl`              |
| `EXPOSE <端口>`            | 声明容器暴露的端口（仅文档作用，不实际映射）                 | `EXPOSE 8080`                                                |
| `ENV <键>=<值>`            | 设置环境变量（构建和运行时都生效）                           | `ENV JAVA_OPTS="-Xms512m -Xmx1024m"`                         |
| `CMD <命令>`               | 容器启动时执行的命令（仅最后一条生效，可被 `docker run` 命令覆盖） | `CMD ["java", "-jar", "demo.jar"]`                           |
| `ENTRYPOINT <命令>`        | 容器启动时执行的命令（不可被覆盖，可与 CMD 配合传参）        | `ENTRYPOINT ["java", "-jar"]` + `CMD ["demo.jar"]`           |


### 7.2 编写最佳实践

1. **基础镜像选择**：优先选择官方、轻量级镜像（如 `alpine` 版本，体积小），避免使用 `latest` 标签（版本不稳定）。

   - 坏：`FROM ubuntu`（体积大，版本不确定）
   - 好：`FROM ubuntu:22.04` 或 `FROM nginx:1.24-alpine`

2. **合并 RUN 指令**：减少镜像层数（Docker 镜像分层存储，层数越多体积越大），用 `&&` 合并命令，用 `\` 换行。

   - 坏：

     ```dockerfile
     RUN apt-get update
     RUN apt-get install -y curl
     ```

   - 好：

     ```dockerfile
     RUN apt-get update && \
         apt-get install -y curl && \
         rm -rf /var/lib/apt/lists/*  # 清理缓存，减少体积
     ```

3. **使用 .dockerignore 文件**：排除无需复制到容器的文件（如 `node_modules`、`logs`、`.git`），减少镜像体积。

# 8. Docker Compose

当应用需要多个容器（如 Nginx + MySQL + Spring Boot）时，手动用 `docker run` 启动多个容器效率低且易出错。**Docker Compose** 是一个用于定义和运行“多容器 Docker 应用”的工具，通过一个 `docker-compose.yml` 文件配置所有容器，执行一条命令即可启动/停止所有服务。


### 8.1 安装 Docker Compose

- Linux 系统：

  ```bash
  # 下载 Compose（版本可替换为最新版）
  sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  # 赋予执行权限
  sudo chmod +x /usr/local/bin/docker-compose
  # 验证安装
  docker-compose --version
  ```

- Windows/macOS：安装 Docker Desktop 时已自带 Docker Compose，无需额外安装。


### 8.2 docker-compose.yml 核心结构

`docker-compose.yml` 是 YAML 格式文件，核心字段包括：

- `version`：指定 Compose 版本（需与 Docker 版本兼容，推荐 `3.8`）。
- `services`：定义所有容器服务（如 `nginx`、`mysql`、`app`），每个服务对应一个容器。
- `networks`：定义服务使用的网络（类似 `docker network create`）。
- `volumes`：定义数据卷（类似 `docker volume create`）。


### 8.3 实战：用 Compose 部署多容器应用

目标：通过 Compose 启动 Nginx + MySQL + Spring Boot 三个服务。

1. 项目结构：

   ```
   demo-project/
   ├── docker-compose.yml  # Compose 配置文件
   ├── app/                # Spring Boot 项目
   │   ├── demo.jar
   │   └── DockerFile
   └── nginx/              # Nginx 配置
       └── nginx.conf
   ```

2. 编写 `docker-compose.yml`：

   ```yaml
   version: '3.8'
   
   services:
     # Spring Boot 服务
     app:
       build: ./app  # 基于 ./app 目录的 DockerFile 构建镜像
       container_name: demo-app
       ports:
         - "8080:8080"
       environment:
         - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/demo_db?useSSL=false&serverTimezone=UTC
         - SPRING_DATASOURCE_USERNAME=root
         - SPRING_DATASOURCE_PASSWORD=123456
       depends_on:  # 依赖 mysql 服务，确保 mysql 先启动
         - mysql
       networks:
         - demo-network
   
     # MySQL 服务
     mysql:
       image: mysql:8.0
       container_name: demo-mysql
       ports:
         - "3306:3306"
       environment:
         - MYSQL_ROOT_PASSWORD=123456
         - MYSQL_DATABASE=demo_db  # 自动创建数据库
       volumes:
         - mysql-data:/var/lib/mysql  # 挂载数据卷（持久化）
       networks:
         - demo-network
   
     # Nginx 服务
     nginx:
       image: nginx:1.24
       container_name: demo-nginx
       ports:
         - "80:80"
       volumes:
         - ./nginx/nginx.conf:/etc/nginx/nginx.conf  # 挂载配置文件
       depends_on:
         - app
       networks:
         - demo-network
   
   # 定义网络
   networks:
     demo-network:
       driver: bridge
   
   # 定义数据卷
   volumes:
     mysql-data:  # 自动创建数据卷，持久化 MySQL 数据
   ```

3. 启动所有服务：在 `docker-compose.yml` 同级目录执行：

   ```bash
   docker-compose up -d  # -d 表示后台运行
   ```

4. 查看服务状态：

   ```bash
   docker-compose ps
   ```

5. 停止并删除所有服务（包括容器、网络，数据卷保留）：

   ```bash
   docker-compose down
   ```

6. 停止并删除所有服务+数据卷：

   ```bash
   docker-compose down -v
   ```

# 9. Docker 私有镜像站 - Harbor

Docker Hub 是公开镜像库，适合存储开源镜像，但企业内部的敏感镜像（如业务应用镜像）需存储在**私有镜像库**中。**Harbor** 是 VMware 开源的企业级私有镜像仓库，支持镜像管理、权限控制、漏洞扫描、日志审计等功能，是企业内部的首选。


### 9.1 Harbor 核心功能

- **镜像管理**：支持镜像的上传、下载、删除，按项目分组管理。
- **权限控制**：基于角色（RBAC）的访问控制（如管理员、开发者、访客）。
- **安全扫描**：集成 Clair 工具，扫描镜像中的漏洞。
- **日志审计**：记录所有镜像操作日志，便于追溯。
- **高可用**：支持多节点部署，避免单点故障。


### 9.2 安装 Harbor（基于 Docker Compose）

Harbor 依赖 Docker 和 Docker Compose，需先确保两者已安装。

1. 下载 Harbor 安装包：

   ```bash
   # 下载最新版（可从 https://github.com/goharbor/harbor/releases 查看最新版本）
   wget https://github.com/goharbor/harbor/releases/download/v2.10.0/harbor-offline-installer-v2.10.0.tgz
   # 解压
   tar -zxvf harbor-offline-installer-v2.10.0.tgz
   cd harbor
   ```

2. 配置 Harbor：

   - 复制模板配置文件：

     ```bash
     cp harbor.yml.tmpl harbor.yml
     ```

   - 编辑 `harbor.yml`，修改核心配置（其他配置默认即可）：

     ```yaml
     hostname: 192.168.1.100  # Harbor 服务器的 IP 或域名（必须修改）
     http:
       port: 80  # HTTP 端口（可选，生产环境推荐用 HTTPS）
     # https:  # 生产环境需配置 HTTPS，此处省略
     #   port: 443
     #   certificate: /your/cert/path
     #   private_key: /your/key/path
     harbor_admin_password: Harbor12345  # 管理员密码（默认，可修改）
     ```

3. 安装 Harbor：

   ```bash
   # 执行安装脚本（自动加载镜像、启动 Compose 服务）
   sudo ./install.sh
   ```

4. 验证安装：

   - 访问 Harbor 页面：在浏览器输入 `http://192.168.1.100`（你的 hostname），用账号 `admin`、密码 `Harbor12345` 登录。

   - 查看 Harbor 服务：

     ```bash
     cd harbor
     docker-compose ps  # 若所有服务状态为 Up，说明安装成功
     ```


### 9.3 实战：使用 Harbor 私有仓库

目标：将本地 `demo-app:v1` 镜像推送到 Harbor，再从其他机器拉取。

1. 在 Harbor 上创建项目：

   - 登录 Harbor 页面，点击「新建项目」，输入项目名（如 `demo-project`），选择「私有」（仅授权用户可访问）。

2. 本地机器登录 Harbor：

   ```bash
   # 若 Harbor 用 HTTP（非 HTTPS），需先配置 Docker 信任该仓库（否则登录失败）
   # 编辑 /etc/docker/daemon.json，添加 "insecure-registries": ["192.168.1.100"]
   sudo tee /etc/docker/daemon.json <<-'EOF'
   {
     "registry-mirrors": ["https://hub-mirror.c.163.com"],
     "insecure-registries": ["192.168.1.100"]  # 新增该行
   }
   EOF
   # 重启 Docker
   sudo systemctl daemon-reload && sudo systemctl restart docker
   
   # 登录 Harbor
   docker login 192.168.1.100
   # 输入 Harbor 账号（如 admin）和密码（Harbor12345）
   ```

3. 给镜像打标签（符合 Harbor 规范：`Harbor地址/项目名/镜像名:tag`）：

   ```bash
   docker tag demo-app:v1 192.168.1.100/demo-project/demo-app:v1
   ```

4. 推送镜像到 Harbor：

   ```bash
   docker push 192.168.1.100/demo-project/demo-app:v1
   ```

   - 推送成功后，在 Harbor 页面的「demo-project」项目中可看到该镜像。

5. 从其他机器拉取镜像：

   - 在目标机器上，同样配置 Docker 信任 Harbor 仓库（步骤 2）。

   - 登录 Harbor 并拉取镜像：

     ```bash
     docker login 192.168.1.100
     docker pull 192.168.1.100/demo-project/demo-app:v1
     ```


### 9.4 Harbor 日常维护

- **启动/停止 Harbor**：

  ```bash
  cd harbor
  docker-compose start  # 启动
  docker-compose stop   # 停止
  docker-compose restart  # 重启
  ```

- **升级 Harbor**：参考 [Harbor 官方升级文档](https://goharbor.io/docs/2.10.0/upgrade/)，需备份数据后执行升级脚本。

- **备份数据**：备份 Harbor 的数据库（默认存储在 `/data/database`）和镜像数据（默认存储在 `/data/registry`）。


---

通过以上 9 个主题的学习，你已掌握 Docker 从基础到进阶的核心知识，包括镜像/容器管理、网络配置、DockerFile 构建、Compose 多容器编排、Harbor 私有仓库。后续可进一步学习 Docker Swarm（Docker 原生集群）或 Kubernetes（K8s，容器编排领域标准），实现大规模容器的管理。

```
2. 



```