# Docker Learning

![image|690x363](https://linux.do/uploads/default/original/4X/b/9/1/b91cc1a19dfcc2f5ba4aa37cdf43c4cb0855842b.jpeg)

> [!NOTE]
> Note: [XLY23333](https://xly23333.xyz)
>
> Learning Video: [40分钟的Docker实战攻略，一期视频精通Docker By:技术爬爬虾](https://www.bilibili.com/video/BV1THKyzBER6/)
>
> 参考Github: [docker_installer by:技术爬爬虾](https://github.com/tech-shrimp/docker_installer)
>
> OS: Ubuntu 24.04.3 LTS (Noble Numbat) x86_64



## Install

### Linux

运行下面两条命令

```bash
# 注意先进个文件夹再执行，shell脚本不乱扔
curl -fsSL https://get.docker.com -o install-docker.sh

sudo sh install-docker.sh
```

> [!TIP]
> 这里如果报错,尝试切换其他节点进行重试，并打开TUN模式
>
> 如果curl报错，请先安装
>
> ```bash
> sudo apt update
> sudo apt install curl wget git vim  # 基本的都给写上了
> ```

### WSL

首先确保安装了WSL2

直接在https://www.docker.com上Download Docker Desktop

执行下面命令制定位置安装Docker

```powershell
start /w "" "Docker Desktop Installer.exe" install --installation-dir=<YourDir>
```
> [!WARNING]
> 在Ubuntu等Linux系统中，同样可以下载Docker Desktop,但是他将会创建另一个完全独立于docker default的引擎，会导致使用docker default管理的所有images和容器全都不可见
>
> 如果需要可视化管理推荐安装`Portainer`
> ```bash
> docker run -d \
>  --name portainer \
>  -p 9101:9000 \
>  -p 9102:9443 \
>  --restart=always \
>  -v /var/run/docker.sock:/var/run/docker.sock \
>  -v portainer_data:/data \
>  portainer/portainer-ce
>```

## Docker 下载镜像

> 即使用docker下载docker镜像

### 命令介绍

标准命令: `docker pull <仓库地址>/<作者名>/<镜像名>:<版本号>`

当属于官方镜像且获取最新版的时候：

`docker pull docker.io/library/nginx:latest`->`docker pull nginx`

docker官方仓库网站: https://hub.docker.com

额外参数:  `docker pull --platform=XXXXX <>/<>/<>:<>` 用于下载指定平台架构的docker镜像

### NGINX下载测试

执行下面命令下载Nginx的Docker官方镜像

```bash
sudo docker pull nginx
```

如果无法连接请参考文首爬爬虾的Github页面添加镜像站

### 其他相关命令

1. 查看所有下载过的Docker镜像

   ```bash
   sudo docker images
   ```

2. 删除指定镜像

   ```bash
   sudo docker rmi <ImageName>
   ```

## Run Image

### 创建并运行容器

```bash
sudo docker run -d \
    -p <宿主机端口>:<容器端口> \
	-v <宿主机目录>:<容器目录> \
	--name <容器名称>  \
	-e <ENV1> \
	-e <ENV2> \
	-it \
	--rm \
	--restart <Option> \
	--network <NName> \
<镜像名称>[:标签]
```

- `-d`(可选): 指的是detached mode, 表示让容器在后台执行
- `-p <Out>:<In>` : 端口映射，将容器端口映射到宿主机端口端口
- `-v <Out>:<In>`(可选): 挂载卷到宿主机指定位置/指定挂载卷名，用于数据持久化
- `--name <Name>`(可选): 设置指定的容器名称 
- `-e <ENV>`(可选): 在启动时传入环境变量，具体每个镜像所需变量参考[hub](https://hub.docker.com)
- `-it`(可选): 启动时终端进入镜像
- `--rm`(可选): 当容器stop后自动删除，一般`-it --rm`一起使用用于调试容器
- `--restart <Option>` (可选): 确定容器停止后的重启模式
  - `--restart always`: 无论什么情况都立即重启
  - `--restart unless-stopped`: 除了手动停止的都立即重启
- `--network <NName>`(可选): 指定镜像的子网

### 查看容器

```bash
sudo docker ps  # 当前正在运行的
sudo docker ps -a  # 所有的容器
```

输出类似

```text
xly233@XLY-U ~ » sudo docker ps        
CONTAINER ID   IMAGE     COMMAND                   CREATED          STATUS          PORTS     NAMES
d1233033b512   nginx     "/docker-entrypoint.…"   20 seconds ago   Up 20 seconds   80/tcp    romantic_maxwell
```

### 两种挂载卷的方式

1. 如上文中直接在命令中使用`-v`挂载，注意创建时宿主机内容会覆盖容器中对应的目录

2. 先创建挂载卷再直接使用，这里会先从容器中同步内容，避免了数据覆盖

   首先使用命令创建挂载卷

   ```bash
   sudo docker volume create <VName>
   ```

   随后直接使用卷的名字

   ```bash
   sudo docker run -d -p <>:<> -v <VName>:<In>
   ```

   并且可以使用如下命令查看创建的挂载卷所存储的位置和基本信息

   ```bash
   sudo docker volume ls  # 查看所有挂载卷
   sudo docker volume inspect <VName>  # 查看挂载卷详细信息
   ```

   使用rm命令可以删除卷

   ```bash
   sudo docker volume rm <VName>  # 删除指定卷
   sudo docker volume prune -a  # 删除所有没有任何容器在使用的卷
   ```

### 启动和停止容器

在run过一次之后直接使用start和stop启停容器

```bash
docker start <CID/CName>
docker stop <CID/CName>
```

当使用run后，run命令的参数会被记录，启动操作不需要添加额外的参数

如果忘记了run的参数可以使用`sudo docker inspect <CID/CName>`查看容器的详细信息

### 仅创建

使用Create命令创建容器，后续还是需要start

```bash
sudo docker create ....  # 后参数与run相同
```

### 追踪查看输出日志

```bash
sudo docker logs <CID/CName> -f
```

### 在容器中执行命令

直接在容器中执行命令

```bash
sudo docker exec <CID/CName> <CMD>
```

进入容器的交互式命令行环境

```bash
sudo docker exec -it <CID/CName> bash
```

### 实操命令

```bash
mkdir -p website/html

sudo docker run -d -p 80:80 -v ./website/html:/usr/share/nginx/html --name my_nginx nginx

sudo docker ps
```

成功启动后进入宿主机./website/html下添加一个index.html

```bash
cd website/html
vim index.html
```

粘贴下面的例子

```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>Hello World</title>
<style>
    body {
        margin: 0;
        height: 100vh;
        display: flex;
        align-items: center;
        justify-content: center;
        font-family: 'Segoe UI', sans-serif;
        background: linear-gradient(135deg, #89f7fe, #66a6ff);
    }
    h1 {
        color: white;
        font-size: 60px;
        text-shadow: 2px 2px 8px rgba(0,0,0,0.3);
        animation: fadeIn 2s ease-in-out, glow 1.5s infinite alternate;
    }
    @keyframes fadeIn {
        from { opacity: 0; transform: scale(0.5); }
        to { opacity: 1; transform: scale(1); }
    }
    @keyframes glow {
        from { text-shadow: 2px 2px 8px rgba(255,255,255,0.3); }
        to { text-shadow: 2px 2px 20px rgba(255,255,255,0.9); }
    }
</style>
</head>
<body>
    <h1>Hello World ✨</h1>
</body>
</html>
```

在浏览器中访问:http://localhost:80查看

清理容器

```bash
sudo docker ps
sudo docker rm -f <YourContainerID/YourContainerName>
```

- 这里由于容器正在运行所以使用`-f`，也可以先试用`sudo docker stop <YourContainerID/YourContainerName> `停止容器再rm

创建挂载卷并挂载

```bash
sudo docker volume create my_ng
sudo docker volume ls
sudo docker run -d -p 80:80 -v my_ng:/usr/share/nginx/html --name my_nginx nginx 
sudo docker ps
```

进入root权限并尝试在宿主机的挂载卷中添加新的HTML

```bash
su -
# 进入ROOT 如果没有用过先使用 sudo passwd设置ROOT密码
cd /var/lib/docker/volumes/my_ng/_data
mkdir hw
cd hw
vim index.html
# 仍然使用上面的示例HTML
```

在浏览器中访问:http://localhost:80查看，并在http://localhost:80/hw查看添加的页

## Dockerfile

> 构建镜像所需要的图纸文件

以一个FastAPI项目为例

FastAPI-demo
		├── Dockerfile
		├── main.py
		└── requirements.txt

main.py

```python
from fastapi import FastAPI
import uvicorn


app = FastAPI()

@app.get('/')
def root():
    return {'message': 'Hello World'}

if __name__ == '__main__':
    uvicorn.run("main:app", host='0.0.0.0', port=8000, reload=True)
```

requirements.txt

```python
fastapi
uvicorn
pydantic
```

Dockerfile

```dockerfile
# 选择基础镜像
FROM python:3.13-slim

# 切换到镜像内的目录作为工作目录
WORKDIR /app

# 拷贝内容 .当前目录 .镜像内目录
COPY . .

# 安装依赖(RUN 指在镜像内执行)
RUN pip install -r requirements.txt

# 暴露端口(仅声明，以-p参数为准)
EXPOSE 8000

# 容器运行时的默认启动命令(List来写，最好不要有空格)
# 一个Dockerfile只能有一个CMD
CMD ["python3", "main.py"]
# 也可以使用ENTRYPOINT, 优先级更高, 不容易被覆盖
# ENTRYPOINT [ "python3", "main.py" ]
```

### 建立镜像

使用如下命令建立镜像

```bash
sudo docker build -t <IMGName>:<Version> <DIR>
```
- `IMGName`为镜像的名称
- `<Version>`为版本号，可以省略

这里的FastAPI例子可以使用`sudo docker build -t fastapi_demo:v1 .` 

随后在localhost:8000即可看到hello world

### 将镜像推送到dockerhub

先在浏览器完成登录

然后终端输入`docker login`, 将给出的验证码复制到给出的URL

重新build一个含有自己用户名的Image(上传到docker hub必须)

:warning: 注意！这里的用户名会自动转成小写，请全部使用小写

```bash
sudo docker build -t <UserName>/fastapi_demo:v1 .
```

然后使用命令push

```bash
sudo docker push <UserName>/<ImgName>:<Version>
```

即可在docker hub上搜索`<UserName>/<ImgName>`来找到上传的Image

## 使用build+tag+push方法管理版本

首先标准build

```bash
sudo docker build -t <CName>:build .
```

然后添加tag

```bash
sudo docker tag fastapi_demo:build <UserName>/<CName>:<Version>
sudo docker tag fastapi_demo:build <UserName>/<CName>:latest
```

随后依次push

```bash
sudo docker login
sudo docker push <UserName>/<CName>:<Version>
sudo docker push <UserName>/<CName>:latest
```

这样可以更加灵活的进行版本管理

## Docker网络

>创建子网，并制定容器到子网，方便容器间直接使用容器名通信

### 创建子网

```bash
sudo docker network create <NName>
```

并在run时加入参数`--netword <NName>`

### 实操命令

创建一个子网

```bash
sudo docker network create n1
```

使用刚才的命令，建立FastAPI项目和

```bash
sudo docker run --network n1 -d --name ftest fastapi_demo
# 使用sleep indinity保证Debian容器在后台持续运行
sudo docker run --network n1 -d --name d1 debian sleep infinity 
```

进入debian容器并尝试直接使用容器名进行通信请求

```bash
sudo docker exec -it d1 bash
```

```bash
apt update
apt install vim wget curl
curl ftest:8000
```

可以看到返回的GET结果

```text
{"message":"Hello World"}
```

## Docker Compose

> 容器编排技术，使用docker-compose.yaml文件进行多容器的协同建立

### 基础命令

首先下面命令中的`-f <file.yaml>`中如果yaml文件名为`docker-compose.yaml`或`compose.yaml`则不需要写，如果要制定compose则加入

**创建+启动** 服务

```bash
sudo docker compose -f <file.yaml> up -d
```

**停止+删除** 资源，:warning:这里会删除容器:warning:

```bash
sudo docker compose -f <file.yaml> down
sudo docker compose -f <file.yaml> down -v  # 同时删除volume
sudo docker compose -f <file.yaml> down --rmi all  # 同时删除相关镜像
```

**启动** 已经存在的compose

```bash
sudo docker compose -f <file.yaml> start
```

**停止** 已经启动的compose

```bash
sudo docker compose -f <file.yaml> stop
```

### 例中学

fastapi-redis-demo/

​	├── docker-compose.yml
​	└── app/
   		   ├── main.py
   		   ├── requirements.txt
   		   └── Dockerfile

main.py

```python
from fastapi import FastAPI
import redis
import os
import time

REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))

r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)

app = FastAPI()

@app.get("/")
def read_root():
    timestamp = int(time.time())  # 当前时间戳（秒）

    r.set("msg", f"hello from redis | ts={timestamp}")

    return {
        "msg": r.get("msg"),
        "timestamp": timestamp,
        "redis_host": REDIS_HOST
    }
```

requirements.txt

```python
fastapi
uvicorn
redis
```

Dockerfile

```dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY main.py .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "6001"]
```

docker-compose.yaml

```yaml
version: "3.9"   # Docker Compose 文件版本，3.9 适用于较新的 Docker

services:
  # ================= Redis 服务 =================
  redis:
    image: redis:7              # 使用官方 Redis 7 镜像
    container_name: redis-db    # 指定容器名称（docker run --name）
    
    # ports:
      # - "6379:6379"             # 这里不需要暴露接口
    
    volumes:
      - redis_data:/data        # 数据卷挂载，用于持久化 Redis 数据
    
    healthcheck:                # 健康检查配置
      test: ["CMD", "redis-cli", "ping"]  # 检查命令
      interval: 5s              # 每 5 秒检查一次
      timeout: 3s               # 超时时间 3 秒
      retries: 5                # 失败 5 次后认为服务不健康

  # ================= FastAPI 服务 =================
  fastapi:
    image: fastapi-redis          # 使用已经 build 好的 FastAPI 镜像
    container_name: fastapi-app   # 指定容器名称
    
    ports:
      - "6001:6001"               # 暴露 FastAPI 服务端口
    
    environment:
      REDIS_HOST: redis           # Redis 主机名（Docker 内部 DNS）
      REDIS_PORT: 6379            # Redis 端口
    
    depends_on:
      redis:
        condition: service_healthy # 等 Redis 健康后再启动 FastAPI

# ================= 数据卷定义 =================
volumes:
  redis_data:                     # 命名 volume，用于 Redis 数据持久化

```

build fastapi-redis-app

```bash
sudo docker build -t fastapi-redis ./app
sudo docker tag fastapi-redis <UserName>/fastapi-redis:latest
sudo docker login  # 登录 docker
sudo docker push xly23333/fastapi-redis  # push到docker hub
```

使用docker-compose.yaml启动

```bash
sudo docker compose up
```

进入http://localhost:6001即可收到正常调用内网redis的服务

```json
{
  "msg": "hello from redis | ts=1769290454",
  "timestamp": 1769290454,
  "redis_host": "redis"
}
```

## Others

### Linux Alias

```bash
alias docker="sudo docker"
alias dk="sudo docker"
```

### 总结

1. Pull `docker pull [ImgURL/Auth/]ImgName[:Version]`

2. Create & Run

    ```bash
    docker run -d \
        -p <OutPort>:<InPort> \
        -v <OutDir/VName>:<InDIR> \
        --name <CName>  \
        -e <ENV1> \
        -e <ENV2> \
        -it \
        --rm \
        --restart <Option> \
        --network <NName> \
    <镜像名称>[:标签]
    ```

    - `-d`(可选): 指的是detached mode, 表示让容器在后台执行
    - `-p <OutPort>:<InPort>` : 端口映射，将容器端口映射到宿主机端口端口
    - `-v <OutDir/VName>:<InDIR>`(可选): 挂载卷到宿主机指定位置/指定挂载卷名，用于数据持久化
    - `--name <Name>`(可选): 设置指定的容器名称 
    - `-e <ENV>`(可选): 在启动时传入环境变量，具体每个镜像所需变量参考[hub](https://hub.docker.com)
    - `-it`(可选): 启动时终端进入镜像
    - `--rm`(可选): 当容器stop后自动删除，一般`-it --rm`一起使用用于调试容器
    - `--restart <Option>` (可选): 确定容器停止后的重启模式
        - `--restart always`: 无论什么情况都立即重启
        - `--restart unless-stopped`: 除了手动停止的都立即重启
    - `--network <NName>`(可选): 指定镜像的子网

3. Volume

    1. Create `docker volume create <VName>`
    2. List `docker volume ls`
    3. Enter Dir `cd /var/lib/docker/volumes/<VName>/_data`
    4. Del `docker volume rm <VName>`
    5. Del no use `docker volume prune -a`

4. Start & Stop
    1. start `docker start <CID/CName>`
    2. stop `docker stop <CID/CName>`
5. Only Create `docker create ...  #  同run`
6. Logs `docker logs <CID/CName> [-f]`
7. Exec
    1. stand `sudo docker exec <CID/CName> <CMD>`
    2. bash `sudo docker exec -it <CID/CName> bash`

8. Build `docker build -t <ImgName>[:Version] <DIR>`
9. Tag `docker tag [Auth/]ImgName[:Version] [ImgURL/Auth/]ImgName[:Version]  ` 
    1. `docker tag fastapi_demo:build <UserName>/<CName>:<Version>`
    2. `docker tag fastapi_demo:build <UserName>/<CName>:latest`

10. Push
    1. login: `docker login`
    2. push: `docker push <UserName>/<ImgName>:<Version>`

11. Network
    1. create `docker network create <NName>`
    2. use `docker run .... --network <NName> <ImgName>`

12. Compose
    1. create & start `docker compose -f <file.yaml> up -d`
    2. stop & del `docker compose -f <file.yaml> down [-v --rmi all]`
        1. `-v` del volume
        2. `--rmi all` remove images
    3. start `docker compose -f <file.yaml> start`
    4. stop `docker compose -f <file.yaml> stop`

Docker基础操作