开发 on Kang's Blog

自定义 Redroid 镜像：从源码构建到功能增强

Wed, 17 Sep 2025 00:00:00 +0000

概述

Redroid（Remote Android）是一个基于容器技术的 Android 运行时环境，可以在 Linux 服务器上运行完整的 Android 系统。本文将详细介绍如何从 AOSP 源码开始，构建一个功能完整的自定义 Redroid 镜像，并集成 GPS 定位、电池管理、Magisk Root 等高级功能。

适用场景

移动应用开发测试
自动化测试环境搭建
Android 逆向工程和安全研究
云端 Android 服务部署

前置条件

在开始之前，请确保您的环境满足以下要求：

硬件要求

CPU: 推荐 8 核心以上，支持 x86_64 架构
内存: 至少 16GB RAM，推荐 32GB
存储: 至少 100GB 可用空间（SSD 推荐）

软件环境

操作系统: Ubuntu 20.04/22.04 LTS 或其他现代 Linux 发行版
Docker: 版本 20.10 以上
Git: 版本 2.25 以上
Python 3: 用于运行构建脚本

网络要求

稳定的网络连接（需要下载大量源码）
如遇网络问题，建议使用清华镜像源

步骤一：环境准备与源码下载

创建工作目录

1
2
3

# 创建专用的工作目录
cd /data
mkdir redroid && cd redroid

安装 Google Repo 工具

Repo 是 Google 开发的用于管理多个 Git 仓库的工具，AOSP 项目必需。

# 下载并安装 repo 工具
curl -k https://storage.googleapis.com/git-repo-downloads/repo > /usr/local/bin/repo
chmod a+x /usr/local/bin/repo

# 配置 Git 用户信息（必需）
git config --global user.email "your-email@example.com"
git config --global user.name "YourName"

注意: 请将邮箱和用户名替换为您的实际信息。

初始化 AOSP 源码仓库

# 初始化 repo，使用清华镜像源加速下载
repo init -u https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest \
    --git-lfs --depth=1 -b android-15.0.0_r36

# 添加 Redroid 专用的本地 manifest 配置
git clone https://git.coderkang.top/Android/local_manifests.git \
    .repo/local_manifests -b 15.0.0

同步源码

1
2

# 开始同步源码（耗时较长，请耐心等待）
repo sync -c

提示: 首次同步可能需要 2-4 小时，具体时间取决于网络状况。建议使用 screen 或 tmux 在后台运行。

步骤二：Magisk 模块集成

Magisk 是流行的 Android Root 解决方案，提供系统级权限管理。

提取 Magisk 组件

1
2
3

# 进入 Magisk 目录并执行提取脚本
cd /data/redroid/vendor/magisk
python3 magisk.py

该脚本会自动下载最新版本的 Magisk APK 并提取必要的二进制文件和模块，集成到系统镜像中。

步骤三：应用定制补丁

下载并应用 Redroid 补丁

# 回到主目录
cd /data

# 获取 Redroid 专用补丁集
git clone https://git.coderkang.top/Android/redroid-patches.git

# 应用所有补丁到源码
./redroid-patches/apply-patch.sh /data/redroid

这些补丁包含：

GPS 功能: 启用定位服务支持
电池管理: 模拟电池状态和电源管理
网络增强: 改进网络连接稳定性
性能优化: 针对容器环境的性能调优

步骤四：Docker 构建环境搭建

创建构建容器

# 获取构建工具
git clone https://git.coderkang.top/Android/redroid-doc.git
cd redroid-doc/android-builder-docker

# 构建 Docker 镜像（包含所有构建依赖）
docker build \
    --build-arg userid=$(id -u) \
    --build-arg groupid=$(id -g) \
    --build-arg username=$(id -un) \
    -t redroid-builder .

启动构建环境

# 启动构建容器，挂载源码目录
docker run -it --rm \
    --hostname redroid-builder \
    --name redroid-builder \
    -v /data/redroid:/src \
    redroid-builder

步骤五：编译 Android 系统

配置构建环境

# 在容器内执行以下命令
cd /src

# 初始化构建环境
. build/envsetup.sh

# 选择构建目标（ARM64 架构，用户调试版本）
lunch redroid_arm64_only-ap3a-userdebug

开始编译

1
2

# 启动编译过程（时间较长，建议使用 -j 参数指定并行度）
m -j$(nproc)

编译时间: 根据硬件配置，编译时间通常在 1-3 小时之间。

步骤六：镜像打包与部署

创建 Docker 镜像

编译完成后，需要将生成的系统文件打包为 Docker 镜像。

# 退出构建容器，回到宿主机
exit

# 进入编译输出目录
cd /data/redroid/out/target/product/redroid_arm64_only

# 挂载系统镜像（只读）
sudo mount system.img system -o ro
sudo mount vendor.img vendor -o ro

# 打包为 Docker 镜像
sudo tar --xattrs -c vendor -C system --exclude="./vendor" . | \
    docker import -c 'ENTRYPOINT ["/init", "androidboot.hardware=redroid", "ro.setupwizard.mode=DISABLED"]' \
    - redroid:custom

# 卸载镜像文件
sudo umount system vendor

验证镜像

# 查看创建的镜像
docker images | grep redroid

# 测试启动容器
docker run -itd --rm --memory-swappiness=0 \
    --name redroid-test \
    -p 5555:5555 \
    redroid:custom

功能验证与使用

验证 Root 权限

# 连接到 Redroid 容器
adb connect localhost:5555

# 验证 Root 权限
adb shell su -c "id"

验证 GPS 功能

1
2

# 检查 GPS 服务状态
adb shell dumpsys location

验证电池管理

1
2

# 查看电池状态
adb shell dumpsys battery

常见问题与解决方案

编译错误

问题: 内存不足导致编译失败

1
2

# 解决方案：减少并行度
m -j4  # 使用较少的并行任务

问题: 磁盘空间不足

1
2

# 解决方案：清理编译缓存
make clean

运行时问题

问题: 容器无法启动

# 检查内核模块
lsmod | grep binder
lsmod | grep ashmem

# 如果缺失，加载模块
sudo modprobe binder_linux
sudo modprobe ashmem_linux

问题: ADB 连接失败

1
2
3

# 重启 ADB 服务
adb kill-server
adb start-server

优化建议

性能优化

内存配置: 为容器分配足够的内存（推荐 4GB+）
CPU 配置: 启用 CPU 热插拔支持
存储优化: 使用 SSD 存储提升 I/O 性能

安全考虑

网络隔离: 使用自定义 Docker 网络
权限控制: 限制容器权限，避免特权模式
数据持久化: 合理配置数据卷挂载

总结

通过本文的详细指导，您已经成功构建了一个功能完整的自定义 Redroid 镜像。这个镜像集成了 GPS、电池管理、Magisk Root 等高级功能，可以满足各种开发和测试需求。

在实际使用中，您可以根据具体需求进一步定制系统配置，添加更多功能模块，或者优化性能参数。Redroid 的灵活性使其成为 Android 开发和测试的理想选择。

下一步

探索更多 Magisk 模块集成
配置持续集成/持续部署（CI/CD）
搭建多实例集群环境
集成自动化测试框架

Autojs 在 Redroid 上使用

Tue, 02 Sep 2025 00:00:00 +0000

前言

在此前的文章中，介绍了如何在 Docker 中配置 Redroid 并通过 Magisk 获取 Root 权限。随着部分开源模块对 Magisk 版本的要求提升，本文采用 ayasa520/redroid-script 进行镜像构建与 Root 方案更新，同时引入 AutoJS 以满足自启动与自动化点击等需求，记录从构建、编排到排障的完整流程。

合规与风险提示
本文仅用于学习与研究。涉及证书、Root、系统模块与网络重定向的操作可能触发合规与安全风险。任何生产或对第三方系统的操作需确保具备合法授权。文中出现的设备标识（如 IMEI）为示例值，请替换为自有、合规的虚构数据。

环境与准备

Docker / Docker Compose
可运行 Redroid 的 Linux 主机
ADB / Scrcpy（用于调试与投屏）
基础应用：MT 管理器、Termux、AutoJsPro、JustTrustMe
Magisk 模块：LSPosed、AlwaysTrustUserCerts、Systemless Hosts
统一资源包（文末提供下载地址）

构建内置 Magisk 的 Redroid 镜像

获取脚本并安装依赖

git clone https://github.com/ayasa520/redroid-script
cd redroid-script

apt update && apt install -y lzip
pip install -r requirements.txt

扩展 Android 版本枚举（示例：14/15）

如需 Android 14/15，请在 redroid.py 中补全可选版本：

def main():
    ...
    parser.add_argument('-a', '--android-version',
                        dest='android',
                        help='Specify the Android version to build',
                        default='11.0.0',
-                        choices=['13.0.0', '12.0.0', '12.0.0_64only', '11.0.0', '10.0.0', '9.0.0', '8.1.0'])
+                        choices=['15.0.0_64only', '15.0.0', '14.0.0_64only', '14.0.0',
+                                 '13.0.0_64only', '13.0.0', '12.0.0', '12.0.0_64only',
+                                 '11.0.0', '10.0.0', '9.0.0', '8.1.0'])

构建内置 Magisk 的镜像

1
2

python3 redroid.py -a 15.0.0_64only -m
# 新镜像：redroid/redroid:15.0.0_64only_magisk

启动 Redroid

docker-compose.yaml 示例：

name: android
services:
  redroid_15_1:
    image: redroid/redroid:15.0.0_64only_magisk
    container_name: redroid_15_1
    restart: unless-stopped
    privileged: true
    networks:
      android:
        ipv4_address: 172.18.0.252
    ports:
      - "45555:5555"
    volumes:
      - ./redroid_15_1:/data
    command:
      - androidboot.hardware=mt6891
      - androidboot.hwc=CN
      - androidboot.redroid_height=2400
      - androidboot.redroid_width=1080
      - ro.boot.hwc=CN
      - ro.product.manufacturer=Xiaomi
      - ro.product.brand=Xiaomi
      - ro.product.model=2211133C
      - ro.product.marketname=Xiaomi 13
      - ro.product.device=fuxi
      - ro.product.name=fuxi
      - ro.build.product=fuxi
      - ro.product.mod_device=fuxi
      - ro.secure=0
      - ro.product.locale=zh-CN
      - ro.product.locale.language=zh
      - ro.product.locale.region=CN
      - persist.sys.locale=zh-CN
      - persist.sys.locale_list=zh-CN,en-US
      - persist.sys.timezone=Asia/Shanghai
      - persist.sys.time_12_24=24

networks:
  android:
    driver: bridge
    ipam:
      config:
        - subnet: 172.18.0.0/16

启动与连接：

docker compose up -d
docker compose ps
docker compose logs -f redroid_15_1

adb connect 127.0.0.1:45555
adb devices
adb shell whoami

运行正常后可通过 45555 端口访问 ADB 服务。

基础软件与模块安装

软件（统一资源包，见文末）

MT 管理器
Termux
AutoJsPro
JustTrustMe

Magisk 模块

LSPosed
AlwaysTrustUserCerts
Systemless Hosts

建议流程：先安装用户证书（见下文），再启用 AlwaysTrustUserCerts，随后按需安装/启用其他模块，以提升 Zygisk 生效的稳定性。

Root 授权与 `su` 路径

现象

在 Termux 中执行 su 可正常触发 Magisk 授权弹窗；
在 MT 管理器、Shizuku 中无法获取 Root；
logcat 无明显异常信息。

处置

显式指定 su 路径为 /sbin/su；
参考项目 issue：https://github.com/ayasa520/redroid-script/issues/47#issuecomment-3242690759。

说明不同 App 的 Root 发现与调用路径存在差异，显式路径可避免环境变量或挂载策略导致的可见性问题。若自定义了 PATH、SELinux 或 overlayfs，也需同步评估其影响。

Zygisk 不生效的排查思路

症状 Magisk 中 Zygisk 始终提示“需要重启”，重启后依旧未生效，日志信息有限。

可复用操作

在系统设置中先安装用户证书；
通过 LSPosed/模块管理启用 AlwaysTrustUserCerts；
重启 Redroid，使 Zygisk 与相关模块完成初始化与挂载。

如仍不生效，可尝试清理模块缓存、核对 LSPosed 版本兼容性，并在必要时回退至稳定的 Magisk/Redroid 组合版本。

部署 AutoJS 自动化

适用场景 需要在特定 App 启动后执行自动点击、心跳或表单填充等动作。

合规说明 以下方法仅限自有环境与授权测试场景，请勿用于未授权的应用或服务。

准备 AutoJS 服务

# 解压资源包中的 autojserver.tar.gz 至编排目录
tar -zxvf autojserver.tar.gz

cd autojserver
chmod +x main.sh
bash main.sh
# 初始化后将生成自签证书等运行所需文件

Compose 编排

name: android
services:
  redroid_15_1:
    image: redroid/redroid:15.0.0_64only_magisk
    container_name: redroid_15_1
    restart: unless-stopped
    privileged: true
    networks:
      android:
        ipv4_address: 172.18.0.252
    ports:
      - "45555:5555"
    volumes:
      - ./redroid_15_1:/data
    command:
      - androidboot.hardware=mt6891
      - androidboot.hwc=CN
      - androidboot.redroid_height=2400
      - androidboot.redroid_width=1080
      - ro.boot.hwc=CN
      - ro.product.manufacturer=Xiaomi
      - ro.product.brand=Xiaomi
      - ro.product.model=2211133C
      - ro.product.marketname=Xiaomi 13
      - ro.product.device=fuxi
      - ro.product.name=fuxi
      - ro.build.product=fuxi
      - ro.product.mod_device=fuxi
      - ro.secure=0
      - ro.product.locale=zh-CN
      - ro.product.locale.language=zh
      - ro.product.locale.region=CN
      - persist.sys.locale=zh-CN
      - persist.sys.locale_list=zh-CN,en-US
      - persist.sys.timezone=Asia/Shanghai
      - persist.sys.time_12_24=24

  autojserver:
    image: autojserver:latest
    build:
      context: ./autojserver
      dockerfile: Dockerfile
    container_name: autojserver
    restart: unless-stopped
    working_dir: /data
    networks:
      android:
        ipv4_address: 172.18.0.251
    command: ["python", "/data/main.py"]
    volumes:
      - ./autojserver:/data

networks:
  android:
    driver: bridge
    ipam:
      config:
        - subnet: 172.18.0.0/16

启动与日志查看

1
2
3

docker compose up -d
docker compose ps
docker compose logs -f autojserver

证书与 hosts 注入

# 用户证书：用于系统设置中手动安装
cp ./autojserver/ca.crt ./redroid_15_1/media/0/Download/

# Systemless Hosts：需确保模块已安装
cp -rf ./autojserver/hosts ./redroid_15_1/adb/modules/hosts/system/etc/

随后在 系统设置 → 安全 → 加密与凭据（或证书管理）→ 从存储安装 中安装 ca.crt 用户证书，并在 JustTrustMe 作用域中勾选 AutoJS/目标 App。完成后重启 Redroid。

资源下载

统一资源包

软件：MT 管理器、Termux、AutoJsPro、JustTrustMe
模块：LSPosed、AlwaysTrustUserCerts、Systemless Hosts

Kubernetes Ingress域名自动解析与证书管理

Tue, 17 Dec 2024 00:00:00 +0000

部署

请确保已经部署

cert-manager：Installation - cert-manager Documentation

`1`	`kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.15.3/cert-manager.yaml`

cert-manager-webhook-dnspod：imroc/cert-manager-webhook-dnspod: cert-manager webhook resolver for DNSPod (github.com)

`1`	`kubectl apply -f https://raw.githubusercontent.com/imroc/cert-manager-webhook-dnspod/master/bundle.yaml`

修改部署文件ingress-dnspod-solver.yaml以下内容：

ingress-dnspod-solver.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: ingress-dnspod-solver
  namespace: cert-manager
  labels:
    app: ingress-dnspod-solver

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: ingress-dnspod-solver
rules:
  - apiGroups: [ "networking.k8s.io" ]
    resources: [ "ingresses" ]
    verbs: [ "get", "list", "watch" ]

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ingress-dnspod-solver
  labels:
    app: ingress-dnspod-solver
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: ingress-dnspod-solver
subjects:
  - apiGroup: ""
    kind: ServiceAccount
    name: ingress-dnspod-solver
    namespace: cert-manager

---
apiVersion: v1
kind: Secret
metadata:
  name: ingress-dnspod-solver
  namespace: cert-manager
type: Opaque
stringData:
  TENCENT_SECRET_KEY: "<secret_key>"  # 腾讯云密钥

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: ingress-dnspod-solver
  namespace: cert-manager
data:
  DOMAIN: "example.com"  # 域名
  POLICY: "retain"       # 监听处置策略：retain(当资源更新时保留记录)、update(当资源更新时更新记录)
  TENCENT_SECRET_ID: "<secret_id>"  # 腾讯云密钥
  RECORD_VALUE: "<record_value>"  # 解析值

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ingress-dnspod-solver
  namespace: cert-manager
  labels:
    app: ingress-dnspod-solver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ingress-dnspod-solver
  template:
    metadata:
      labels:
        app: ingress-dnspod-solver
    spec:
      serviceAccountName: ingress-dnspod-solver
      containers:
        - name: ingress-dnspod-solver
          image: harbor.example.com/devops/ingress-dnspod-solver:latest
          imagePullPolicy: IfNotPresent
          env:
            - name: DOMAIN
              valueFrom:
                configMapKeyRef:
                  name: ingress-dnspod-solver
                  key: DOMAIN
            - name: POLICY
              valueFrom:
                configMapKeyRef:
                  name: ingress-dnspod-solver
                  key: POLICY
            - name: TENCENT_SECRET_ID
              valueFrom:
                configMapKeyRef:
                  name: ingress-dnspod-solver
                  key: TENCENT_SECRET_ID
            - name: TENCENT_SECRET_KEY
              valueFrom:
                secretKeyRef:
                  name: ingress-dnspod-solver
                  key: TENCENT_SECRET_KEY
            - name: RECORD_VALUE
              valueFrom:
                configMapKeyRef:
                  name: ingress-dnspod-solver
                  key: RECORD_VALUE

`1`	`kubectl apply -f ingress-dnspod-solver.yaml`

源码分析构建

源码采用 go 语言编写，使用 go mod 管理依赖。

main.go

package main

import (
	"fmt"
	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
	dnspod "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/dnspod/v20210323"
	"go.uber.org/zap"
	networkingv1 "k8s.io/api/networking/v1"
	"k8s.io/client-go/informers"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/cache"
	"k8s.io/client-go/tools/clientcmd"
	"os"
)

var (
	logger       *zap.Logger
	version      string
	policy       string
	domain       string
	secretId     string
	secretKey    string
	recordValue  string
	dnsPodClient *dnspod.Client
	clientSet    *kubernetes.Clientset
)

func initLogger() {
	logger, _ = zap.NewDevelopment()
	defer func(logger *zap.Logger) {
		err := logger.Sync()
		if err != nil {
			fmt.Println("Logger sync error: ", err)
		}
	}(logger)
}

func initCheck() {
	version = os.Getenv("VERSION")
	if version == "" {
		version = "2021-03-23"
	}
	policy = os.Getenv("POLICY")
	if policy == "" {
		policy = "retain"
	}
	domain = os.Getenv("DOMAIN")
	if domain == "" {
		logger.Error("Please set the environment variable `DOMAIN`")
		os.Exit(1)
	}
	secretId = os.Getenv("TENCENT_SECRET_ID")
	secretKey = os.Getenv("TENCENT_SECRET_KEY")
	if secretId == "" || secretKey == "" {
		logger.Error("Please set the environment variables `TENCENT_SECRET_ID` and `TENCENT_SECRET_KEY`")
		os.Exit(1)
	}
	recordValue = os.Getenv("RECORD_VALUE")
	if recordValue == "" {
		logger.Error("Please set the environment variable `RECORD_VALUE`")
		os.Exit(1)
	}

	logger.Info("---------------------------------")
	logger.Info("Version" + ": " + version)
	logger.Info("Policy" + ": " + policy)
	logger.Info("Domain" + ": " + domain)
	logger.Info("SecretId" + ": " + secretId)
	logger.Info("SecretKey: *****")
	logger.Info("RecordValue" + ": " + recordValue)
	logger.Info("---------------------------------")
}

func getRecordDict() map[string]uint64 {
	recordDict := make(map[string]uint64)
	request := dnspod.NewDescribeRecordListRequest()
	request.Domain = common.StringPtr(domain)
	request.RecordType = common.StringPtr("A")
	request.Offset = common.Uint64Ptr(0)
	request.Limit = common.Uint64Ptr(10)

	// 返回的 response 是一个 DescribeRecordListResponse 的实例，与请求对象对应
	response, err := dnsPodClient.DescribeRecordList(request)
	if err != nil {
		logger.Panic(err.Error())
	}
	for i := 0; i < len(response.Response.RecordList); i++ {
		recordDict[*response.Response.RecordList[i].Name] = *response.Response.RecordList[i].RecordId
	}
	domainCount := *response.Response.RecordCountInfo.ListCount
	domainTotal := *response.Response.RecordCountInfo.TotalCount
	for domainCount < domainTotal {
		request.Offset = common.Uint64Ptr(domainCount)
		response, err = dnsPodClient.DescribeRecordList(request)
		if err != nil {
			logger.Panic(err.Error())
		}
		for i := 0; i < len(response.Response.RecordList); i++ {
			recordDict[*response.Response.RecordList[i].Name] = *response.Response.RecordList[i].RecordId
		}
		domainCount += *response.Response.RecordCountInfo.ListCount
	}

	logger.Info("RecordDict: ", zap.Any("RecordDict", recordDict))
	return recordDict
}

func createRecord(subDomain string) {
	request := dnspod.NewCreateRecordRequest()
	request.Domain = common.StringPtr(domain)
	request.SubDomain = common.StringPtr(subDomain)
	request.RecordType = common.StringPtr("A")
	request.RecordLine = common.StringPtr("默认")
	request.Value = common.StringPtr(recordValue)

	_, err := dnsPodClient.CreateRecord(request)
	if err != nil {
		logger.Panic(err.Error())
	}
}

func updateRecord(recordId uint64, subDomain string) {
	request := dnspod.NewModifyRecordRequest()
	request.Domain = common.StringPtr(domain)
	request.RecordId = common.Uint64Ptr(recordId)
	request.SubDomain = common.StringPtr(subDomain)
	request.RecordType = common.StringPtr("A")
	request.RecordLine = common.StringPtr("默认")
	request.Value = common.StringPtr(recordValue)

	_, err := dnsPodClient.ModifyRecord(request)
	if err != nil {
		logger.Panic(err.Error())
	}
}

func deleteRecord(recordId uint64) {
	request := dnspod.NewDeleteRecordRequest()
	request.Domain = common.StringPtr(domain)
	request.RecordId = common.Uint64Ptr(recordId)

	_, err := dnsPodClient.DeleteRecord(request)
	if err != nil {
		logger.Panic(err.Error())
	}
}

func addHandler(obj interface{}) {
	logger.Info("Detect Ingress Add Event")
	recordDict := getRecordDict()
	addIngress := obj.(*networkingv1.Ingress)
	for i := 0; i < len(addIngress.Spec.Rules); i++ {
		customDomain := addIngress.Spec.Rules[i].Host
		// customDomain 判断是否以 domain 结尾
		if customDomain[len(customDomain)-len(domain):] != domain {
			continue
		}
		subDomain := customDomain[:len(customDomain)-len(domain)-1]
		if _, ok := recordDict[subDomain]; !ok {
			createRecord(subDomain)
		} else {
			if policy == "update" {
				updateRecord(recordDict[subDomain], subDomain)
			}
		}
	}
}

func updateHandler(oldObj, newObj interface{}) {
	logger.Info("Detect Ingress Update Event")
	recordDict := getRecordDict()
	newIngress := newObj.(*networkingv1.Ingress)
	for i := 0; i < len(newIngress.Spec.Rules); i++ {
		customDomain := newIngress.Spec.Rules[i].Host
		// customDomain 判断是否以 domain 结尾
		if customDomain[len(customDomain)-len(domain):] != domain {
			continue
		}
		subDomain := customDomain[:len(customDomain)-len(domain)-1]
		if _, ok := recordDict[subDomain]; !ok {
			createRecord(subDomain)
		} else {
			updateRecord(recordDict[subDomain], subDomain)
		}
	}
}

func deleteHandler(obj interface{}) {
	logger.Info("Detect Ingress Delete Event")
	recordDict := getRecordDict()
	deleteIngress := obj.(*networkingv1.Ingress)
	for i := 0; i < len(deleteIngress.Spec.Rules); i++ {
		customDomain := deleteIngress.Spec.Rules[i].Host
		// customDomain 判断是否以 domain 结尾
		if customDomain[len(customDomain)-len(domain):] != domain {
			continue
		}
		subDomain := customDomain[:len(customDomain)-len(domain)-1]
		if _, ok := recordDict[subDomain]; ok {
			deleteRecord(recordDict[subDomain])
		}
	}
}

func k8sInformer() {
	// 创建共享 Informer 工厂
	factory := informers.NewSharedInformerFactory(clientSet, 0)

	// 获取 Informer Ingress watcher
	ingressInformer := factory.Networking().V1().Ingresses().Informer()

	// 添加事件处理器来监听 Ingress 资源的变化
	_, err := ingressInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
		AddFunc:    addHandler,
		UpdateFunc: updateHandler,
		DeleteFunc: deleteHandler,
	})
	if err != nil {
		return
	}

	// 启动 informer 并等待缓存同步
	stopCh := make(chan struct{})
	defer close(stopCh)
	factory.Start(stopCh)
	factory.WaitForCacheSync(stopCh)

	// 阻塞，持续监听事件
	<-stopCh
}

func main() {
	// 初始化
	initLogger()
	initCheck()

	// 创建 DNSPod 客户端
	credential := common.NewCredential(secretId, secretKey)
	cpf := profile.NewClientProfile()
	cpf.HttpProfile.Endpoint = "dnspod.tencentcloudapi.com"
	dnsPodClient, _ = dnspod.NewClient(credential, "", cpf)

	// 创建 Kubernetes 客户端
	var config *rest.Config
	var err error
	// 判断是否在集群内部
	if os.Getenv("KUBERNETES_SERVICE_HOST") != "" {
		config, err = rest.InClusterConfig()
		if err != nil {
			logger.Panic(err.Error())
		}
	} else {
		if _, err = os.Stat("./.kube/config"); os.IsNotExist(err) {
			logger.Panic("Please set the kubeconfig file")
		}
		config, err = clientcmd.BuildConfigFromFlags("", "./.kube/config")
	}
	clientSet, err = kubernetes.NewForConfig(config)
	if err != nil {
		logger.Panic(err.Error())
	}
	k8sInformer()
}

Dockerfile

FROM golang:alpine AS builder
WORKDIR /app
COPY . .
RUN go mod download
RUN go build -o main .

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
CMD ["./main"]

构建镜像

`1`	`docker build -t harbor.example.com/devops/ingress-dnspod-solver:latest .`

推送镜像

`1`	`docker push harbor.example.com/devops/ingress-dnspod-solver:latest`

安卓Redroid容器化实现指南

Fri, 01 Dec 2023 00:00:00 +0000

安卓-iOS-macOS Docker

Redroid

非 Root 版本

启动

version: "3.0"
services:
  redroid_11:
    image: redroid/redroid:11.0.0-latest  # 安卓 11
    container_name: redroid_11
    privileged: true
    restart: always
    ports:
      - 5555:5555
    volumes:
      - ../data/redroid_11:/data
    command: ro.secure=0

Root 版本

初始化脚本

路径：~/Redroid/MagiskOnRedroid/

需要注意机器的 CPU 架构

#!/bin/bash


# 删除旧的文件
rm -rf ./magisk* ./remove.rc ./setup.sh


# 创建一个目录，用于存放 magisk 的文件
if [ ! -d "/root/Redroid/MagiskOnRedroid" ]; then
  mkdir ~/Redroid/MagiskOnRedroid
fi
cd ~/Redroid/MagiskOnRedroid


# 下载 magisk 的 apk 文件
find -maxdepth 1 -iname "magisk*" -not -name "*.apk" -exec rm -r {} \;
magisk_file="app-debug.apk"
if [ ! -f $magisk_file ]; then
  wget "https://cdn.jsdelivr.net/gh/topjohnwu/magisk-files@1cea72840fbf690f9a95512d03721f6a710fe02e/app-debug.apk"
fi
# 解压 magisk 的 apk 文件：注意机器的架构，这里是 x86_64
unzip -j $magisk_file "lib/x86_64/libmagisk64.so" -d magisk
unzip -j $magisk_file "lib/x86_64/libbusybox.so" -d magisk
mv -v magisk/libmagisk64.so magisk/magisk
mv -v magisk/libbusybox.so magisk/busybox


# 压缩 magisk 的文件
tar --transform 's/.*\///g' -cf ./magisk.tar --absolute-names $( find ~/Redroid/MagiskOnRedroid | grep -E "magisk/|app-debug.apk$" )


# remove.rc
cat <<\EOF > ./remove.rc
on early-init
        export PATH /sbin:/product/bin:/apex/com.android.runtime/bin:/apex/com.android.art/bin:/system_ext/bin:/system/bin:/system/xbin:/odm/bin:/vendor/bin:/vendor/xbin
        chmod 0700 /magisk.tar
        chown root root /magisk.tar
        chmod 0700 /setup.sh
        chown root root /setup.sh
        exec root root -- /setup.sh
service magisk-d /sbin/magisk --daemon
        user root
        oneshot
on boot
        start magisk-d
on post-fs-data
        start logd
        rm /dev/.magisk-unblock
        start s1
        wait /dev/.magisk-unblock 5
        rm /dev/.magisk-unblock
service s1 /sbin/magisk --post-fs-data
        user root
        oneshot
service s2 /sbin/magisk --service
        class late_start
        user root
        oneshot
on property:sys.boot_completed=1
        exec /sbin/magisk --boot-complete
on property:init.svc.zygote=restarting
        exec /sbin/magisk --zygote-restart
on property:init.svc.zygote=stopped
        exec /sbin/magisk --zygote-restart
EOF
sudo chmod 644 ./remove.rc
sudo chown root:root ./remove.rc


# setup.sh
cat <<\EOF > ./setup.sh
#!/system/bin/sh

# rm /system/fonts/NotoColorEmoji.ttf
tmpPushed=/magisk
rm -rf $tmpPushed
mkdir $tmpPushed
tar -xvf /magisk.tar --no-same-owner -C $tmpPushed
umount /magisk.tar ; rm -v /magisk.tar
mkdir /sbin
chown root:root /sbin
# chmod 0700 /sbin
chmod 0751 /sbin
cp $tmpPushed/magisk /sbin/
cp $tmpPushed/app-debug.apk /sbin/stub.apk
find /sbin -type f -exec chmod 0755 {} \;
find /sbin -type f -exec chown root:root {} \;
# add /sbin
# /sbin/
# ├── magisk
# └── stub.apk


ln -f -s /sbin/magisk /system/xbin/su
mkdir /product/bin
chmod 751 /product/bin
ln -f -s /sbin/magisk /product/bin/su
# add su (override `/system/xbin/su`)
# /product/bin/
# └── su -> /sbin/magisk

mkdir -p /data/adb/magisk
chmod 700 /data/adb
mv $tmpPushed/busybox /data/adb/magisk/
chmod -R 755 /data/adb/magisk
chmod -R root:root /data/adb/magisk
# /data/adb/
# ├── magisk
# │   └── busybox

# rm -rf $tmpPushed
EOF
sudo chmod 700 ./setup.sh
sudo chown root:root ./setup.sh

启动

version: "3.0"
services:
  redroid_11_magisk:
    image: redroid/redroid:11.0.0-latest  # 安卓 11
    container_name: redroid_11_magisk
    privileged: true
    restart: always
    ports:
      - 5555:5555
    volumes:
      - ../data/redroid_11_magisk:/data
      - ../MagiskOnRedroid/remove.rc:/vendor/etc/init/remove.rc
      - ../MagiskOnRedroid/setup.sh:/setup.sh
      - ../MagiskOnRedroid/magisk.tar:/magisk.tar
    command: ro.secure=0

连接模拟器

1
2

adb connect 172.16.0.101:5555
scrcpy -s 172.16.0.101:5555

使用 ACME 在 DNSPod 上自动配置 SSL 证书指南

Mon, 18 Sep 2023 00:00:00 +0000

Docker 部署 acme.sh

docker-compose.yml，将 DNSPod API ID 和 Key 替换为实际值。

services:
  acme-sh:
    image: neilpang/acme.sh:latest
    container_name: acme
    restart: always
    command: daemon
    environment:
      - TZ=Asia/Shanghai
      - DP_Id=******            # DNSPod API ID
      - DP_Key=**************** # DNSPod API Key
    volumes:
      - ./certs/:/acme.sh/

配置 acme.sh

# 启动 acme.sh
docker compose up -d
# 进入 acme.sh 容器
docker compose exec -it acme sh
# 设置默认 CA
acme.sh --set-default-ca --server letsencrypt

申请证书

生成证书，将 www.example.com 替换为实际域名。证书会挂载到 ./certs/ 目录下。

`1`	`acme.sh --issue --dns dns_dp -d www.example.com`