Offends/Kubernetes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

synchronization

Browse Source
This commit is contained in:
offends
2025-08-25 17:53:08 +08:00
commit c201eb5ef9
318 changed files with 23092 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
Docker/Docs/Bitnami部署Mysql主从.md Normal file
View File

@@ -0,0 +1,56 @@
> 本文作者：丁辉
# Bitnami部署Mysql主从
1. 创建持久化目录
```bash
mkdir -p /opt/mysql/data
chmod 777 /opt/mysql/data
```
2. 部署 Master 容器
```bash
docker run --name mysql-master --restart=always \
-p 3306:3306 \
-v /opt/mysql/data:/bitnami/mysql/data \
-e MYSQL_ROOT_PASSWORD=root \
-e MYSQL_REPLICATION_MODE=master \
-e MYSQL_REPLICATION_USER=slave \
-e MYSQL_REPLICATION_PASSWORD=slave_password \
-e MYSQL_AUTHENTICATION_PLUGIN=mysql_native_password \
-d bitnami/mysql:latest
```
3. 部署 Slave 容器
```bash
docker run --name mysql-slave --restart=always \
-p 3306:3306 \
-v /opt/mysql/data:/bitnami/mysql/data \
-e MYSQL_MASTER_HOST=<MYSQL_MASTER_HOST> \
-e MYSQL_MASTER_ROOT_PASSWORD=root \
-e MYSQL_MASTER_PORT_NUMBER=3306 \
-e MYSQL_REPLICATION_MODE=slave \
-e MYSQL_REPLICATION_USER=slave \
-e MYSQL_REPLICATION_PASSWORD=slave_password \
-e MYSQL_AUTHENTICATION_PLUGIN=mysql_native_password \
-d bitnami/mysql:latest
```
4. 进入 Slave 容器
```bash
docker exec -it mysql-slave bash
mysql -u root -proot
```
5. 查看同步状态
```bash
show slave status\G;
```
> 切记请勿在主使用清空 GTID 信息命令，会使主从状态失效

80
Docker/Docs/Centos安装Docker.md Normal file
View File

@@ -0,0 +1,80 @@
> 本文作者：丁辉
# Docker网络安装
> 整体来说各系统安装方式都相差不大,那么咱们这里只举例 Centos 安装 Docker 形式
>
> [官网安装文档](https://docs.docker.com/engine/install/)
## 开始部署
1. 卸载就办 Docker
```bash
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
```
2. 设置存储库
```bash
yum install -y yum-utils
```
```bash
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
```
> 国内源
>
> ```bash
> yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
> ```
3. 安装最新版
```bash
yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```
> 安装特定版本
>
> - 查看版本库
>
> ```bash
> yum list docker-ce --showduplicates | sort -r
> ```
>
> - 安装
>
> ```bash
> sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io docker-buildx-plugin docker-compose-plugin
> ```
4. 启动
```bash
systemctl enable docker
systemctl start docker
```
## 卸载 Docker
1. 卸载软件包
```bash
yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
```
2. 清理文件
```bash
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
```

82
Docker/Docs/Docker-fio磁盘读写测试.md Normal file
View File

@@ -0,0 +1,82 @@
> 本文作者：丁辉
# Docker-fio磁盘读写测试
[官方文档](https://fio.readthedocs.io/en/latest/fio_doc.html)
1. 拉取测试工具镜像
```bash
docker pull registry.cn-hangzhou.aliyuncs.com/offends/fio:latest
```
2. 启动并进入容器
> 为了更好的测试磁盘读写速率我们挂载 /data 目录进行测试
```bash
docker run --name disktest \
-it --rm -v /data/disk_test:/data/disk_test \
registry.cn-hangzhou.aliyuncs.com/offends/fio:latest \
sh
```
3. 开始测试
- 随机写
```bash
fio --ioengine=libaio --runtime=300 --numjobs=2 --iodepth=64 --bs=4k --size=2G --rw=randwrite --filename=/data/disk_test --time_based=1 --direct=1 --name=test --group_reporting --cpus_allowed=3 --cpus_allowed_policy=split
```
- 顺序写
```bash
fio --ioengine=libaio -runtime=300 --numjobs=2 --iodepth=64 --bs=1024k --size=10G --rw=write --filename=/data/disk_test --time_based=1 --direct=1 --name=test --group_reporting --cpus_allowed=3 --cpus_allowed_policy=split
```
4. 查看结果
> 随机写看（IOPS）
>
> 顺序写看（吞吐量BW）
# 命令参数
| 参数 | 描述 |
| -------------------- | ------------------------------------------------------------ |
| --debug=options | 启用调试日志记录，可以选择启用不同类型的调试信息，比如进程、文件、IO等等。 |
| --parse-only | 仅解析选项，不执行任何IO操作。 |
| --output | 将输出写入文件。 |
| --bandwidth-log | 生成带宽日志。 |
| --minimal | 生成最小化（简洁）的输出。 |
| --output-format=type | 指定输出格式，可以是简洁、JSON等。 |
| --terse-version=type | 设置简洁版本输出格式。 |
| --version | 打印版本信息并退出。 |
| --help | 打印帮助信息。 |
| --cpuclock-test | 执行CPU时钟的测试/验证。 |
| --crctest=[type] | 测试校验和功能的速度。 |
| --cmdhelp=cmd | 打印命令帮助，使用"all"可以查看所有命令。 |
| --enghelp=engine | 打印IO引擎的帮助信息，或者列出可用的IO引擎。 |
| --enghelp=engine,cmd | 打印特定IO引擎命令的帮助信息。 |
| --showcmd | 将作业文件转换为命令行选项。 |
| --eta=when | 指定何时打印ETA（预计完成时间）估计值。 |
| --eta-newline=time | 每个 'time' 时间段强制换行显示ETA。 |
| --status-interval=t | 每个 't' 时间段强制完整状态转储。 |
| --readonly | 打开安全只读检查，防止写入。 |
| --section=name | 只运行作业文件中指定的部分，可以指定多个部分。 |
| --alloc-size=kb | 将smalloc池的大小设置为指定的kb数（默认为16384）。 |
| --warnings-fatal | Fio解析器警告变为致命错误。 |
| --max-jobs=nr | 支持的最大线程/进程数。 |
| --server=args | 启动后端fio服务器。 |
| --daemonize=pidfile | 后台运行fio服务器，将PID写入文件。 |
| --client=hostname | 与远程后端fio服务器通信。 |
| --remote-config=file | 告诉fio服务器加载本地作业文件。 |
| --idle-prof=option | 报告系统或每CPU基础的CPU空闲情况或运行单位工作校准。 |
| --inflate-log=log | 解压缩并输出压缩日志。 |
| --trigger-file=file | 当文件存在时执行触发命令。 |
| --trigger-timeout=t | 在指定的时间执行触发器。 |
| --trigger=cmd | 将此命令设置为本地触发器。 |
| --trigger-remote=cmd | 将此命令设置为远程触发器。 |
| --aux-path=path | 使用此路径作为fio生成文件的路径。 |

188
Docker/Docs/DockerHub上传双架构镜像.md Normal file
View File

@@ -0,0 +1,188 @@
> 本文作者：丁辉
# DockerHub上传双架构镜像
## Docker manifest 推送双架构镜像
[官网文档](https://docs.docker.com/engine/reference/commandline/manifest/)
1. 构建并推送镜像
- X85执行
```bash
docker build -t offends/demo-x86:v1 .
docker push offends/demo-x86:v1
```
- arm执行
```bash
docker build -t offends/demo-arm:v1 .
docker push offends/demo-arm:v1
```
2. 创建 manifest
```bash
docker manifest create offends/demo:v1 \
offends/demo-x86:v1 \
offends/demo-arm:v1
```
3. 为镜像指定架构
```bash
docker manifest annotate offends/demo-x86:v1 \
offends/demo-x86:v1 \
--os linux --arch x86_64
docker manifest annotate offends/demo-arm:v1 \
offends/demo-arm:v1 \
--os linux --arch arm64 --variant v8
```
4. 查看
```bash
docker manifest inspect offends/demo:v1
```
5. 推送
```bash
docker manifest push offends/demo:v1
```
## Docker Buildx 推送双架构镜像
[Buildx二进制文件下载](https://github.com/docker/buildx/releases)
[模拟仓库文档](https://github.com/tonistiigi/binfmt)
[官网文档](https://docs.docker.com/build/building/multi-platform/)
1. 安装 Buildx
```bash
mkdir -p ~/.docker/cli-plugins
mv buildx-v*.linux-amd64 ~/.docker/cli-plugins/docker-buildx
chmod +x ~/.docker/cli-plugins/docker-buildx
docker buildx version
```
2. 添加模拟仓库
```bash
docker run --privileged --rm tonistiigi/binfmt --install all
```
> 内核版本需要升级，如果过低无法添加成功
3. 查看
```bash
docker buildx ls
#一下是输出
NAME/NODE DRIVER/ENDPOINT STATUS BUILDKIT PLATFORMS
default * docker
default default running v0.8+unknown linux/amd64, linux/386, linux/arm64, linux/riscv64, linux/ppc64le, linux/s390x, linux/arm/v7, linux/arm/v6
```
4. 创建 builder 示例
```bash
docker buildx create --name dmeo --use
```
5. 构建混合建构镜像
```bash
docker buildx build --platform linux/amd64,linux/arm64/v8 -t demo:v1 --push .
```
## Docker Buildx使用私有仓库 推送双架构镜像
### 部署私有镜像仓库
[Docker hub文档](https://docs.docker.com/registry/)
[GitHub文档](https://github.com/distribution/distribution)
1. 启动镜像仓库
```bash
docker run -d \
--name docker-registry \
--restart=always \
-p 5000:5000 \
-v /root/private-registry:/var/lib/registry \
registry
```
2. 将本机Docker添加非安全仓库
> Buildx 只允许 https 协议的镜像仓库使用，这里的方法之建议测试使用
```bash
cat > /etc/docker/daemon.json <<EOF
{
"experimental": true,
"insecure-registries": ["192.168.1.10:5000"]
}
EOF
```
3. 重启 docker 进程启用
```bash
systemctl restart docker
```
4. 将 buildkit 镜像推送到私仓
```bash
docker tag moby/buildkit:buildx-stable-1 192.168.1.10:5000/buildkit:buildx-stable-1
docker push 192.168.1.10:5000/buildkit:buildx-stable-1
```
5. 新增 buildkit 私仓配置
```bash
cat > /etc/buildkit/buildkitd.toml << EOF
debug = true
[registry."192.168.1.10:5000"]
http = true
insecure = true
EOF
```
6. 创建 builder
```bash
docker buildx create --use \
--name builder \
--driver-opt image=192.168.1.10:5000/buildkit:buildx-stable-1 \
--config /etc/buildkit/buildkitd.toml
```
7. 构建混合建构镜像
```bash
docker buildx build --platform linux/amd64,linux/arm64/v8 -t 192.168.1.10:5000/demo:v1 --push .
```
8. 查看
```bash
curl http://192.168.1.10:5000/v2/_catalog
```
### 清理
删除构建器实例
```bash
docker buildx rm builder
```

63
Docker/Docs/Docker上下文配置.md Normal file
View File

@@ -0,0 +1,63 @@
> 本文作者：丁辉
# Docker 上下文
## 基础命令
> 示例新上下文名为: docker-node2
- 查看当前上下文
```bahs
docker context ls
```
- 详细查看上下文信息
```bash
docker context inspect default
```
- 创建新的上下文
```bash
docker context create docker-node2 --docker host=tcp://docker:2375
```
- 切换上下文
```bash
docker context use docker-node2
```
> 通过变量切换
>
> ```bash
> export DOCKER_CONTEXT=docker-node2
> ```
>
> 全局`--context`标志覆盖上下文
>
> ```bash
> docker --context production container ls
> ```
- 导出上下文
```bash
docker context export docker-node2
```
- 导入上下文
```bash
docker context import docker-node2 docker-node2.dockercontext
```
- 更新上下文
```bash
docker context update docker-node2 --description "Test context"
```

90
Docker/Docs/Docker使用GPU.md Normal file
View File

@@ -0,0 +1,90 @@
> 本文作者丁辉
# GPU容器化基础环境准备
## Linux下载并安装GPU驱动(根据自身环境情况而定)
[请查看此文档](https://gitee.com/offends/Kubernetes/blob/main/GPU/Linux%E4%B8%8B%E8%BD%BD%E5%B9%B6%E5%AE%89%E8%A3%85GPU%E9%A9%B1%E5%8A%A8.md)
## 安装 NVIDIA 驱动程序 nvidia-container-toolkit
[官方文档](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
- **Centos**
配置生产存储库
```bash
curl -s -L https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo | \
tee /etc/yum.repos.d/nvidia-container-toolkit.repo
```
配置存储库以使用实验包(可选)
```bash
yum-config-manager --enable nvidia-container-toolkit-experimental
```
安装 NVIDIA Container Toolkit 软件包
```bash
yum install -y nvidia-container-toolkit
```
- **Ubuntu**
配置生产存储库
```bash
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
```
配置存储库以使用实验包(可选)
```bash
sed -i -e '/experimental/ s/^#//g' /etc/apt/sources.list.d/nvidia-container-toolkit.list
```
安装 NVIDIA Container Toolkit 软件包
```bash
apt-get update && apt-get install -y nvidia-container-toolkit
```
## 容器对接GPU
> 以 Docker 运行时举例
1. 使用 `nvidia-ctk` 修改配置文件
```bash
nvidia-ctk runtime configure --nvidia-set-as-default
```
> 无需担心此命令会覆盖源有的配置文件内容, 它只会通过修改来改变你当前的配置文件内容
**参数解释**
| 参数 | 描述 | 使用 |
| :-----------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: |
| `--runtime=` | 指定当前容器运行时: docker,containerd,crio 等(默认会自动选择当前容器运行时) | `nvidia-ctk runtime configure --runtime=docker` |
| `--config=` | 指定容器运行时的配置文件的位置 | `nvidia-ctk runtime configure --config=/etc/docker/daemon.json` |
| `--nvidia-set-as-default` | 指定 NVIDIA 容器运行时作为默认运行时 | `nvidia-ctk runtime configure --nvidia-set-as-default` |
2. 重启服务
```bash
systemctl restart docker
```
3. 测试
```bash
docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi
```
> 查看是否成功打印 GPU 信息

68
Docker/Docs/Docker使用Tor实现匿名通信.md Normal file
View File

@@ -0,0 +1,68 @@
> 本文作者：丁辉
# Docker使用Tor实现匿名通信
## 介绍
Tor（The Onion Router）是一种免费的开源软件，用于实现匿名通信。它通过全球范围内的一系列自愿维护的节点或“路由器”来转发和加密用户的互联网流量，从而隐藏用户的身份和位置。
[官方文档](https://community.torproject.org/onion-services/setup/install/)
## 开始部署
> 准备一个 Nginx 服务，部署 Tor 实现匿名通信 Nginx
>
> Nginx访问地址：192.168.1.10:80
1. 创建持久化目录
```bash
mkdir -p $HOME/tor-data
```
2. 目录授权
```bash
chmod 700 $HOME/tor-data
chown 100:65533 $HOME/tor-data
```
3. 编写配置文件
```bash
vi $HOME/tor-data/torrc
```
内容如下
```bash
Log notice file /var/log/tor/notices.log
SOCKSPort 0
HiddenServiceNonAnonymousMode 1
HiddenServiceSingleHopMode 1
# 配置代理
#Socks5Proxy sslocal-rust:1080
HiddenServiceDir /var/lib/tor/nginx
HiddenServicePort 80 192.168.1.10:80
```
4. 启动容器
```bash
docker run -itd \
--restart always \
-v $HOME/tor-data:/var/lib/tor \
-v $HOME/tor-data:/etc/tor \
--name=tor \
osminogin/tor-simple:latest
```
5. 查看 hostname
```bash
cat $HOME/tor-data/nginx/hostname
```
6. 通过匿名浏览器访问
> xxx.onion

117
Docker/Docs/Docker常用命令及参数.md Normal file
View File

@@ -0,0 +1,117 @@
> 本文作者：丁辉
# Docker基础命令
> 当然太简单的咱们就不记了,闭眼都会
## 基础命令
- 查看指定 Docker 镜像的历史记录,这个命令可以帮助你了解镜像是如何构建的
```bash
docker image history app:v1
```
## Docker镜像批量打包
第一种
```bash
docker save $(docker images | grep -v REPOSITORY | awk 'BEGIN{OFS=":";ORS=" "}{print $1,$2}') -o images.tar
```
第二种
> 将需要统一打包的镜像写在文件内
```bash
cat > images.txt <<EOF
nginx:alpine
nginx:latest
EOF
```
打包
```bash
docker save -o images.tar.gz $(cat images.txt)
```
## 清理资源命令
- 批量删除 Exited 容器
```bash
docker rm $(docker ps -q -f status=exited)
```
- 移除所有没有使用的镜像
```bash
docker image prune -a
```
> 跳过警告提示：`--force`或`-f`
>
> ```bash
> docker image prune -f
> ```
>
> 清理所有无用的镜像
>
> ```bash
> docker image prune --all --force
> ```
>
> 超过24小时创建的镜像
>
> ```bash
> docker image prune -a --filter "until=24h"
> ```
- 清理不再使用的移除容器
```bash
docker container prune
```
- 移除卷
```bash
docker volume prune
```
- 移除网络
```bash
docker network prune
```
- 清理卷
```bash
docker system prune --volumes
```
- 用于清理 Docker 系统中不再使用的资源，包括容器、镜像、网络和数据卷
```bash
docker system prune -a
```
## 基本构建参数
| 参数 | 描述 | 用法示例 |
| ------------------------- | ------------------------------------------------------------ | --------------------------------------------------- |
| `--target` | 选择构建过程中的目标阶段（Stage）。 | `docker build --target my-stage .` |
| `--no-cache` | 强制忽略缓存，每个指令都将重新执行。 | `docker build --no-cache .` |
| `--build-arg` | 设置构建过程中的参数变量。 | `docker build --build-arg MY_VAR=value .` |
| `--squash` | 合并镜像的历史记录以减小镜像层级数和总体积。 | `docker build --squash -t myimage:latest .` |
| `--disable-content-trust` | 在执行 `docker push` 和 `docker pull` 等命令时禁用内容信任。 | `docker build --disable-content-trust -t myimage .` |
## 启动参数
| 参数 | 描述 | 用法示例 |
| ----------------- | -------------------------------------- | ------------------------------------ |
| `--cpus=2` | 限制容器使用的 CPU 核心数量为 2 个。 | `docker run --cpus=2 myimage` |
| `--memory="200m"` | 限制容器可用的内存为 200 兆字节 (MB)。 | `docker run --memory="200m" myimage` |

74
Docker/Docs/Docker常用配置文件配置.md Normal file
View File

@@ -0,0 +1,74 @@
> 本文作者：丁辉
# Docker常用配置文件配置
## 更改IP池
- 添加如下参数
```bash
vi /etc/docker/daemon.json
```
```json
{
"default-address-pools" : [
{
"base" : "192.168.0.0/16",
"size" : 24
}
]
}
```
## 指定的 Cgroups 驱动程序
- 添加如下参数
```bash
vi /etc/docker/daemon.json
```
```bash
{
"exec-opts": ["native.cgroupdriver=systemd"]
}
```
- 验证
```bash
docker info|grep "Cgroup Driver"
```
## Docker启用实验性CLI功能
**第一种**
- 客户端开启
```bash
vi ~/.docker/config.json
```
```bash
{
"experimental": "enabled"
}
```
**第二种**
- 服务端开启
```bash
vi /etc/docker/daemon.json
```
```bash
{
"experimental": true
}
```

23
Docker/Docs/Docker快速部署LobeChat.md Normal file
View File

@@ -0,0 +1,23 @@
> 本文作者：丁辉
# Docker快速部署LobeChat
[Github](https://github.com/lobehub/lobe-chat) [官方文档](https://lobehub.com/zh/features) [官方部署文档](https://lobehub.com/zh/docs/self-hosting/platform/docker)
[OpenAi-Api-keys页面](https://platform.openai.com/api-keys)
```
docker run -d -p 3210:3210 \
-e OPENAI_API_KEY=sk-xxxx \
-e ACCESS_CODE=lobe66 \
--name lobe-chat \
lobehub/lobe-chat
```
**参数解释**
- `OPENAI_API_KEY`：这是用于访问 OpenAI 服务的 API 密钥。这个密钥用于验证请求的身份，并确保请求是由授权用户发起的。
- `OPENAI_PROXY_URL`：这是一个代理服务器的 URL，用于将请求重定向到指定的地址。这可以用于在请求 OpenAI API 时绕过直接访问限制，或者用于增加安全性。
- `ACCESS_CODE`：这是一个访问代码，可能用于程序内部的身份验证或控制访问某些功能。

33
Docker/Docs/Docker更改IP池.md Normal file
View File

@@ -0,0 +1,33 @@
> 本文作者：丁辉
# Docker更改IP池
1. 更改配置文件
```bash
vi /etc/docker/daemon.json
```
内容如下
```bash
{
"default-address-pools" : [
{
"base" : "192.168.0.0/16",
"size" : 24
}
]
}
```
2. 重启 Docker
```bash
systemctl restart docker
```

99
Docker/Docs/Docker构建镜像.md Normal file
View File

@@ -0,0 +1,99 @@
> 本文作者：丁辉
# Docker 构建镜像
> Docker 构建镜像有很多门道,今天咱就来说道说道,直接实际演示
>
> 为了方便简单演示,咱们就随便打包一份文件当作示例好了
## 多阶段构建
- 编写 Dockerfile
> 使用 AS 参数,后面定义名称
>
> 第二个容器直接 COPY 第一个容器所构建好的文件包使用
```bash
vi Dockerfile
```
```dockerfile
FROM alpine AS builder
RUN apk add git \
&& git clone https://gitee.com/offends/Docs.git \
&& tar -cvf Docker-Template.tar ./Docker-Template
FROM alpine
COPY --from=builder /Docker-Template.tar /
```
开始构建
```bash
docker build -t app:v1 .
```
## 多阶段构建,选定构建容器
- 编写 Dockerfile
> 当我们在一个 Dockerfile 中定义了多个容器构建,这里我门可以使用 `--target` 参数指定特定的容器构建
>
```bash
vi Dockerfile
```
```dockerfile
FROM alpine AS builder
RUN apk add git \
&& git clone https://gitee.com/offends/Docs.git \
&& tar -cvf Docker-Template.tar ./Docker-Template
FROM alpine AS builder-2
COPY --from=builder /Docker-Template.tar /
RUN rm -rf /Docker-Template.tar
FROM alpine AS builder-3
COPY --from=builder /Docker-Template.tar /
RUN tar -xvf /Docker-Template.tar
```
开始构建
```bash
docker build --target builder-3 -t app:v1 .
```
## 替换构建镜像或参数
- 编写 Dockerfile
> Dockerfile 可定义变量在外部指定
>
```bash
vi Dockerfile
```
```dockerfile
# 默认镜像使用 alpine ,通过外部定义修改镜像为 ubuntu
ARG IMAGE=alpine
FROM ${IMAGE}
# 定义一个ENV，默认值为: default_env,外部传入 NAME_ARG 让 NAME 变量值改变为 demo_env
ARG NAME_ARG
ENV NAME=${NAME_ARG:-default_env}
```
开始构建
```bash
docker build --build-arg NAME_ARG=demo_env --build-arg IMAGE=ubuntu -t app:v1 .
```

39
Docker/Docs/Docker部署Caddy.md Normal file
View File

@@ -0,0 +1,39 @@
> 本文作者：丁辉
# Docker部署Caddy
[官网](https://caddyserver.com/)
1. 启动 Caddy 容器
```bash
docker run -itd \
--restart always \
-p 80:80 \
-v /data/caddy:/etc/caddy/ \
--name=caddy \
caddy:latest
```
2. 进入容器修改配置文件
```bash
vi /data/caddy/Caddyfile
```
内容如下
```bash
:80 {
root * /etc/caddy/www
file_server
}
```
3. 重启容器
```bash
docker restart caddy
```
4. 访问 IP:80

169
Docker/Docs/Docker部署Gitlab.md Normal file
View File

@@ -0,0 +1,169 @@
> 本文作者：丁辉
# Docker部署Gitlab
[企业版官网网址](https://docs.gitlab.com/ee/install/docker.html)
> 部署开源版
>
> 例：本地 IP 为 192.168.1.10
## 部署Gitlab
1. 启动容器
> 这里也可以通过 `--hostname 192.168.1.10` 指定 Clone 地址，Gitlab会通过读取本地主机名作为默认的 Clone 地址
```bash
docker run -itd \
--restart always \
-p 80:80 \
-p 222:22 \
-u root \
-v $PWD/data/log:/var/log/gitlab \
-v $PWD/data/opt:/var/opt/gitlab \
-v $PWD/data/etc:/etc/gitlab \
--privileged=true \
--name=gitlab \
gitlab/gitlab-ce:latest
```
2. 进入容器查看 root 初始密码
```bash
docker exec -it gitlab bash
```
```bash
cat /etc/gitlab/initial_root_password
```
> 访问 192.168.1.10:80
3. 修改 SSH Clone 地址(进入容器内执行)
```bash
cp /etc/gitlab/gitlab.rb /etc/gitlab/gitlab.rb.bak
vi /etc/gitlab/gitlab.rb
```
写入如下内容
```bash
external_url "http://192.168.1.10:80" #http对外clone地址
gitlab_rails["gitlab_ssh_host"] = "192.168.1.10" #ssh对外clone地址
gitlab_rails["gitlab_shell_ssh_port"] = 222 #ssh对外clone端口
```
4. 重启服务
```bash
gitlab-ctl reconfigure
```
## 安装Gitlab-runner
1. 启动容器
```bash
docker run -itd --name gitlab-runner \
--restart always \
--privileged=true \
-v $PWD/data/gitlab-runner-config:/etc/gitlab-runner \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /usr/local/bin/docker:/usr/bin/docker \
gitlab/gitlab-runner:latest
```
2. 创建 Runner 实例获取 Token
点击Admin Area(管理员设置) > 点击CI/CD > 点击Runners > 点击New project runner > 选择Linux > 填写一个Tags > 点击Create runner
3. 进入容器
```bash
docker exec -it gitlab-runner bash
```
4. 开始注册 Runner
```bash
gitlab-ci-multi-runner register
```
过程如下
```bash
Runtime platform arch=amd64 os=linux pid=106 revision=6e766faf version=16.4.0
Running in system-mode.
Enter the GitLab instance URL (for example, https://gitlab.com/):
http://192.168.1.10 #Gitlab地址
Enter the registration token:
******** #刚刚获取到的Token
Verifying runner... is valid runner=Te1gEas2d
Enter a name for the runner. This is stored only in the local config.toml file:
[f94c7a9b1272]: test #名称
Enter an executor: docker+machine, instance, kubernetes, docker-windows, shell, virtualbox, docker-autoscaler, custom, docker, parallels, ssh:
shell #输入一个执行器
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!
Configuration (with the authentication token) was saved in "/etc/gitlab-runner/config.toml"
```
5. 开始测试
在测试仓库内创建 `.gitlab-ci.yml` 文件编写内容
```yml
stages:
- test
build-test:
stage: test
tags:
- test
script:
- echo "Hello world"
```
6. 查看结果
进入测试仓库 > 点击Build > 点击Pipelines > 查看到 `passed` 即为成功可点击进去查看
## 忘记密码
1. 进入容器
```bash
docker exec -it gitlab /bin/bash
```
2. 进⼊控制台(需要等待一段时间)
```bash
gitlab-rails console -e production
```
3. 查询root⽤户
```bash
user=User.where(id:1).first
```
4. 设置密码
```bash
user.password='password'
```
5. 保存退出
```bash
user.save!
exit
```

31
Docker/Docs/Docker部署JumpServer.md Normal file
View File

@@ -0,0 +1,31 @@
> 本文作者：丁辉
# Docker部署JumpServer
[官网](https://docs.jumpserver.org/zh/master/install/setup_by_fast/) [JumpServer安装包](https://github.com/jumpserver/installer/releases)
1. 部署 Mysql 数据库
```bash
docker run -itd --name jump-mysql \
--restart=always -p 3306:3306 \
-v /usr/local/jumpserver/data:/var/lib/mysql \
-v /usr/local/jumpserver/logs:/var/log/mysql \
-v /usr/local/jumpserver/conf:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=jumpserver \
-e MYSQL_DATABASE=jumpserver \
mysql:5.7
```
2. 解压 JumpServer 安装包
```bash
tar -xf jumpserver-installer-v*.tar.gz
cd jumpserver-installer-v*
```
3. 修改 `config-example.txt` 文件配置参数, 并启动
```bash
./jmsctl.sh install
```

58
Docker/Docs/Docker部署Nacos.md Normal file
View File

@@ -0,0 +1,58 @@
> 本文作者：丁辉
# Docker部署Nacos
[官网文档](https://nacos.io/zh-cn/docs/v2/guide/user/auth.html)
1. 启动 MYSQL
```bash
docker run --name nacos-mysql --restart=always \
-p 3306:3306 \
-v /data/mysql:/var/lib/mysql \
-e MYSQL_USER=nacos \
-e MYSQL_PASSWORD=nacos \
-e MYSQL_DATABASE=nacos \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:latest
```
2. 启动 NACOS
```bash
docker run --name nacos --restart=always \
-p 8848:8848 \
-e MYSQL_SERVICE_HOST=${MYSQL_HOST} \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=nacos \
-e MYSQL_SERVICE_PASSWORD=nacos \
-e MYSQL_SERVICE_DB_NAME=nacos \
-e MODE=standalone \
-e PREFER_HOST_MODE=hostname \
-d mysql:latest
```
3. 开启登录
```bash
vi /data/nacos/application.properties
```
内容如下
```bash
# vi /data/nacos/application.properties
nacos.core.auth.enabled=true
nacos.core.auth.server.identity.key=nacos
nacos.core.auth.server.identity.value=nacos
nacos.core.auth.plugin.nacos.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789
```
4. 访问：http://localhost:8848/nacos/#/login
> 启动挂载配置文件
>
> ```bash
> -e /data/nacos/application.properties:/home/nacos/conf/application.properties
> ```

16
Docker/Docs/Docker部署Node-exporter.md Normal file
View File

@@ -0,0 +1,16 @@
> 本文作者：丁辉
# Docker部署Node-exporter
```bash
docker run -d --restart=always \
-p 9100:9100 \
-v "/proc:/host/proc:ro" \
-v "/sys:/host/sys:ro" \
-v "/:/rootfs:ro" \
--net="host" \
--restart=always \
--name node-exporter \
prom/node-exporter
```

45
Docker/Docs/Docker部署Portainer.md Normal file
View File

@@ -0,0 +1,45 @@
> 本文作者：丁辉
>
# Docker部署Portainer
[官方文档](https://docs.portainer.io/)
> 通过Portainer管理docker
## Docker部署
```bash
docker run -d -p 9000:9000 \
--name portainer --restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /data/portainer:/data \
portainer/portainer-ce:latest
```
## 远程连接Docker
远程连接默认端口是2375 [Docker配置2375端口文档](https://gitee.com/offends/Kubernetes/blob/main/Docker/Docs/Docker%E9%85%8D%E7%BD%AE2375%E7%AB%AF%E5%8F%A3.md)
## 忘记密码
1. 下载新镜像
```bash
docker pull portainer/helper-reset-password
```
2. 关闭容器
```bash
docker stop portainer
```
3. 启动观看密码
```bash
docker run --rm -v portainer_data:/data portainer/helper-reset-password
```

158
Docker/Docs/Docker部署Watchtower管理容器更新.md Normal file
View File

@@ -0,0 +1,158 @@
> 本文作者：丁辉
# Docker部署Watchtower管理容器更新
[Github仓库](https://github.com/containrrr/watchtower)
## 介绍
Watchtower 是一个开源的容器监控和自动更新工具，设计用于Docker容器环境。它可以监控正在运行的容器及其使用的镜像，当发现镜像有更新时，自动拉取新镜像并重新启动容器。这种自动化管理方式有助于确保部署的应用保持最新状态，从而减少安全风险和改进功能。
## 快速开始
```bash
docker run -d \
--name watchtower \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower
```
所有容器都会自动更新，也包括 Watch­tower 本身。
## 其他启动参数
- 自动清除旧镜像
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower \
--cleanup
```
> `--cleanup` 选项可以简写为 `-c`
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c
```
- 选择性自动更新
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
nginx redis
```
- 配置容器更新列表
```bash
vi ~/.watchtower.list
```
内容如下
```bash
nginx
reidis
```
启动 Watchtower 容器
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
$(cat ~/.watchtower.list)
```
- 设置单个容器自动更新标签
```bash
docker run -d \
--name nginx \
--restart always \
--label com.centurylinklabs.watchtower.enable=true \
nginx:latest
```
启动 Watchtower 容器
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
--label-enable
```
> `--label-enable` 可以简写为 `-e`
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -ce
```
- 设置自动更新检查频率
- `--interval` 设置更新检测时间间隔单位为秒。
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
--interval 3600
```
- `--schedule` 设置定时检测更新时间。格式为 6 字段 Cron 表达式，而非传统的 5 字段，第一位是秒。
> 比如每天凌晨 2 点检查一次更新
```bash
docker run -d \
--name watchtower \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
--schedule "0 0 2 * * *"
```
- 手动更新
> 检查 nginx 是否需要更新
```bash
docker run --rm \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -c \
--run-once \
nginx
```
> `--run-once` 可以简写为 `-R`
```bash
docker run --rm \
-v /var/run/docker.sock:/var/run/docker.sock \
containrrr/watchtower -cR \
nginx
```
> 当容器设置过 `com.centurylinklabs.watchtower.enable=false` 参数则不会更新

63
Docker/Docs/Docker配合Mysql-Secrets使用.md Normal file
View File

@@ -0,0 +1,63 @@
> 本文作者：丁辉
# Docker配合Mysql-Secrets使用
1. 配置密码
```bash
echo "root" > root-pass.txt
echo "root" > offends-pass.txt
```
2. 创建 Secrets
```bash
docker secret create mysql-root-pass ./root-pass.txt
docker secret create mysql-offends-pass ./offends-pass.txt
```
3. 构建容器
```bash
docker build -t mysql:v1 --file=./Dockerfile-secrets .
```
4. 创建持久化目录
```bash
mkdir /data/mysqld
```
5. 启动容器
```bash
docker service create \
--name mysql \
--replicas 1 \
--publish published=3306,target=3306 \
--mount type=bind,source=/data/mysqld,destination=/var/lib/mysql \
--secret source=mysql-root-pass,target=/run/secrets/mysql-root-pass \
--secret source=mysql-offends-pass,target=/run/secrets/mysql-offends-pass \
mysql:v1
```
6. 查看
```bash
docker service ps mysql
```
> 查看完整事件
>
> ```bash
> docker service ps mysql --no-trunc
> ```
7. 停止容器
```bash
docker service rm mysql
```

165
Docker/Docs/Docker配置2375端口.md Normal file
View File

@@ -0,0 +1,165 @@
> 本文作者：丁辉
# Docker配置2375端口
## 方法一
1. 配置 `/etc/docker/daemon.json` 文件
```bash
vi /etc/docker/daemon.json
```
内容如下
```json
{
"hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]
}
```
2. 重载并重启 Docker
```bash
systemctl daemon-reload
systemctl restart docker
```
## 方法二
1. 修改 `/usr/lib/systemd/system/docker.service` 文件
```bash
vi /usr/lib/systemd/system/docker.service
```
- 旧版 Docker
```bash
ExecStart=/usr/local/bin/dockerd -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock
```
- 新版 Docker
```bash
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H fd:// --containerd=/run/containerd/containerd.sock
```
2. 重载并重启 Docker
```bash
systemctl daemon-reload
systemctl restart docker
```
## 验证
- 查看端口是否启动
```bash
netstat -anput | grep 2375
```
- 测试
```bash
docker -H tcp://192.168.1.10:2375 ps
```
# 配置证书访问
1. 可以使用本脚本生成证书
```bash
curl -Os https://gitee.com/offends/Linux/raw/main/File/Shell/openssl-cert.sh && chmod 777 ./openssl-cert.sh
```
> 修改
>
> ```bash
> IP="127.0.0.1" # 本地 IP 地址
> PASSWORD="123456" # 证书密码
> VALIDITY_PERIOD=3650 # 证书有效时间
> ```
2. 执行脚本
```bash
./openssl-cert.sh
```
3. 修改 `/usr/lib/systemd/system/docker.service` 文件
```bash
vi /usr/lib/systemd/system/docker.service
```
- 旧版 Docker
```bash
ExecStart=/usr/bin/dockerd --tlsverify --tlscacert=/etc/docker/cert/2375/ca.pem --tlscert=/etc/docker/cert/2375/server-cert.pem --tlskey=/etc/docker/cert/2375/server-key.pem -H unix:///var/run/docker.sock
```
- 新版 Docker
```bash
ExecStart=/usr/bin/dockerd --tlsverify --tlscacert=/etc/docker/cert/2375/ca.pem --tlscert=/etc/docker/cert/2375/server-cert.pem --tlskey=/etc/docker/cert/2375/server-key.pem -H tcp://0.0.0.0:2375 -H fd:// --containerd=/run/containerd/containerd.sock
```
4. 重载并重启 Docker
```bash
systemctl daemon-reload
systemctl restart docker
```
5. 验证
```bash
docker --tlsverify --tlscacert=/etc/docker/cert/2375/ca.pem --tlscert=/etc/docker/cert/2375/server-cert.pem --tlskey=/etc/docker/cert/2375/server-key.pem -H tcp://192.168.1.10:2375 ps
```
# 问题记录
> [方法一] 由于 Docker 在最近新版更换了容器引擎为 Containerd, daemon.json 文件如果配置原来的通信套接字文件路径是不行的,现在也没有更好的解决方案,本次我就记录一下从老外那里学来的方法。
>
> 嗯......为什么说这个方案也不是很对呢,因为他会替换你的 Docker 启动命令,那为什么不直接改 `docker.service` 呢?反正咱只是记录一下,通过修改 docker.service 方法我也放在 [方法二] 里了你们自己看吧
1. 配置 `/etc/docker/daemon.json` 文件
```bash
vi /etc/docker/daemon.json
```
内容如下
```json
{
"hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]
}
```
2. 创建 `override.conf` 文件
```bash
mkdir -p /etc/systemd/system/docker.service.d/
vi /etc/systemd/system/docker.service.d/override.conf
```
文件内容为
```bash
[Service]
ExecStart=
ExecStart=/usr/bin/dockerd --config-file /etc/docker/daemon.json
```
3. 重载并重启 Docker
```bash
systemctl daemon-reload
systemctl restart docker
```

83
Docker/Docs/Docker配置代理.md Normal file
View File

@@ -0,0 +1,83 @@
> 本文作者：丁辉
# Docker配置代理
## Docker服务代理配置
> 此方法适用于 `docker pull` 镜像配置代理
创建 Systemd 代理文件
```bash
mkdir -p /etc/systemd/system/docker.service.d
touch /etc/systemd/system/docker.service.d/proxy.conf
```
内容如下
```bash
[Service]
Environment="HTTP_PROXY=http://127.0.0.1:15777"
Environment="HTTPS_PROXY=http://127.0.0.1:15777"
Environment="NO_PROXY=localhost,127.0.0.1,example.com"
```
- `HTTP_PROXY=`：设置HTTP代理服务器
- `HTTPS_PROXY=`：设置HTTPS代理服务器
- `NO_PROXY=""`：设置不使用代理服务器的域名或IP地址列表
> 将 `http://127.0.0.1:15777` 换成可用的代理即可
重启生效
```bash
systemctl daemon-reload
systemctl restart docker
```
## 容器内部代理
> 在容器运行阶段，如果需要代理上网，则需要配置 `~/.docker/config.json`。
创建 Config.json 代理文件
```bash
mkdir ~/.docker/
vi ~/.docker/config.json
```
内容如下
```json
{
"proxies":
{
"default":
{
"httpProxy": "http://192.168.1.100:15777",
"httpsProxy": "http://192.168.1.100:15777",
"noProxy": "localhost,127.0.0.1,example.com"
}
}
}
```
> 此外, 也可以直接在容器运行时通过注入 `http_proxy` 等环境变量进行代理
重启生效
```bash
systemctl daemon-reload
systemctl restart docker
```
## DockerBuild代理
```bash
docker build . \
--build-arg "HTTP_PROXY=http://192.168.1.100:15777" \
--build-arg "HTTPS_PROXY=http://192.168.1.100:15777" \
--build-arg "NO_PROXY=localhost,127.0.0.1,example.com" \
-t your/image:tag
```

137
Docker/Docs/Docker配置守护进程.md Normal file
View File

@@ -0,0 +1,137 @@
> 本文作者：丁辉
# Docker配置守护进程
> 通过修改 `/etc/docker/daemon.json` 配置守护进程
>
> [官方文档](https://docs.docker.com/engine/reference/commandline/dockerd/#daemon) [示例文件位置](https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file)
- 编写基础配置
```json
{
"registry-mirrors": [
"https://dockerhub.azk8s.cn",
"https://docker.mirrors.ustc.edu.cn",
"http://hub-mirror.c.163.com"
],
"insecure-registries": [],
"max-concurrent-downloads": 10,
"max-concurrent-uploads": 10,
"log-driver": "json-file",
"log-level": "warn",
"log-opts": {
"max-size": "10m",
"max-file": "3"
},
"data-root": "/var/lib/docker"
}
```
- 建立垃圾收集
```json
{
"builder": {
"gc": {
"enabled": true,
"defaultKeepStorage": "10GB",
"policy": [
{ "keepStorage": "10GB", "filter": ["unused-for=2200h"] },
{ "keepStorage": "50GB", "filter": ["unused-for=3300h"] },
{ "keepStorage": "100GB", "all": true }
]
}
}
}
```
- 验证守护进程配置文件
```bash
dockerd --validate --config-file=/etc/docker/daemon.json
```
- 重载 Docker
```bash
systemctl reload docker
```
# 参数
| 参数 | 用法和说明 | 默认值/示例 |
| -------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| allow-nondistributable-artifacts | 允许的非分发性文件列表（为空） | true/false |
| api-cors-header | API的跨源资源共享（CORS）头部，允许对API进行跨域请求 | "" （空字符串）或 * 或指定IP地址或域名 |
| authorization-plugins | 授权插件列表（为空） | |
| bip | 容器网络的默认桥接接口的IP范围 | "" （空字符串） |
| bridge | 指定容器网络的默认桥接接口 | "" （空字符串） |
| cgroup-parent | 指定容器的cgroup父目录 | |
| containerd | 容器运行时 containerd 的socket路径 | "/run/containerd/containerd.sock" |
| containerd-namespace | 容器运行时 containerd 的命名空间 | "docker" |
| containerd-plugin-namespace | 容器运行时 containerd 插件的命名空间 | "docker-plugins" |
| data-root | Docker 数据的根目录路径 | |
| debug | 是否启用调试模式 | true/false（根据具体实现或配置文件而定） |
| default-address-pools | 默认的地址池设置列表，包括基础地址和子网大小 | 示例：[]（空列表） |
| default-cgroupns-mode | 默认的cgroup命名空间模式（通常是私有） | "private"（私有模式） |
| default-gateway | 默认网关设置 | |
| default-gateway-v6 | 默认IPv6网关设置 | |
| default-network-opts | 默认网络选项 | |
| default-runtime | 默认容器运行时 | "runc"（具体容器运行时的名称） |
| default-shm-size | 默认的共享内存大小 | "64M"（64兆字节） |
| default-ulimits | 默认的ulimit设置，指定文件描述符的硬限制和软限制 | 示例：{"nofile": {"Hard": 64000, "Name": "nofile", "Soft": 64000}} （文件描述符限制示例） |
| dns | DNS服务器列表 | 示例：[]（空列表） |
| dns-opts | DNS选项列表 | 示例：[]（空列表） |
| dns-search | DNS搜索域列表 | 示例：[]（空列表） |
| exec-opts | 容器执行参数列表 | 示例：[]（空列表） |
| exec-root | 容器执行的根目录路径 | "" （空字符串） |
| experimental | 是否启用实验性功能 | true/false（根据具体实现或配置文件而定） |
| features | Docker功能列表 | |
| fixed-cidr | 固定CIDR地址设置（通常用于设置 Docker 容器的 IP 地址） | "" （空字符串） |
| fixed-cidr-v6 | 固定IPv6 CIDR地址设置（通常用于设置 Docker 容器的 IPv6 地址） | "" （空字符串） |
| group | Docker进程的用户组 | |
| hosts | 主机名设置列表 | 示例：[]（空列表） |
| proxies | 代理设置，包括HTTP代理、HTTPS代理和不使用代理的地址列表 | |
| icc | 是否启用容器间通信 | false （默认值为false） |
| init | 是否启用自定义初始化进程 | false （默认值为false） |
| init-path | 自定义初始化进程的路径 | "/usr/libexec/docker-init" |
| insecure-registries | 不安全的镜像仓库列表 | 示例：[]（空列表） |
| ip | Docker守护进程监听的IP地址 | 0.0.0.0 |
| ip-forward | 是否启用IP转发 | false （默认值为false） |
| ip-masq | 是否启用IP伪装 | false （默认值为false） |
| iptables | 是否启用iptables | false （默认值为false） |
| ip6tables | 是否启用ip6tables | false （默认值为false） |
| ipv6 | 是否启用IPv6 | true/false（根据具体实现或配置文件而定） |
| labels | 标签设置列表 | 示例：[]（空列表） |
| live-restore | 是否启用容器守护进程在宕机时自动恢复容器 | true/false（根据具体实现或配置文件而定） |
| log-driver | 日志驱动设置（默认为json-file） | "json-file"（JSON文件） |
| log-level | 日志级别设置 | "" （空字符串） |
| log-opts | 日志选项设置，包括缓存禁用、缓存大小、缓存最大文件数等 | 示例：{"max-size": "10m", "max-file": "5"}（最大大小为10兆字节，最大文件数为5） |
| max-concurrent-downloads | 最大并发下载任务数 | 3（示例值） |
| max-concurrent-uploads | 最大并发上传任务数 | 5（示例值） |
| max-download-attempts | 最大下载尝试次数 | 5（示例值） |
| mtu | 最大传输单元设置 | 0（示例值） |
| no-new-privileges | 是否禁用新特权 | false （默认值为false） |
| node-generic-resources | 节点通用资源列表，通常用于指定GPU等硬件资源 | 示例：["NVIDIA-GPU=UUID1", "NVIDIA-GPU=UUID2"]（GPU资源示例） |
| oom-score-adjust | OOM分数调整设置 | 0（示例值） |
| pidfile | PID文件路径设置 | |
| raw-logs | 是否启用原始日志记录 | true/false（根据具体实现或配置文件而定） |
| registry-mirrors | 镜像仓库镜像设置列表 | 示例：[]（空列表） |
| runtimes | 容器运行时设置，可以包括自定义运行时的路径和参数 | |
| seccomp-profile | 安全策略配置文件路径 | "" （空字符串） |
| selinux-enabled | 是否启用SELinux | true/false（根据具体实现或配置文件而定） |
| shutdown-timeout | 容器守护进程关闭超时设置 | 15（示例值） |
| storage-driver | 存储驱动设置 | |
| storage-opts | 存储选项设置列表 | 示例：[]（空列表） |
| swarm-default-advertise-addr | Swarm模式下的默认广告地址设置 | |
| tls | 是否启用TLS | true/false（根据具体实现或配置文件而定） |
| tlscacert | TLS CA证书路径 | |
| tlscert | TLS证书路径 | |
| tlskey | TLS密钥路径 | |
| tlsverify | 是否验证TLS | true/false（根据具体实现或配置文件而定） |
| userland-proxy | 是否使用用户空间代理 | true/false（根据具体实现或配置文件而定） |
| userland-proxy-path | 用户空间代理的路径 | "/usr/libexec/docker-proxy" |
| userns-remap | 用户命名空间重映射设置 | |

27
Docker/Docs/Docker镜像批量打包.md Normal file
View File

@@ -0,0 +1,27 @@
> 本文作者：丁辉
# Docker镜像批量打包
- 第一种
```bash
docker save $(docker images | grep -v REPOSITORY | awk 'BEGIN{OFS=":";ORS=" "}{print $1,$2}') -o k8s-master.tar
```
- 第二种
> 将需要统一打包的镜像写在文件内
```bash
cat > images.txt <<EOF
nginx:alpine
nginx:latest
EOF
```
打包
```bash
docker save -o images.tar.gz $(cat images.txt)
```

234
Docker/Docs/Docker集群.md Normal file
View File

@@ -0,0 +1,234 @@
> 本文作者：丁辉
# Docker Swarm集群
[官方文档](https://docs.docker.com/engine/swarm/swarm-tutorial/deploy-service/)
| 节点IP | 角色 |
| :----------: | :----: |
| 192.168.1.10 | MASTER |
| 192.168.1.20 | WORKER |
## 开始组建集群
1. 初始化 MASTER 节点
```bash
docker swarm init
```
> 指定 IP
>
> ```bash
> docker swarm init --advertise-addr 192.168.1.10
> ```
>
> 指定网段
>
> ```bash
> --default-addr-pool 192.168.1.0/24
> ```
2. WORKER 节点加入集群
```bash
docker swarm join --token <token> 192.168.1.10:2377
```
3. 检查所有节点
```bash
docker node ls
```
> 删除节点命令为
>
> ```bash
> docker swarm leave
> ```
>
> 强制使用 ` --force` 参数
## 常用基础命令
- 查看加入 MASTER TOKEN
```bash
docker swarm join-token manager
```
- 查看加入 WORKER TOKEN
```bash
docker swarm join-token worker
```
- 查看所有节点
```bash
docker node ls
```
- 查看节点详情
```bash
docker node inspect <节点名称> --pretty
```
## Secrets 基础操作
- 创建 Secrets
```
docker secret create <Secrets名称> ./<文件位置>
```
> echo 创建 Secrets
>
> ```bash
> echo "内容" | docker secret create <Secrets名称> -
> ```
>
> openssl 创建 Secrets,生成一个随机的20个字符的密码,并将其作为密钥存储到Docker中
>
> ```bash
> openssl rand -base64 20 | docker secret create mysql_password -
> ```
- 查看 Secrets
```bash
docker secret ls
```
- 检查 Secrets
```bash
docker secret inspect <Secrets名称>
```
- 删除 Secrets
```bash
docker secret rm <Secrets名称>
```
## Network 基础操作
- 创建 Network
```
docker network create -d overlay <网络名称>
```
- 查看 Network
```bash
docker network ls
```
- 检查 Network
```bash
docker network inspect <网络名称>
```
- 删除 Network
```bash
docker network rm <网络名称>
```
## Volume 基础操作
- 创建 Volume
```
docker volume create -d overlay <存储名称>
```
- 查看 Volume
```bash
docker volume ls
```
- 检查 Volume
```bash
docker volume inspect <存储名称>
```
- 删除 Volume
```bash
docker volume rm <存储名称>
```
## 启动容器测试
```bash
docker service create \
--name mysql \
--replicas 1 \
--mount type=bind,source=/data/mysqld,destination=/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD="root" \
mysql
```
**其他参数**
- 指定 Docker 节点
```bash
--constraint 'node.hostname==节点名称'
```
- 指定对外端口
```bash
--publish published=<容器对外端口>,target=<容器内部端口>
```
- 挂载 volume 存储
```bash
--mount type=volume,source=<指定存储名称>,destination=<容器内部路径>
```
- 指定网络
```bash
--network <网络名称>
```
- 挂载 secret
```bash
--secret source=<secret名称>,target=<容器内路径>
```
**常见参数说明**
| 参数 | 说明 |
| :--------------------------: | :-----------------------------------: |
| `--name` | 指定服务的名称 |
| `--replicas` | 指定服务的副本数 |
| `--constraint` | 指定服务运行的节点约束条件 |
| `--publish` | 将容器的端口映射到主机的端口 |
| `--mount` | 将主机上的目录或文件挂载到容器内 |
| `--network` | 将服务连接到指定的Docker网络 |
| `--secret` | 将指定的Docker secret文件挂载到容器内 |
| `-e` | 指定容器内的环境变量 |
| `--env-file` | 指定容器内的环境变量文件 |
| `--restart-condition` | 指定容器的重启策略 |
| `--update-delay` | 指定服务更新之间的延迟时间 |
| `--update-parallelism` | 指定服务更新时的并行数量 |
| `--update-failure-action` | 指定服务更新失败后的操作 |
| `--update-max-failure-ratio` | 指定服务更新失败的最大比率 |
| `--endpoint-mode` | 指定服务的网络端点模式 |

41
Docker/Docs/Mysql容器纳入System管理.md Normal file
View File

@@ -0,0 +1,41 @@
> 本文作者：丁辉
# Mysql容器纳入System管理
1. 创建 Systemd Service 文件
```bash
vi /usr/lib/systemd/system/mysql.service
```
内容如下
```bash
[Unit]
Description=Mysql container
Requires=docker.service
After=docker.service
[Service]
RemainAfterExit=yes
ExecStop=/usr/bin/docker stop mysql # 容器名
ExecStart=/usr/bin/docker start mysql
ExecReload=/usr/bin/docker restart mysql
Restart=on-abnormal
[Install]
WantedBy=multi-user.target
```
2. 重载配置文件
```bash
systemctl daemon-reload
```
3. 启动 Mysql
```bash
systemctl start mysql
```

57
Docker/Docs/Nginx配置文件读取变量.md Normal file
View File

@@ -0,0 +1,57 @@
> 本文作者：丁辉
>
# Nginx配置文件读取变量
## 方法一使用 Envsubst 渲染替换环境变量
1. 编辑 Dockerfile
```dockerfile
FROM nginx:alpine-slim
COPY ./nginx.conf.template /etc/nginx/conf.d/nginx.conf.template
ENV PROXY_SERVER=default
CMD /bin/sh -c "envsubst '\$PROXY_SERVER \$SERVER_NAME' < /etc/nginx/conf.d/nginx.conf.template > /etc/nginx/conf.d/default.conf && nginx -g 'daemon off;'"
```
2. 编辑 nginx.conf.template 文件
```bash
vi nginx.conf.template
```
内容如下
```nginx
server {
listen 80;
server_name ${SERVER_NAME};
location / {
proxy_pass http://${PROXY_SERVER}:3080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
}
```
3. 构建镜像
```bash
docker build -t <name:tag> .
```
4. 启动容器(指定变量)
```bash
docker run -itd -e PROXY_SERVER=127.0.0.1 -e SERVER_NAME=localhost <name:tag>
```
## 方法二
**查看此文档**
[Nginx镜像构建](https://gitee.com/offends/Kubernetes/tree/main/Docker/Dockerfile/Nginx)

43
Docker/Docs/OpeneUleros部署Docker.md Normal file
View File

@@ -0,0 +1,43 @@
> 本文作者：丁辉
# OpeneUleros部署Docker
> OpeneUleros 为 dnf 包管理工具, 所以特意记录本次安装
## 基础配置
1. 修改chrony时间同步配置
```bash
sed -i 's/pool pool.ntp.org iburst/pool ntp.aliyun.com/g' /etc/chrony.conf
```
2. 重启chrony服务, 并检查
```bash
systemctl restart chronyd && chronyc sources
```
## 安装 Docker
1. 更新镜像源缓存
```bash
dnf makecache
```
2. 安装
```bash
dnf install docker
```
3. 启动
```bash
systemctl start docker
systemctl enable docker
```

17
Docker/Docs/脚本安装Docker.md Normal file
View File

@@ -0,0 +1,17 @@
> 本文作者：丁辉
# 脚本安装Docker
- 官方源
```bash
curl -fsSL https://get.docker.com | bash
```
- 阿里源
```bash
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
```