# Nginx 动态代理访问子节点网页完整流程

## 一、环境准备
1. **服务器要求**：
   - A 服务器（需安装 Nginx，且能访问 A1/A2/A3 子节点）
   - B 服务器（需能访问 A 服务器的 8080 端口）
   - 确保子节点（如 A1）的网页服务已启动（如 HTTP 80 端口）



2. **软件安装**：
   - 在 A 服务器安装 Nginx：
     ```bash
     # Ubuntu/Debian
     sudo apt update && sudo apt install nginx
     
     # CentOS
     sudo yum install epel-release && sudo yum install nginx
     ```

3. **防火墙设置**：
   - 放行 A 服务器的 8080 端口：
     ```bash
     # Ubuntu/Debian（UFW）
     sudo ufw allow 8080/tcp
     
     # CentOS（Firewalld）
     sudo firewall-cmd --add-port=8080/tcp --permanent
     sudo firewall-cmd --reload
     ```


## 二、A 服务器 Nginx 配置

### 1. 打开配置文件
```bash
sudo nano /etc/nginx/nginx.conf
```

### 2. 添加代理配置
在 `http` 块中添加以下内容：
```nginx
http {
    # 其他原有配置...

    server {
        listen 8080;  # 监听端口，B 服务器将访问此端口
        server_name _;  # 允许所有域名访问

        location /proxy {
            # 从 URL 参数获取子节点 IP 和端口
            set $target_ip $arg_ip;
            set $target_port $arg_port;

            # 验证参数是否存在
            if ($target_ip = "") {
                return 400 "Error: Please provide 'ip' parameter";
            }

            if ($target_port = "") {
                set $target_port 80;  # 默认端口为 80
            }

            # 反向代理到目标子节点
            proxy_pass http://$target_ip:$target_port;

            # 保留原始请求头
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}
```

### 3. 保存并重启 Nginx
```bash
sudo systemctl restart nginx
```


## 三、B 服务器访问方法

### 1. 直接通过浏览器访问
在 B 服务器的浏览器中输入：
```
http://A服务器IP:8080/proxy?ip=子节点IP&port=子节点端口
```
- 示例：访问 A1 的 80 端口网页：
  ```
  http://192.168.1.100:8080/proxy?ip=192.168.1.101&port=80
  ```

### 2. 使用 curl 命令验证
```bash
curl "http://A服务器IP:8080/proxy?ip=192.168.1.101&port=80"
```


## 四、动态 IP 处理方案

### 1. 使用动态 DNS（DDNS）
如果子节点（如 A1）的 IP 经常变化，建议搭配 DDNS 服务：
1. 为子节点申请一个固定域名（如 `a1.mydomain.com`）
2. 在子节点安装 DDNS 客户端，自动更新 IP 到域名
3. 修改 Nginx 配置中的 `$target_ip` 为域名：
   ```nginx
   proxy_pass http://$arg_ip:$target_port;  # 直接使用 URL 中的域名参数
   ```

### 2. 动态参数传递
每次访问时直接传递最新 IP：
```
http://A服务器IP:8080/proxy?ip=192.168.1.102&port=80  # 假设 A1 的新 IP 是 192.168.1.102
```


## 五、注意事项

1. **HTTPS 支持**：
   - 如果子节点使用 HTTPS（443 端口），修改 Nginx 配置为：
     ```nginx
     proxy_pass https://$target_ip:$target_port;
     ```
   - 需在 A 服务器安装 SSL 证书（如 Let's Encrypt）

2. **端口冲突**：
   - 确保 A 服务器的 8080 端口未被其他服务占用

3. **安全加固**：
   - 限制仅允许 B 服务器访问 A 的 8080 端口：
     ```nginx
     allow 192.168.1.200;  # B 服务器的 IP
     deny all;
     ```


## 六、常见问题处理

1. **404 错误**：
   - 检查 Nginx 配置是否正确，特别是 `location /proxy` 的路径

2. **502 Bad Gateway**：
   - 确认子节点 IP 和端口是否可达
   - 检查子节点的网页服务是否正常运行

3. **跨域问题**：
   - 在 Nginx 配置中添加跨域头：
     ```nginx
     add_header Access-Control-Allow-Origin *;
     ```


如果需要 B 服务器代理 B1/B2/B3，只需在 B 服务器重复上述配置，A 服务器通过 B 的 8080 端口访问即可。

Nginx 动态代理访问子节点网页完整流程

# 📱 使用 Kivy 将 Python 应用打包成 Android APK 完整指南

## 1 环境准备与安装

### 1.1 系统要求

- **推荐操作系统**：Ubuntu 20.04 或更高版本（在 Linux 环境下最为稳定）
- **Windows 用户**：建议使用 WSL（Windows Subsystem for Linux）或虚拟机
- **Python 版本**：Python 3.8 或更高版本



### 1.2 安装必要依赖

在 Ubuntu/Debian 系统上，打开终端并运行以下命令安装所有必需的依赖：

```bash
# 更新系统包管理器
sudo apt update
sudo apt upgrade -y

# 安装编译工具和依赖
sudo apt install -y python3-pip python3-setuptools python3-virtualenv git zip unzip
sudo apt install -y build-essential libffi-dev zlib1g-dev libncursesw5-dev
sudo apt install -y libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev
sudo apt install -y libssl-dev openssl cython libxml2-dev libxslt1-dev

# 安装图形和 OpenGL 相关依赖
sudo apt install -y libgl1-mesa-dev libgles2-mesa-dev

# 安装 Java 开发工具包
sudo apt install -y openjdk-11-jdk
```

### 1.3 安装 Kivy 和 Buildozer

```bash
# 安装 Kivy
pip3 install kivy

# 安装 Buildozer
pip3 install buildozer
```

## 2 创建 Kivy 应用

### 2.1 简单的示例应用

创建一个项目目录，并在其中创建 `main.py` 文件：

```python
from kivy.app import App
from kivy.uix.button import Button

class MyApp(App):
    def build(self):
        return Button(text='Hello, Kivy!')

if __name__ == '__main__':
    MyApp().run()
```

### 2.2 测试应用

在继续之前，先测试你的应用是否能正常运行：

```bash
python3 main.py
```

如果一切正常，你应该能看到一个显示 "Hello, Kivy!" 按钮的窗口。

## 3 配置 Buildozer

### 3.1 初始化 Buildozer

在项目目录中运行以下命令：

```bash
buildozer init
```

这会在当前目录生成一个 `buildozer.spec` 文件，其中包含了所有的构建配置。

### 3.2 关键配置说明

以下表格列出了 `buildozer.spec` 文件中需要关注和可能修改的重要配置项：

| 配置项 | 描述 | 示例值 |
|--------|------|--------|
| `title` | 应用名称 | `My Kivy App` |
| `package.name` | 应用包名（全部小写） | `myapp` |
| `package.domain` | 应用域名（组织反域名） | `org.example` |
| `source.dir` | 源代码目录 | `.` |
| `source.include_exts` | 包含的文件类型 | `py,png,jpg,kv,atlas,txt` |
| `version` | 应用版本号 | `0.1` |
| `requirements` | Python 依赖 | `python3,kivy,cython` |
| `android.permissions` | Android 权限 | `INTERNET, WRITE_EXTERNAL_STORAGE` |
| `presplash.filename` | 启动画面图片 | `%(source.dir)s/data/presplash.png` |
| `icon.filename` | 应用图标 | `%(source.dir)s/data/icon.png` |

### 3.3 常用配置修改

根据你的需求修改 `buildozer.spec` 文件：

```ini
[app]
title = My Kivy App
package.name = myapp
package.domain = org.example
source.dir = .
source.include_exts = py,png,jpg,kv,atlas,txt
version = 0.1
requirements = python3,kivy,cython

[buildozer]
log_level = 2

[app::android]
permissions = INTERNET

[app::android:meta_data]
```

如果你需要访问网络、存储等功能，记得在 `android.permissions` 中添加相应权限。

## 4 打包 APK

### 4.1 首次构建

在项目目录中运行以下命令开始构建：

```bash
buildozer -v android debug
```

**注意**：
- 第一次构建需要下载 Android SDK、NDK 和其他依赖，可能需要 **30-60 分钟**，具体取决于你的网络速度
- 确保网络连接稳定，因为需要从 GitHub 和其他源下载大量文件

### 4.2 网络问题解决方案

如果在国内或遇到网络问题，可以尝试以下方法：

```bash
# 设置 HTTP/HTTPS 代理（根据你的实际情况修改）
export http_proxy=http://127.0.0.1:38457
export https_proxy=http://127.0.0.1:38457

# 或者使用 FastGithub 等加速工具
```

### 4.3 构建类型

- **调试版本**：`buildozer -v android debug` - 包含调试信息，未签名
- **发布版本**：`buildozer -v android release` - 需要签名，用于上架应用商店

## 5 定位和获取 APK 文件

构建成功后，APK 文件会生成在 `bin` 目录中：

- **调试 APK**：`bin/MyApp-0.1-debug.apk`
- **发布 APK**：`bin/MyApp-0.1-release.apk`

## 6 安装和测试

### 6.1 安装到安卓设备

**方法一：使用 ADB 安装**
```bash
adb install bin/MyApp-0.1-debug.apk
```

**方法二：手动安装**
1. 将 APK 文件传输到安卓手机
2. 在手机上启用"未知来源"安装权限
3. 使用文件管理器找到 APK 文件并安装

### 6.2 查看日志

如果应用运行异常，可以通过以下命令查看日志：
```bash
adb logcat | grep python
```

## 7 常见问题与解决方案

以下表格汇总了打包过程中可能遇到的常见问题及解决方法：

| 问题现象 | 可能原因 | 解决方案 |
|---------|----------|----------|
| SSL/SSH 错误 | Ubuntu 版本过旧 | 使用 Ubuntu 18.04 或更高版本 |
| 下载过程中失败 | 网络不稳定 | 设置代理或使用加速器 |
| 文件已存在错误 | 上次下载不完整 | 删除 `.buildozer` 文件夹重新下载 |
| 提取压缩包失败 | 下载文件损坏 | 手动下载并替换对应文件 |
| 应用启动崩溃 | 缺少依赖库 | 检查 `requirements` 是否包含所有依赖 |
| 预加载画面卡住 | 资源文件问题 | 检查图标和启动画面文件格式 |

### 7.1 清理构建缓存

如果遇到构建问题，可以尝试清理缓存：

```bash
# 清理构建文件
buildozer android clean

# 完全清理（包括下载的依赖）
buildozer distclean
```

### 7.2 添加缺失的依赖

如果应用使用了其他 Python 库，确保在 `buildozer.spec` 的 `requirements` 中添加它们：

```ini
requirements = python3,kivy,cython,requests,pillow
```

## 8 高级配置

### 8.1 应用签名（发布版本）

要对发布版 APK 进行签名，首先创建密钥库：

```bash
keytool -genkey -v -keystore my-release-key.keystore -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias
```

然后在 `buildozer.spec` 中配置：

```ini
[app]
# 发布构建配置
buildozer.release_keystore = /path/to/my-release-key.keystore
buildozer.release_keystore_password = YOUR_PASSWORD
buildozer.release_key_alias = my-alias
buildozer.release_key_password = YOUR_PASSWORD
```

### 8.2 优化 APK 大小

```ini
[app]
# 只指定需要的架构
android.arch = armeabi-v7a

# 排除不必要的文件
source.exclude_exts = .pyc,.git,.gitignore
```

## 总结

通过以上步骤，应该能够成功将 Kivy 应用打包为 Android APK。关键要点：

1. **环境准备**：使用推荐的 Ubuntu 版本可以避免多数问题
2. **网络稳定**：首次构建需要下载大量依赖，稳定的网络至关重要
3. **耐心调试**：如果遇到问题，查看终端输出日志，通常会有详细的错误信息

如果在具体步骤中遇到问题，可以查阅 [Buildozer 官方文档](https://buildozer.readthedocs.io/) 或 Kivy 社区获取更多帮助。

使用 Kivy 将 Python 应用打包成 Android APK 完整指南

## 1. 布局基础属性

### 1.1 `direction` - 布局方向
**作用**：定义子元素的排列方向



**可选值**：
- `ROW`：水平排列（默认）
- `COLUMN`：垂直排列

```python
import toga
from toga.style import Pack
from toga.style.pack import ROW, COLUMN

def build(app):
    # 水平排列的容器
    horizontal_box = toga.Box(style=Pack(direction=ROW, padding=10))
    btn1 = toga.Button("按钮1", style=Pack(padding=5))
    btn2 = toga.Button("按钮2", style=Pack(padding=5))
    horizontal_box.add(btn1)
    horizontal_box.add(btn2)
    
    # 垂直排列的容器  
    vertical_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    btn3 = toga.Button("按钮3", style=Pack(padding=5))
    btn4 = toga.Button("按钮4", style=Pack(padding=5))
    vertical_box.add(btn3)
    vertical_box.add(btn4)
    
    # 主容器
    main_box = toga.Box(style=Pack(direction=COLUMN))
    main_box.add(horizontal_box)
    main_box.add(vertical_box)
    
    return main_box
```

### 1.2 `display` - 显示方式
**作用**：控制元素是否显示

**可选值**：
- `PACK`：正常显示（默认）
- `NONE`：隐藏元素（不占空间）

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    visible_btn = toga.Button("可见按钮", style=Pack(padding=5))
    hidden_btn = toga.Button("隐藏按钮", style=Pack(display=None, padding=5))
    
    box.add(visible_btn)
    box.add(hidden_btn)  # 这个按钮不会显示
    
    return box
```

### 1.3 `visibility` - 可见性
**作用**：控制元素可见性

**可选值**：
- `VISIBLE`：可见（默认）
- `HIDDEN`：隐藏（但仍占空间）

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    visible_btn = toga.Button("可见按钮", style=Pack(padding=5))
    # 隐藏但仍占空间的按钮
    hidden_btn = toga.Button("隐藏但占位", style=Pack(visibility='hidden', padding=5))
    another_btn = toga.Button("另一个按钮", style=Pack(padding=5))
    
    box.add(visible_btn)
    box.add(hidden_btn)  # 看不到但会占位置
    box.add(another_btn)
    
    return box
```

## 2. 对齐与分布属性

### 2.1 `align_items` - 交叉轴对齐
**作用**：在交叉轴上对齐子元素

**可选值**：
- `START`：起始对齐
- `CENTER`：居中对齐  
- `END`：末端对齐

```python
from toga.style.pack import START, CENTER, END

def build(app):
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 起始对齐（顶部/左侧）
    start_box = toga.Box(
        style=Pack(direction=ROW, align_items=START, height=100, background_color='lightgray', padding=5)
    )
    start_box.add(toga.Button("Start", style=Pack(width=80, height=30)))
    
    # 居中对齐
    center_box = toga.Box(
        style=Pack(direction=ROW, align_items=CENTER, height=100, background_color='lightblue', padding=5)
    )
    center_box.add(toga.Button("Center", style=Pack(width=80, height=30)))
    
    # 末端对齐（底部/右侧）
    end_box = toga.Box(
        style=Pack(direction=ROW, align_items=END, height=100, background_color='lightgreen', padding=5)
    )
    end_box.add(toga.Button("End", style=Pack(width=80, height=30)))
    
    main_box.add(toga.Label("align_items 示例:", style=Pack(padding_bottom=5)))
    main_box.add(start_box)
    main_box.add(center_box)
    main_box.add(end_box)
    
    return main_box
```

### 2.2 `justify_content` - 主轴分布
**作用**：在主轴上分布子元素

**可选值**：
- `START`：起始分布（默认）
- `CENTER`：居中分布
- `END`：末端分布

```python
def build(app):
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 起始分布
    start_box = toga.Box(
        style=Pack(direction=ROW, justify_content=START, width=300, background_color='lightgray', padding=5)
    )
    for i in range(3):
        start_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    # 居中分布
    center_box = toga.Box(
        style=Pack(direction=ROW, justify_content=CENTER, width=300, background_color='lightblue', padding=5)
    )
    for i in range(3):
        center_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    # 末端分布
    end_box = toga.Box(
        style=Pack(direction=ROW, justify_content=END, width=300, background_color='lightgreen', padding=5)
    )
    for i in range(3):
        end_box.add(toga.Button(f"Btn{i}", style=Pack(width=60, margin=2)))
    
    main_box.add(toga.Label("justify_content 示例:", style=Pack(padding_bottom=5)))
    main_box.add(start_box)
    main_box.add(center_box)
    main_box.add(end_box)
    
    return main_box
```

## 3. 尺寸与弹性属性

### 3.1 `width` / `height` - 固定尺寸
**作用**：设置元素的固定宽度和高度

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 固定宽度的按钮
    fixed_btn = toga.Button(
        "固定宽度200", 
        style=Pack(width=200, height=40, background_color='lightblue', padding=5)
    )
    
    # 固定高度的按钮
    tall_btn = toga.Button(
        "固定高度80", 
        style=Pack(width=120, height=80, background_color='lightgreen', padding=5)
    )
    
    box.add(fixed_btn)
    box.add(tall_btn)
    
    return box
```

### 3.2 `flex` - 弹性布局
**作用**：在可用空间中按比例分配空间

**注意**：只在未设置明确宽高时生效

```python
def build(app):
    box = toga.Box(style=Pack(direction=ROW, height=60, padding=10, background_color='gray'))
    
    # flex=1 的元素
    flex1_btn = toga.Button(
        "flex=1", 
        style=Pack(flex=1, margin=2, background_color='lightblue')
    )
    
    # flex=2 的元素（占用两倍空间）
    flex2_btn = toga.Button(
        "flex=2", 
        style=Pack(flex=2, margin=2, background_color='lightgreen')
    )
    
    # flex=1 的元素
    flex1_btn2 = toga.Button(
        "flex=1", 
        style=Pack(flex=1, margin=2, background_color='lightcoral')
    )
    
    box.add(flex1_btn)
    box.add(flex2_btn)
    box.add(flex1_btn2)
    
    return box
```

## 4. 间距属性

### 4.1 `margin` 系列 - 外边距
**作用**：设置元素的外边距

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=20, background_color='lightgray'))
    
    # 不同的外边距设置
    margins = [
        ("四周10px", {"margin": 10}),
        ("上下10px, 左右20px", {"margin": (10, 20)}),
        ("上10px, 右20px, 下30px, 左40px", {"margin": (10, 20, 30, 40)}),
        ("仅右边距50px", {"margin_right": 50}),
    ]
    
    for text, margin_style in margins:
        btn = toga.Button(
            text, 
            style=Pack(
                background_color='white', 
                padding=5,
                **margin_style
            )
        )
        box.add(btn)
    
    return box
```

## 5. 外观属性

### 5.1 `color` - 文字颜色
**作用**：设置文字颜色

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    colors = [
        ("红色文字", "red"),
        ("蓝色文字", "blue"),
        ("绿色文字", "green"),
        ("十六进制颜色", "#FF00FF"),
    ]
    
    for text, color in colors:
        label = toga.Label(
            text, 
            style=Pack(color=color, padding=5, font_size=14)
        )
        box.add(label)
    
    return box
```

### 5.2 `background_color` - 背景颜色
**作用**：设置背景颜色

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    backgrounds = [
        ("浅蓝背景", "lightblue"),
        ("浅绿背景", "lightgreen"),
        ("浅珊瑚色", "lightcoral"),
        ("黄色背景", "yellow"),
    ]
    
    for text, bg_color in backgrounds:
        btn = toga.Button(
            text, 
            style=Pack(
                background_color=bg_color, 
                padding=10, 
                margin=5,
                color='black'  # 确保文字可读
            )
        )
        box.add(btn)
    
    return box
```

## 6. 文本属性

### 6.1 `text_align` - 文本对齐
**作用**：设置文本水平对齐方式

```python
from toga.style.pack import LEFT, RIGHT, CENTER, JUSTIFY

def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10, width=300))
    
    alignments = [
        ("左对齐文本", LEFT),
        ("居中对齐文本", CENTER),
        ("右对齐文本", RIGHT),
        ("两端对齐文本", JUSTIFY),
    ]
    
    for text, alignment in alignments:
        label = toga.Label(
            text, 
            style=Pack(
                text_align=alignment,
                padding=10,
                background_color='lightgray',
                width=280,
                margin=2
            )
        )
        box.add(label)
    
    return box
```

### 6.2 `text_direction` - 文本方向
**作用**：设置文本阅读方向

```python
from toga.style.pack import LTR, RTL

def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 从左到右（默认）
    ltr_label = toga.Label(
        "从左到右文本 (LTR)", 
        style=Pack(text_direction=LTR, padding=10, background_color='lightblue')
    )
    
    # 从右到左
    rtl_label = toga.Label(
        "从右到左文本 (RTL)", 
        style=Pack(text_direction=RTL, padding=10, background_color='lightgreen')
    )
    
    box.add(ltr_label)
    box.add(rtl_label)
    
    return box
```

## 7. 字体属性

### 7.1 字体相关属性
**作用**：设置字体系列、样式、大小等

```python
def build(app):
    box = toga.Box(style=Pack(direction=COLUMN, padding=10))
    
    # 字体系列
    font_family_label = toga.Label(
        "自定义字体: Arial", 
        style=Pack(font_family='Arial', font_size=14, padding=5)
    )
    
    # 字体大小
    font_size_label = toga.Label(
        "大号字体: 20pt", 
        style=Pack(font_size=20, padding=5)
    )
    
    # 字体粗细
    font_weight_label = toga.Label(
        "粗体文字", 
        style=Pack(font_weight='bold', padding=5)
    )
    
    # 字体样式
    font_style_label = toga.Label(
        "斜体文字", 
        style=Pack(font_style='italic', padding=5)
    )
    
    # 组合使用
    combined_label = toga.Label(
        "组合样式: 粗体+斜体+大号", 
        style=Pack(
            font_weight='bold', 
            font_style='italic', 
            font_size=16,
            padding=10,
            background_color='lightyellow'
        )
    )
    
    box.add(font_family_label)
    box.add(font_size_label)
    box.add(font_weight_label)
    box.add(font_style_label)
    box.add(combined_label)
    
    return box
```

## 8. 综合示例

下面是一个结合多种属性的完整示例：

```python
import toga
from toga.style import Pack
from toga.style.pack import COLUMN, ROW, CENTER, START, END

def build(app):
    # 主容器 - 垂直布局
    main_box = toga.Box(style=Pack(direction=COLUMN, padding=20))
    
    # 标题
    title = toga.Label(
        "用户信息表单",
        style=Pack(
            text_align=CENTER,
            font_size=20,
            font_weight='bold',
            padding_bottom=20,
            color='navy'
        )
    )
    
    # 姓名行 - 水平布局
    name_box = toga.Box(style=Pack(direction=ROW, padding=10))
    name_label = toga.Label(
        "姓名:",
        style=Pack(width=80, padding_right=10, font_weight='bold')
    )
    name_input = toga.TextInput(
        style=Pack(flex=1, padding=8)
    )
    name_box.add(name_label)
    name_box.add(name_input)
    
    # 邮箱行 - 水平布局  
    email_box = toga.Box(style=Pack(direction=ROW, padding=10))
    email_label = toga.Label(
        "邮箱:",
        style=Pack(width=80, padding_right=10, font_weight='bold')
    )
    email_input = toga.TextInput(
        style=Pack(flex=1, padding=8)
    )
    email_box.add(email_label)
    email_box.add(email_input)
    
    # 按钮容器 - 水平布局，右对齐
    button_box = toga.Box(
        style=Pack(
            direction=ROW, 
            justify_content=END,
            padding_top=20
        )
    )
    
    cancel_btn = toga.Button(
        "取消",
        style=Pack(
            padding=15,
            margin_left=10,
            background_color='#e74c3c',
            color='white',
            width=100
        )
    )
    
    submit_btn = toga.Button(
        "提交",
        style=Pack(
            padding=15,
            margin_left=10,
            background_color='#3498db',
            color='white',
            width=100
        )
    )
    
    button_box.add(cancel_btn)
    button_box.add(submit_btn)
    
    # 将所有元素添加到主容器
    main_box.add(title)
    main_box.add(name_box)
    main_box.add(email_box)
    main_box.add(button_box)
    
    return main_box

def main():
    app = toga.App('综合示例', 'org.example.comprehensive', startup=build)
    return app

if __name__ == '__main__':
    main().main_loop()
```

## 重要注意事项

1. **版本兼容性**：确保使用的 Toga 版本与文档匹配
2. **属性优先级**：某些属性会相互影响，如 `flex` 只在未设置明确宽高时生效
3. **布局嵌套**：通过组合 `ROW` 和 `COLUMN` 方向可以创建复杂布局
4. **调试技巧**：给容器设置背景色可以直观看到布局边界

每个属性都可以单独使用或组合使用，通过不断实践可以掌握 Pack 布局系统的强大功能。

Toga Pack 布局系统详细解析

# MySQL EXPLAIN 全面指南

## 📊 什么是EXPLAIN？

EXPLAIN是MySQL提供的查询分析工具，用于显示MySQL如何执行SQL语句，帮助开发者优化查询性能。



## 🔍 如何查看EXPLAIN

### 基本用法
```sql
EXPLAIN SELECT * FROM table_name WHERE condition;
```

### 详细格式（MySQL 8.0+）
```sql
EXPLAIN FORMAT=JSON SELECT * FROM table_name;
-- 或
EXPLAIN ANALYZE SELECT * FROM table_name;
```

## 📋 EXPLAIN输出列详解

| 列名 | 说明 | 关键值解读 |
|------|------|------------|
| **id** | 查询标识符 | 数字越大越先执行，相同id按顺序执行 |
| **select_type** | 查询类型 | 见下方详细说明 |
| **table** | 访问的表名 | 可能是表名、别名或<derivedN> |
| **partitions** | 匹配的分区 | 显示使用的分区 |
| **type** | 访问类型 | **性能关键指标**，见下方说明 |
| **possible_keys** | 可能使用的索引 | 查询可能使用的索引列表 |
| **key** | 实际使用的索引 | 实际选择的索引 |
| **key_len** | 索引长度 | 使用的索引字节数 |
| **ref** | 索引比较的列 | 显示与索引比较的列或常量 |
| **rows** | 预估扫描行数 | 估算需要检查的行数 |
| **filtered** | 过滤百分比 | 存储引擎层过滤后剩余行的百分比 |
| **Extra** | 额外信息 | 重要优化信息，见下方说明 |

## 🎯 关键字段详细解读

### select_type（查询类型）
| 类型 | 含义 | 出现场景 |
|------|------|----------|
| SIMPLE | 简单查询 | 不包含子查询或UNION |
| PRIMARY | 最外层查询 | 包含子查询的主查询 |
| SUBQUERY | 子查询 | WHERE子句中的子查询 |
| DERIVED | 派生表 | FROM子句中的子查询 |
| UNION | UNION查询 | UNION中的第二个及以后的SELECT |
| UNION RESULT | UNION结果 | UNION的结果集 |

### type（访问类型）**性能关键**
从最优到最差排序：

| 类型 | 描述 | 性能 |
|------|------|------|
| **system** | 系统表，只有一行 | ⭐⭐⭐⭐⭐ |
| **const** | 通过主键或唯一索引查询 | ⭐⭐⭐⭐⭐ |
| **eq_ref** | 关联查询，使用唯一索引 | ⭐⭐⭐⭐⭐ |
| **ref** | 使用非唯一索引查询 | ⭐⭐⭐⭐ |
| **range** | 索引范围扫描 | ⭐⭐⭐⭐ |
| **index** | 索引全扫描 | ⭐⭐⭐ |
| **ALL** | 全表扫描 | ⭐（需要优化） |

### Extra（额外信息）
| 信息 | 含义 | 优化建议 |
|------|------|----------|
| **Using index** | 使用覆盖索引 | ✅ 良好 |
| **Using where** | 使用WHERE过滤 | ⚠️ 可能需要优化 |
| **Using temporary** | 使用临时表 | 🔴 需要优化 |
| **Using filesort** | 使用文件排序 | 🔴 需要优化 |
| **Using join buffer** | 使用连接缓冲 | ⚠️ 可能需要优化 |

## 🚨 性能问题识别

### 需要立即优化的信号
1. **type: ALL** - 全表扫描
2. **Using temporary** - 使用临时表
3. **Using filesort** - 文件排序
4. **rows** 值很大 - 扫描行数过多
5. **key: NULL** - 没有使用索引

### 示例：问题查询分析
```sql
EXPLAIN SELECT * FROM users WHERE age > 30 ORDER BY name;
```

可能的问题输出：
- `type: ALL` (全表扫描)
- `key: NULL` (未使用索引)
- `Extra: Using where; Using filesort` (WHERE过滤和文件排序)

## 🛠️ 优化建议

### 1. 添加合适索引
```sql
-- 添加单列索引
CREATE INDEX idx_age ON users(age);
CREATE INDEX idx_name ON users(name);

-- 添加复合索引
CREATE INDEX idx_age_name ON users(age, name);
```

### 2. 重写查询
```sql
-- 优化前（可能产生Using filesort）
SELECT * FROM users WHERE age > 30 ORDER BY name;

-- 优化后（使用覆盖索引）
SELECT id, name, age FROM users 
WHERE age > 30 
ORDER BY name;
```

### 3. 避免全表扫描
确保WHERE条件中的列有索引：
```sql
-- 不好的写法
SELECT * FROM users WHERE YEAR(create_time) = 2023;

-- 好的写法
SELECT * FROM users WHERE create_time >= '2023-01-01' AND create_time < '2024-01-01';
```

## 📊 EXPLAIN实战案例

### 案例1：简单查询优化
```sql
-- 优化前
EXPLAIN SELECT * FROM products WHERE price > 100;

-- 添加索引后
CREATE INDEX idx_price ON products(price);
EXPLAIN SELECT * FROM products WHERE price > 100;
```

### 案例2：关联查询优化
```sql
EXPLAIN SELECT u.name, o.order_date 
FROM users u 
JOIN orders o ON u.id = o.user_id 
WHERE u.city = 'Beijing';
```

优化建议：
- 在`users.city`上添加索引
- 在`orders.user_id`上添加索引

## 🎯 最佳实践

1. **定期分析慢查询**
2. **为频繁查询的列添加索引**
3. **避免在WHERE子句中使用函数**
4. **使用覆盖索引减少回表**
5. **监控`Using temporary`和`Using filesort`**

## 📝 总结

| 检查项 | 良好迹象 | 需要优化 |
|--------|----------|----------|
| **type** | const, ref, range | ALL, index |
| **key** | 使用索引 | NULL |
| **rows** | 数值小 | 数值大 |
| **Extra** | Using index | Using temporary, Using filesort |

通过EXPLAIN分析，可以系统性地识别和解决SQL性能问题，显著提升数据库查询效率。

MySQL EXPLAIN 全面指南

### 总体思路

1. **准备阶段（在一台有互联网连接的机器上）**：
   * 下载所有必需的软件包和依赖项。
   * 将它们传输到目标离线服务器。
2. **部署阶段（在目标离线服务器上）**：
   * 安装基础依赖（如 Git）。
   * 安装 Gitea。
   * 安装和配置 `act_runner`（Gitea Actions 的 runner）。
   * 将两者连接起来。



---

### 第一部分：准备离线安装包（在线机器上操作）

#### 1. 下载 Gitea

访问 Gitea 的官方下载页面：https://dl.gitea.com/gitea/

选择适合目标服务器架构的版本。最常见的是 **Linux amd64**。下载二进制文件。例如，选择版本 `1.21.0`：

```bash
# 创建一个目录来存放所有离线文件
mkdir gitea-offline
cd gitea-offline

# 下载 Gitea 二进制文件
wget -O gitea https://dl.gitea.com/gitea/1.21.0/gitea-1.21.0-linux-amd64
chmod +x gitea
```

**注意**：请将 `1.21.0` 替换为当时最新的稳定版本。

#### 2. 下载 act_runner

`act_runner` 的发布版本在 Gitea 的官方仓库：https://dl.gitea.com/act_runner/

同样选择 Linux amd64 版本：

```bash
# 下载 act_runner 二进制文件
wget -O act_runner https://dl.gitea.com/act_runner/act_runner-linux-amd64
chmod +x act_runner
```

#### 3. 下载 Docker 离线安装包（可选但强烈推荐）

Gitea Actions 依赖于 `act_runner`，而 `act_runner` 需要 Docker 来运行工作流容器。
前往 Docker 官方文档获取离线安装包：https://docs.docker.com/engine/install/binaries/

或者直接下载静态二进制包（例如，从 https://download.docker.com/linux/static/stable/ 选择版本）：

```bash
# 示例：下载 Docker 20.10.24 for x86_64
wget https://download.docker.com/linux/static/stable/x86_64/docker-20.10.24.tgz
```

#### 4. 收集其他依赖

* **Git**：确保目标服务器上已经安装了 Git。如果无法通过内部源安装，也需要下载对应的 Git RPM/Deb 包。
* **数据库**：Gitea 支持 SQLite, PostgreSQL, MySQL。SQLite 最简单，无需额外安装。如果使用其他数据库，也需要准备对应的离线安装包。

#### 5. 打包所有文件

将所有这些文件打包成一个压缩包，方便传输。

```bash
# 回到上级目录
cd ..
tar -czvf gitea-offline-pack.tar.gz gitea-offline/
```

将 `gitea-offline-pack.tar.gz` 文件通过U盘、内部网络或其他方式复制到目标离线服务器上。

---

### 第二部分：在离线服务器上部署

#### 1. 解压安装包并安装基础依赖

```bash
# 将安装包复制到服务器后，解压
tar -xzvf gitea-offline-pack.tar.gz
cd gitea-offline

# 安装 Git (如果尚未安装)
# 对于 CentOS/RHEL/Fedora，你需要提前下载好rpm包并使用rpm命令安装
# sudo rpm -ivh git-*.rpm

# 对于 Debian/Ubuntu，使用dpkg安装提前下载的deb包
# sudo dpkg -i git-*.deb
```

#### 2. 安装 Docker

```bash
# 解压 Docker 二进制包
tar -xzvf docker-20.10.24.tgz

# 将二进制文件复制到系统的可执行路径
sudo cp docker/* /usr/bin/

# 创建 docker 用户组（如果不存在）
sudo groupadd docker

# 将当前用户添加到 docker 组（例如用户 ‘git’）
sudo usermod -aG docker $USER
# 或者指定用户 sudo usermod -aG docker git

# 配置 Docker 守护进程（使用 systemd）
# 首先，创建 systemd 服务文件
sudo tee /etc/systemd/system/docker.service > /dev/null <<'EOF'
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target firewalld.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/usr/bin/dockerd
ExecReload=/bin/kill -s HUP $MAINPID
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
TimeoutStartSec=0
Delegate=yes
KillMode=process
Restart=on-failure
StartLimitBurst=3
StartLimitInterval=60s

[Install]
WantedBy=multi-user.target
EOF

# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 启动 Docker 并设置开机自启
sudo systemctl enable docker --now

# 验证 Docker 是否安装成功
docker --version
```

#### 3. 安装和配置 Gitea

```bash
# 创建一个系统用户来运行 Gitea（例如 ‘git’）
sudo adduser \
   --system \
   --shell /bin/bash \
   --comment 'Git Version Control' \
   --home /home/git \
   --group \
   --disabled-password \
   git

# 创建必要的目录结构
sudo mkdir -p /var/lib/gitea/{custom,data,log}
sudo chown -R git:git /var/lib/gitea
sudo chmod -R 750 /var/lib/gitea

# 将 gitea 二进制文件复制到全局可执行路径
sudo cp gitea /usr/local/bin
sudo chown git:git /usr/local/bin/gitea
sudo chmod +x /usr/local/bin/gitea

# 为 Gitea 创建 systemd 服务
sudo tee /etc/systemd/system/gitea.service > /dev/null <<'EOF'
[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target
After=docker.service
[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web --work-path /var/lib/gitea
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea
[Install]
WantedBy=multi-user.target
EOF

# 重新加载 systemd 并启动 Gitea
sudo systemctl daemon-reload
sudo systemctl enable gitea --now

# 检查 Gitea 状态，确保它正在运行
sudo systemctl status gitea
```

至此就可以通过浏览器访问服务器的 IP 地址和端口（默认 `http://<server-ip>:3000`）来完成 Gitea 的初始网页配置。
**重要**：在配置页面中，将 **SSH 服务器域名** 和 **Gitea 基本 URL** 设置为离线环境中其他客户端可以访问的地址。

#### 4. 安装和配置 act_runner

```bash
# 将 act_runner 二进制文件复制到全局路径
sudo cp act_runner /usr/local/bin/
sudo chmod +x /usr/local/bin/act_runner

# 为 act_runner 创建工作目录
sudo mkdir -p /var/lib/act_runner
sudo chown -R git:git /var/lib/act_runner

# 切换到 git 用户
sudo su - git

# 在 Gitea 实例中创建 Runner Token
# 1. 以管理员身份登录 Gitea Web 界面。
# 2. 进入 “站点管理” -> “Actions” -> “Runners”。
# 3. 点击 “创建新的 Runner”，选择 “Runner 类型”（例如：组织级）。
# 4. 复制生成的令牌（一个长长的字符串）。它看起来像 `MR6MZ6V4DQQBVCUVTGN6T3RRN4HS6`。

# 注册 runner (在离线服务器的命令行中运行)
# 将 <your-gitea-url> 替换为你的内网 Gitea 地址，<your-runner-token> 替换为上一步复制的令牌
cd /var/lib/act_runner
act_runner register --instance <your-gitea-url> --token <your-runner-token> --no-interactive

# 注册过程中会询问一些配置，使用默认值即可（直接回车）。由于是离线环境，`--no-interactive` 参数有助于避免需要输入无法访问的默认值（如 docker.io）。

# 为 act_runner 创建 systemd 服务文件 (以 root 用户操作)
exit # 退出 git 用户，回到 root
sudo tee /etc/systemd/system/act_runner.service > /dev/null <<'EOF'
[Unit]
Description=Gitea Act Runner
After=network.target docker.service gitea.service
Requires=docker.service
[Service]
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/act_runner
ExecStart=/usr/local/bin/act_runner daemon
Restart=always
Environment=HOME=/home/git
[Install]
WantedBy=multi-user.target
EOF

# 重新加载 systemd 并启动 act_runner
sudo systemctl daemon-reload
sudo systemctl enable act_runner --now

# 检查 act_runner 状态
sudo systemctl status act_runner
```

#### 5. 验证

1. **在 Gitea Web 界面**：回到 “站点管理” -> “Actions” -> “Runners”。应该能看到一个新注册的 runner，状态应该是 **“空闲”** 或 **“在线”**。
2. **创建一个测试仓库并启用 Actions**：在仓库中创建一个简单的 `.gitea/workflows/demo.yaml` 工作流文件，推送代码后，应该能看到 Actions 被触发并且由你的离线 runner 执行。

### 故障排除

* **Runner 状态为“离线”**：检查 `act_runner` 的日志 `journalctl -u act_runner -f`。常见问题是网络无法连接到 Gitea 服务器地址，或者令牌无效。
* **Docker 权限问题**：确保 `git` 用户属于 `docker` 组，并重新登录该用户（或重启服务）以使组更改生效。
* **工作流执行失败**：检查 `act_runner` 日志。如果工作流需要基础镜像（如 `node:20-alpine`），需要在内网搭建一个私有 Docker 镜像仓库，并提前将所需镜像推送进去，或者在离线环境中手动 `docker load` 这些镜像。

Nginx 动态代理访问子节点网页完整流程

一、环境准备

📱 使用 Kivy 将 Python 应用打包成 Android APK 完整指南

1 环境准备与安装

1.1 系统要求

1. 布局基础属性

1.1 direction - 布局方向

MySQL EXPLAIN 全面指南

📊 什么是EXPLAIN？

总体思路

1.1 `direction` - 布局方向