:::info{title="INFO"}
Learning Video: [知了传课【2026 版】零基础 FastAPI+Vue3+LangChain 实战](https://www.bilibili.com/video/BV1Vr25ByEpG?)

Python Version: 3.11 [miniconda]

OS: Ubuntu 24.04.3 LTS

IDE: Visual Studio Code

Shell: zsh 5.9
:::

<center><img src="/static/img/d6aeaed08b24b86bcd18938293066867.image.webp"></center>



## Install

```bash
pip install "sqlalchemy[asyncio]" # ORM
pip install aiomysql  # 异步mysql支持
pip install cryptography  # 密码加密
```

## 创建连接

### 配置参数

```python
DB_URL = "mysql+aiomysql://<username>:<password>@<host>:<port>/<dbname>?charset=utf8mb4"
```

### 创建 Engine 对象

创建异步 Engine 对象
放置在`/models/__init__.py`中

```python
from sqlalchemy.ext.asyncio import create_async_engine

DB_URL = "..."

engine = create_async_engine(
    DB_URL,
    echo=True,    # 开发阶段输出SQL执行日志
    pool_size=10,  # 连接池大小(d=5)
    max_overflow=20,  # 允许连接池最大的连接数(d=10)
    pool_timeout=10,  # 获取连接池连接的超时时间(d=30)
    pool_recycle=3600,  # 连接回收时间(d=-1，代表永不回收)
    pool_pre_ping=True  # 连接前是否预检查(d=False)
)
```

### 创建会话工厂

```python
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.asyncio import AsyncSession

AsyncSessionFactory = sessionmaker(
    bind=engine,  # 引擎或其子类对象
    class_=AsyncSession,  # Session类的代替
    autoflush=True,  # 是否在查找以前执行flush操作(d=True)
    expire_on_commit=False,  # 是否在提交commit操作后session就过期(d=True)
)

```

## 创建模型

### 定义 Base 类

`Base`类是所有`ORM MODEL`类的父类，一个`ORM MODEL`对应数据库中的一张表，`ORM MODEL`中的一个`Column`类属性对应数据库表中的一个字段

`Base`类的生成由函数
`sqlalchemy.ext.declarative.declarative_base()`实现，也可以继承`sqlalchemy.MetaData`类，实现紫的集子类
以下为常规写法, 直接复制在**init**.py\_\_中,models 中的其他类直接`from . import BaseORM`即可

```python
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy import MetaData

class BaseORM(DeclarativeBase):
    metadata = MetaData(
        naming_convention={
            # ix: index索引
            "ix": "ix_%(column_0_label)s",
            # uq: unique唯一索引
            "uq": "uq_%(table_name)s_%(column_0_name)s",
            # ck: Check检查约束
            "ck": "ck_%(table_name)s_%(constraint_name)s",
            # fk: ForeignKey外键索引
            "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
            # pk: PrimaryKey主键约束
            "pk": "pk_%(table_name)s"
        }
    )
```

### 创建 ORM 模型

```python
from typing import Optional
from sqlalchemy import Integer, String, select
from sqlalchemy.orm import Mapped, mapped_column


class User(BaseORM):
    __tablename__ = "user"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, auto_increment=True)
    email: Mapped[str] = mapped_column(String(100), unique=True, index=True)
    username: Mapped[str] = mapped_column(String(100))
    password: Mapped[str] = mapped_column(String(200))

```

- `__tablename__`: 表名
- `primary_key`: 主键
- `unique`: 唯一索引(内容不重复)
- `index`: 索引

写法：`<cname>: Mapped[<PyType>] = mapped_column(<SQLType>, <SQLOption>)`

## 模型关系

```python
from sqlalchemy.orm import relationship
from sqlalchemy import ForeignKey
```

- 外键：指向他表的 Column

```python
user_id: Mapped[int] = mapped_column(Integer, ForeignKey("user.id"))
```

- 关系：用来跳转的属性

```python
user: Mapped["User"] = relationship(back_populates="user_extention")
```

其中`back_populates`属性，表示反向引用的属性，即与另一个模型之间相互 relationship 的属性名

`relationship`中第一个参数为关联的模型，由于前面已经定义，可省略
`user: Mapped["User"] = relationship(back_populates="user_extention")`

和

`user: Mapped["User"] = relationship("User", back_populates="user_extention")` [recommend]

含义相同

### 一对一

> Eg: 用户-扩展信息
> User <-> UserExtention

```python
class User(BaseORM):
    __tablename__ = "user"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    email: Mapped[str] = mapped_column(String(100), unique=True, index=True)
    username: Mapped[str] = mapped_column(String(100))
    password: Mapped[str] = mapped_column(String(200))

    user_extention: Mapped["UserExtention"] = relationship(back_populates="user", uselist=False)

class UserExtention(BaseORM):
    __tablename__ = "user_extention"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    university: Mapped[str] = mapped_column(String(100))
    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("user.id"), unique=True)
    user: Mapped["User"] = relationship(back_populates="user_extention")
```

- 声明`back_populates`的意义：
  - `user_extention.user` 正向引用
  - `user.user_extention` 反向引用
- `uselist=False`(d=True): 正向引用保证一对一关系
- `unique=True`: 对应到的 table 中保证一对一关系

### 一对多

> Eg: 用户-文章
> User <-> Article

```python
class User(BaseORM):
    __tablename__ = "user"

    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    email: Mapped[str] = mapped_column(String(100), unique=True, index=True)
    username: Mapped[str] = mapped_column(String(100))
    password: Mapped[str] = mapped_column(String(200))

    articles: Mapped[List["Article"]] = relationship(back_populates="author") # type: ignore

class Article(BaseORM):
    __tablename__ = "article"

    id: Mapped[int] = mapped_column(Integer, autoincrement=True, primary_key=True, index=True)
    title: Mapped[str] = mapped_column(String(100))
    content: Mapped[str] = mapped_column(String(1000))

    author_id: Mapped[int] = mapped_column(Integer, ForeignKey("user.id"))
    author: Mapped["User"] = relationship(back_populates="articles") # type: ignore
```

### 多对多

> Eg: 文章-标签
> Article <-> Tag

通过中间表实现多对多关系

```python
class Article(BaseORM):
    __tablename__ = "article"

    id: Mapped[int] = mapped_column(Integer, autoincrement=True, primary_key=True, index=True)
    title: Mapped[str] = mapped_column(String(100))
    content: Mapped[str] = mapped_column(String(1000))

    author_id: Mapped[int] = mapped_column(Integer, ForeignKey("user.id"))
    author: Mapped["User"] = relationship(back_populates="articles") # type: ignore
    tags: Mapped[List["Tag"]] = relationship(
        "Tag",
        back_populates="articles",
        # 中间表
        secondary="article_tag"
    )


class Tag(BaseORM):
    __tablename__ = "tag"

    id: Mapped[int] = mapped_column(Integer, autoincrement=True, primary_key=True, index=True)
    name: Mapped[str] = mapped_column(String(100))
    articles: Mapped[List["Article"]] = relationship(
        "Article",
        back_populates="tags",
        # 中间表
        secondary="article_tag"
    )

class ArticleTag(BaseORM):
    __tablename__ = "article_tag"

    # 两个主键
    article_id: Mapped[int] = mapped_column(Integer, ForeignKey("article.id"), primary_key=True)
    tag_id: Mapped[int] = mapped_column(Integer, ForeignKey("tag.id"), primary_key=True)

```

## 模型迁移

### 安装 alembic

```bash
pip install alembic
```

### 流程

1. 创建迁移仓库
2. 修改 alembic.ini
3. 修改 env.py
4. 生成迁移脚本
5. 执行迁移脚本

### 创建迁移仓库

> 只需要进行一次

```bash
alembic init alembic --template async
```

### 修改 alembic.ini

> 只需要进行一次

注释掉`alembic.ini`中的`sqlalchemy.url`

### 修改 env.py

> 只需要进行一次

1. `alembic/env.py`中添加内容

```python
config = context.config
# 下方开始添加内容

# ============== USER DATABASE ================

database_url = <YOUR_DB_URL>
if database_url is None:
    raise ValueError("Database URL is not set")
config.set_main_option("sqlalchemy.url", database_url)

# =============================================
```

- `<YOUR_DB_URL>`是数据库连接地址，通过你的位置 import 导入

2. 修改`alembic/env.py`中的`target_meatadata`

`target_metadata = None`修改为

```python
target_metadata = BaseORM.metadata
```

- `BaseORM`是自定义的数据库模型基类

### 生成迁移脚本

> DB、Table 变化后需要执行

执行前请确保`models/__init_.py`中 import 了所有的 py 模块

写在最后：

```python
# 导入ORM
from . import user, article
```

随后执行

```bash
alembic revision --autogenerate -m "<message>"
```

### 执行迁移脚本

> DB、Table 变化后需要执行

```bash
alembic upgrade head
```

## CRUD 操作

> 增删改查操作

### 创建 Session 对象

- 使用异步上下文管理器
- 使用依赖注入 [Recommend]
- 使用中间件

#### 使用依赖注入

```python
async def get_session() -> AsyncSession:
    session = AsyncSessionFactory()  # 这里使用的是工厂
    try:
        yield session
    finally:
        await session.close()

@app.get("/article/add")
async def add_article(
    req: UserCreateReq,
    # 这里使用的是Session类
    session: AsyncSession = Depends(get_session)
):
    async with session.begin():
        user = User(
            username=req.username,
            email=req.email,
            password=req.password
        )
        session.add(user)
    return user

```

这里可以创建一个 schemas 模块，用于定义请求参数和响应参数
可以指定 POST 回给前端的数据类

```python
class UserSchemaOut(BaseModel):
    # 返回给前端创建成功的信息
    id: int
    username: str
    email: str

@app.post("/user/add", response_model=UserSchemaOut)
async def add_user(
    user: UserCreateReq,
    session: AsyncSession = Depends(get_session)
):
    async with session.begin():
        user = User(
            username=req.username,
            email=req.email,
            password=req.password
        )
        session.add(user)
    return user

```

### 增删改查

#### 新增数据

```python
@app.post(...)
async def add_data(...):
    async with session.begin():
        data = ...
        session.add(data)
    return data
```

#### 删除数据

```python
from sqlalchemy import delete as DELETE
```

```python
@app.delete("/XXX/delete/{XXX_id}")
async def add_data():
    async with session.begin():
        await session.execute(
            DELETE(<TableORM>).where(<Condition>)
        )
    return {"message": "Delete Success"}
```

#### 查询数据

##### 查找一条数据

```python
from sqlalchemy import select as SELECT
```

```python
@app.get("/user/delete/{user_id}", response_model=UserSchemaOut)
async def add_data(
    user_id: int,
    session: As = Depends(get_session)
):
    async with session.begin():
        query = await session.execute(
            SELECT(
                User.id, User.email, User.username
            ).where(
                User.id == user_id
            )
        )
        result = query.scalar()  # 返回一条数据
    # 可选：无数据404
    if result is None:
        raise HTTPException(status_code=404, detail="Data Not Found")
    return result
```

这里的 query 可以拆分，execute 也可以直接用后面的 scalar

```python
    async with session.begin():
        stmt = SELECT(
            User.id, User.email, User.username
        ).where(
            User.id == user_id
        )
        result = await session.scalar(stmt)
    return result
```

##### 查找多条数据

```python
@app.get("/user/select/qq", response_model=UserListSchemaOut)
async def get_user(
    session: AsyncSession = Depends(get_session)
):
    async with session.begin():
        stmt = SELECT(User).where(
            User.email.contains("qq.com")
        )
        users = await session.scalars(stmt)
        return users
```

#### 修改数据

```python
from sqlalchemy import update as UPDATE
```


##### 两步修改

适合于需要查找信息的场景

```python
@app.put("/user/update/{user_id}", response_model=UserSchemaOut)
async def update_user(
    user_id: int,
    session: AsyncSession = Depends(get_session)
):
    # 1.先查再改
    async with session.begin():
        user = await session.scalar(
            SELECT(User).where(User.id==user_id)
        )
        if user is None:
            raise HTTPException(status_code=404, detail=f"User_{user_id} not found")
        user.username = user.username+"-[BAN]"
    return user
```


##### 直接修改

适合于不需要查找信息且没有返回信息的场景

```python
@app.put("/user/update/{user_id}")
async def update_user(
    user_id: int,
    session: AsyncSession = Depends(get_session)
):
    async with session.begin():
        await session.execute(
            UPDATE(User).where(User.id==user_id).values(
                username="[BAN]"
            )
        )
        return {"message": "Update Success"}
```

FastAPI+SQLAlchemy基本操作

:::info{title="INFO"}

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
:::

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



## 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{title="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`