OCP中的OCS operator介绍及应用示例

一、OCS operator介绍

在 Red Hat OpenShift Container Platform（OCP4.8版之前，包含4.8） 中，OCS Operator（OpenShift Container Storage Operator） 是用于在 OpenShift 集群中部署、配置和管理 OpenShift Container Storage（OCS） 的核心组件。

OCS 是 Red Hat 推出的一个 软件定义存储（SDS）解决方案，其核心基于 Ceph 构建，为 Kubernetes 工作负载提供持久存储（块、文件、对象存储），并可用于集群内部的多种使用场景，如：

• 容器持久卷（PV）存储；

• 内部对象存储（如为 AI/ML 或 S3 接口使用）；

• 镜像仓库存储（例如 OpenShift 内置的镜像仓库）；

• 日志、监控存储（如 Prometheus 数据）； 

1、OCS Operator 的作用

OCS Operator 是一个 Operator Framework 应用，核心职责包括：

1. 部署 OCS 所需的存储组件：

   • 部署并管理 Ceph 的核心服务组件（如 rook-ceph-mon、rook-ceph-osd、rook-ceph-mgr 等）；

   • 部署 NooBaa（对象存储服务）；

   • 部署 StorageClass 供 PVC 动态创建使用。

2. 管理生命周期：

   • 自动执行升级、修补、安全加固；

   • 自动扩容 Ceph 存储池；

   • 故障自愈和监控。

3. 集成 Kubernetes 存储资源对象：

   • 创建 StorageCluster、CephCluster、ObjectBucketClaim 等自定义资源（CR）；

   • 支持动态卷调度、存储池自动管理；

   • 提供标准 CSI 接口（块存储、文件存储、对象存储）； 

2、关键组件关系图

+-------------------------------+
|         OCS Operator         |
+-------------------------------+
       |   |            |   |
       ↓   ↓            ↓   ↓
+-----------+   +---------------+
| Rook-Ceph |   |     NooBaa     |   <- 提供对象存储（S3接口）
+-----------+   +---------------+
      |
      ↓
+----------------------+
| Ceph Cluster         |
| - MON / MGR / OSD    |   <- 支持块、文件存储
+----------------------+

3、部署流程简要说明

1. 安装 Operator：

   • 在 OpenShift 的 OperatorHub 中安装 OCS Operator；

   • Operator 安装后自动安装 Rook-Ceph 和 NooBaa Operator。

2. 创建 StorageCluster 资源：

   • StorageCluster 是 OCS 的顶级 CR，定义了整个存储集群的配置；

   • 你可以指定使用哪些节点、磁盘、存储类型（Internal、External）等。

3. 自动部署存储集群：

   • OCS Operator 基于 StorageCluster 自动创建 Rook-Ceph 集群、存储池等。 

4、常见的资源类型（CR）

• StorageCluster：定义整个 OCS 集群；

• CephCluster：由 Rook 创建，定义 Ceph 配置；

• CephBlockPool、CephFilesystem、ObjectBucketClaim：分别管理块存储、文件系统和对象存储；

• StorageClass：Kubernetes 中定义 PV 的接口资源。 

5、使用场景举例

• 应用数据库（MySQL/PostgreSQL）的 PVC 存储；

• 部署 AI/ML 任务，使用 OCS 提供的对象存储（S3）上传/读取模型；

• OpenShift Logging / Monitoring 的数据存储；

• 为 Jenkins 提供持久化数据支持。 

如果你已经在使用 OCP，并希望搭建自定义存储系统，OCS 是一个企业级的高可用存储解决方案，由 Operator 管理，可深度集成 OpenShift 的生态。

二、OCS Operator 的实际部署 YAML 示例

下面是一个完整的 OpenShift Container Storage（OCS） Operator 安装与配置对象存储（S3 Bucket）的示例流程，包括：

1. 安装 OCS Operator（通过 Web 控制台或 CLI）

2. 创建 StorageCluster 资源

3. 创建对象存储（NooBaa Bucket）并获取 S3 凭据 

1、安装 OCS Operator

可以通过 OpenShift Console 安装（OperatorHub），也可以用 CLI 安装：

1. 创建 OperatorGroup 和 Subscription

# ocs-operator-subscription.yaml
apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
  name: ocs-operatorgroup
  namespace: openshift-storage
spec:
  targetNamespaces:
    - openshift-storage
---
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
  name: ocs-subscription
  namespace: openshift-storage
spec:
  channel: stable-4.12  # 根据你的 OCP 版本选
  name: ocs-operator
  source: redhat-operators
  sourceNamespace: openshift-marketplace

oc create namespace openshift-storage
oc apply -f ocs-operator-subscription.yaml

 等待几分钟，直到 OCS Operator 安装完成。

2、创建 StorageCluster（本地集群）

# storagecluster.yaml
apiVersion: ocs.openshift.io/v1
kind: StorageCluster
metadata:
  name: ocs-storagecluster
  namespace: openshift-storage
spec:
  manageNodes: false
  monDataDirHostPath: /var/lib/rook
  storageDeviceSets:
    - count: 1
      dataPVCTemplate:
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 512Gi
          storageClassName: gp2  # 替换为你的默认 StorageClass
          volumeMode: Block
      name: ocs-deviceset
      portable: true
      replica: 3
      resources: {}
  externalStorage: false

oc apply -f storagecluster.yaml

等待 StorageCluster 状态变为 Ready，表示 Ceph + NooBaa 正常运行。

3、创建对象存储 Bucket（S3 接口）

1. 创建 ObjectBucketClaim（OBC）

# s3-bucket-claim.yaml
apiVersion: objectbucket.io/v1alpha1
kind: ObjectBucketClaim
metadata:
  name: my-s3-bucket
  namespace: openshift-storage
spec:
  generateBucketName: mybucket-
  storageClassName: openshift-storage.noobaa.io

oc apply -f s3-bucket-claim.yaml

这将自动创建：

• 一个 S3 Bucket（在 NooBaa 中）；

• 一个 Secret（包含 S3 access_key、secret_key）；

• 一个 ConfigMap（包含 endpoint 等信息）。

2. 查看访问凭据

# 获取 Secret 名称
SECRET=$(oc get obc -n openshift-storage my-s3-bucket -o jsonpath='{.spec.secretName}')

# 查看访问信息
oc get secret -n openshift-storage $SECRET -o yaml

 会看到内容类似：

data:
  AWS_ACCESS_KEY_ID: BASE64ENCODED
  AWS_SECRET_ACCESS_KEY: BASE64ENCODED
  BUCKET_HOST: ...
  BUCKET_NAME: ...
  BUCKET_PORT: "443"

用 base64 -d 解码即可使用。

3. 使用 S3 工具访问 Bucket（示例：s3cmd）

# .s3cfg 示例
[default]
access_key = <access-key>
secret_key = <secret-key>
host_base = <bucket-host>
host_bucket = <bucket-host>
use_https = True
signature_v2 = False

s3cmd ls  # 查看 bucket
s3cmd put file.txt s3://mybucket-xxxx/

三、OCS提供PV给数据库使用

下面介绍如何使用 OpenShift Container Storage（OCS）提供的 Persistent Volume（PV） 为数据库（例如 PostgreSQL、MySQL）等提供持久化存储。

OCS 会自动创建多个 StorageClass，这些 StorageClass 通过 Ceph 提供不同类型的存储接口：

1、OCS 默认提供的 StorageClass 类型

部署好 OCS 后，系统会自动创建以下 StorageClass：

StorageClass 名称	类型	描述
ocs-storagecluster-ceph-rbd	Block 存储	适合数据库、缓存等高 IOPS 应用
ocs-storagecluster-cephfs	文件存储	适合共享访问，如 CI/CD 构建产物
ocs-storagecluster-ceph-rgw	对象存储	用于 OBC，非 PVC 直接使用

对于数据库，我们一般选择 ocs-storagecluster-ceph-rbd（块存储）。

2、创建数据库 PVC（PostgreSQL 示例）

# postgresql-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pgdata
  namespace: myapp
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: ocs-storagecluster-ceph-rbd

3 、部署 PostgreSQL（StatefulSet 示例）

# postgresql-deployment.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
  namespace: myapp
spec:
  serviceName: "postgres"
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:15
          ports:
            - containerPort: 5432
          env:
            - name: POSTGRES_DB
              value: mydb
            - name: POSTGRES_USER
              value: admin
            - name: POSTGRES_PASSWORD
              value: secret
          volumeMounts:
            - name: pgdata
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
    - metadata:
        name: pgdata
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi
        storageClassName: ocs-storagecluster-ceph-rbd

4、部署并验证

oc new-project myapp
oc apply -f postgresql-deployment.yaml

 然后验证 PVC 是否绑定成功：

oc get pvc -n myapp

输出应该类似：

NAME     STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS                     AGE
pgdata   Bound    pvc-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx   10Gi       RWO            ocs-storagecluster-ceph-rbd      1m

5、说明

• OCS 使用的 Ceph RBD 提供高性能、可扩展的块存储，非常适合数据库使用；

• 自动支持故障恢复，节点/Pod 迁移时可自动重挂载；

• 支持加密、QoS 配置等高级功能（可通过 StorageClass 参数配置）； 

如果使用 Helm Chart 部署数据库（如 Bitnami PostgreSQL、MySQL），只需在 values.yaml 中将 storageClass 设置为：

primary:
  persistence:
    enabled: true
    storageClass: ocs-storagecluster-ceph-rbd
    size: 10Gi

四、MySQL示例及设置备份与还原机制

1、使用 OCS 的 PVC 部署 MySQL 示例（StatefulSet）

我们使用 OCS 提供的 块存储（RBD） 来存储 MySQL 数据。

1. 创建命名空间

oc new-project mysql-ocs

2. 创建 MySQL PVC + StatefulSet

# mysql-ocs.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
  namespace: mysql-ocs
spec:
  serviceName: "mysql"
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql:8.0
          env:
            - name: MYSQL_ROOT_PASSWORD
              value: my-secret-pw
            - name: MYSQL_DATABASE
              value: mydb
            - name: MYSQL_USER
              value: myuser
            - name: MYSQL_PASSWORD
              value: mypass
          ports:
            - containerPort: 3306
              name: mysql
          volumeMounts:
            - name: mysql-data
              mountPath: /var/lib/mysql
  volumeClaimTemplates:
    - metadata:
        name: mysql-data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi
        storageClassName: ocs-storagecluster-ceph-rbd

oc apply -f mysql-ocs.yaml

创建完成后可通过 port-forward 或 Service 暴露端口连接数据库：

oc port-forward statefulset/mysql 3306:3306 -n mysql-ocs

2、MySQL 备份与还原机制（结合 OCS 对象存储）

我们可以用 mysqldump 将数据库导出，然后将其上传到 OCS 提供的 S3 对象存储（NooBaa）中做备份。

1. 创建 ObjectBucketClaim（如之前的示例）

# mysql-backup-obc.yaml
apiVersion: objectbucket.io/v1alpha1
kind: ObjectBucketClaim
metadata:
  name: mysql-backup
  namespace: mysql-ocs
spec:
  generateBucketName: mysql-backup-
  storageClassName: openshift-storage.noobaa.io

oc apply -f mysql-backup-obc.yaml

查看并获取访问信息：

SECRET=$(oc get obc mysql-backup -o jsonpath='{.spec.secretName}')
oc get secret $SECRET -n mysql-ocs -o yaml

2. 使用备份脚本上传 MySQL Dump 到对象存储

假设你已经用 mysqldump 导出了一个 mydb.sql 文件：

mysqldump -h 127.0.0.1 -P 3306 -u root -p mydb > mydb.sql

 安装并配置 MinIO Client（mc）或 AWS CLI：

# 安装 awscli（如未安装）
pip install awscli

# 配置访问对象存储（用 OBC Secret 中的内容）
aws configure --profile noobaa
AWS Access Key ID: <解码后的 access_key>
AWS Secret Access Key: <解码后的 secret_key>
Default region: us-east-1
Default output: json

上传 SQL 文件：

aws --endpoint-url https://<BUCKET_HOST> --profile noobaa s3 cp mydb.sql s3://mysql-backup-xxxx/

3. 从 S3 恢复备份并导入数据库

# 下载备份
aws --endpoint-url https://<BUCKET_HOST> --profile noobaa s3 cp s3://mysql-backup-xxxx/mydb.sql .

# 导入
mysql -h 127.0.0.1 -P 3306 -u root -p mydb < mydb.sql

五、自动定时备份任务（CronJob + S3上传） 示例

1、目标

• 定时运行备份任务（比如每天凌晨 1 点）

• 使用 mysqldump 导出数据库

• 自动上传到 OCS 的对象存储（S3 兼容） 

2、准备工作

1. 获取对象存储的访问凭据（来自 OBC）

假设你已经有了如下 Secret：

oc get secret mysql-backup -n mysql-ocs -o yaml

需要：

• AWS_ACCESS_KEY_ID

• AWS_SECRET_ACCESS_KEY

• BUCKET_HOST

• BUCKET_NAME

3、创建备份 CronJob

# mysql-backup-cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: mysql-backup
  namespace: mysql-ocs
spec:
  schedule: "0 1 * * *"  # 每天凌晨1点
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: mysql-backup
              image: bitnami/mysql:8.0
              env:
                - name: MYSQL_ROOT_PASSWORD
                  value: my-secret-pw
                - name: AWS_ACCESS_KEY_ID
                  valueFrom:
                    secretKeyRef:
                      name: mysql-backup
                      key: AWS_ACCESS_KEY_ID
                - name: AWS_SECRET_ACCESS_KEY
                  valueFrom:
                    secretKeyRef:
                      name: mysql-backup
                      key: AWS_SECRET_ACCESS_KEY
                - name: BUCKET_HOST
                  valueFrom:
                    secretKeyRef:
                      name: mysql-backup
                      key: BUCKET_HOST
                - name: BUCKET_NAME
                  valueFrom:
                    secretKeyRef:
                      name: mysql-backup
                      key: BUCKET_NAME
              command:
                - /bin/sh
                - -c
                - |
                  apt update && apt install -y awscli
                  TIMESTAMP=$(date +%F-%H%M)
                  mysqldump -h mysql -uroot -p$MYSQL_ROOT_PASSWORD mydb > /tmp/mydb-$TIMESTAMP.sql
                  aws --endpoint-url https://$BUCKET_HOST s3 cp /tmp/mydb-$TIMESTAMP.sql s3://$BUCKET_NAME/
          restartPolicy: OnFailure

4、注意事项

1. 修改连接信息：

• -h mysql：应为数据库服务名称；

• mydb：要导出的数据库名；

• my-secret-pw：应与 MySQL 实际密码一致；

• 如果密码保存在 Secret 中，也可以使用 valueFrom 从 Secret 引用；

2. 安装 awscli：

我们使用 bitnami/mysql 镜像，并在脚本中安装 awscli。为了优化，你也可以：

• 用自定义镜像提前集成 awscli；

• 挂载 PVC 临时存储备份文件（目前是在容器临时目录）。 

5、部署 CronJob

oc apply -f mysql-backup-cronjob.yaml

查看执行记录：

oc get cronjob -n mysql-ocs
oc get jobs -n mysql-ocs
oc logs job/<job-name> -n mysql-ocs

6、还原数据（人工触发）

可手动下载：

aws --endpoint-url https://<BUCKET_HOST> --profile noobaa s3 cp s3://mysql-backup-xxxx/mydb-2025-04-10-0100.sql .
mysql -h 127.0.0.1 -u root -p mydb < mydb-2025-04-10-0100.sql

 六、增强版MySQL 自动备份系统

1、功能增强项

1. 多数据库备份：支持多个数据库定时导出；

2. 历史版本管理：备份文件带时间戳，保留多个历史版本；

3. 上传对象存储：上传到 OCS 的 NooBaa（S3 兼容）；

4. Helm Chart 封装：可参数化部署，便于多项目复用；

5. 可选支持 PVC 缓存临时备份文件；

6. 支持环境隔离、Secret 管理、资源限制配置等企业级部署需求。 

2、文件结构规划

mysql-backup-chart/
├── charts/                    # 子 chart（空）
├── templates/
│   ├── cronjob.yaml           # 核心定时任务
│   ├── secret.yaml            # 存储访问密钥（可选）
│   └── _helpers.tpl           # 模板函数（Helm 专用）
├── values.yaml                # 参数配置（如数据库列表、时间间隔等）
├── Chart.yaml                 # Helm Chart 元数据
└── README.md                  # 使用说明

3、最终成果（Helm Chart）

• 支持备份数据库：qxdb 和 gztz

• 每天定时备份，文件自动加上时间戳（如 qxdb-2025-04-10.sql）

• 自动上传到指定 OCS（NooBaa）桶（使用固定前缀）

• 自动清理 7 天前的备份（S3上删除）

• 使用自定义镜像（内置 awscli, mysqldump） 

现在将分步输出文件：

步骤 1：values.yaml（用户参数配置）

schedule: "0 1 * * *"  # 每天1点

mysql:
  host: mysql
  port: 3306
  rootPassword: "my-secret-pw"
  databases:
    - qxdb
    - gztz

aws:
  endpoint: https://s3-openshift.noobaa.svc
  bucket: mysql-backup-prod
  accessKey: YOUR_ACCESS_KEY
  secretKey: YOUR_SECRET_KEY
  region: us-east-1

backup:
  retentionDays: 7
  image: your-repo/mysql-backup:latest
  tempDir: /tmp/backups

步骤 2：自定义备份镜像（Dockerfile）

FROM bitnami/mysql:8.0

USER root

RUN apt update && apt install -y awscli cron && rm -rf /var/lib/apt/lists/*

ENTRYPOINT [ "/bin/bash" ]

 可以构建这个镜像并推送到自己的仓库：

docker build -t your-repo/mysql-backup:latest .
docker push your-repo/mysql-backup:latest

步骤 3：templates/cronjob.yaml

apiVersion: batch/v1
kind: CronJob
metadata:
  name: {{ include "mysql-backup.fullname" . }}
spec:
  schedule: "{{ .Values.schedule }}"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: mysql-backup
              image: {{ .Values.backup.image }}
              env:
                - name: MYSQL_ROOT_PASSWORD
                  value: {{ .Values.mysql.rootPassword }}
                - name: AWS_ACCESS_KEY_ID
                  value: {{ .Values.aws.accessKey }}
                - name: AWS_SECRET_ACCESS_KEY
                  value: {{ .Values.aws.secretKey }}
                - name: AWS_DEFAULT_REGION
                  value: {{ .Values.aws.region }}
              command:
                - /bin/bash
                - -c
                - |
                  mkdir -p {{ .Values.backup.tempDir }}
                  for DB in {{ join " " .Values.mysql.databases }}; do
                    FNAME="$DB-$(date +%F-%H%M).sql"
                    mysqldump -h {{ .Values.mysql.host }} -P {{ .Values.mysql.port }} -uroot -p$MYSQL_ROOT_PASSWORD $DB > {{ .Values.backup.tempDir }}/$FNAME
                    aws --endpoint-url {{ .Values.aws.endpoint }} s3 cp {{ .Values.backup.tempDir }}/$FNAME s3://{{ .Values.aws.bucket }}/
                  done

                  # 自动清理 7 天前备份
                  aws --endpoint-url {{ .Values.aws.endpoint }} s3 ls s3://{{ .Values.aws.bucket }}/ | while read -r line; do
                    FILE_DATE=$(echo $line | awk '{print $1}')
                    FILE_NAME=$(echo $line | awk '{print $4}')
                    if [ -n "$FILE_NAME" ]; then
                      FILE_TIMESTAMP=$(date -d "$FILE_DATE" +%s)
                      NOW=$(date +%s)
                      AGE=$(( (NOW - FILE_TIMESTAMP) / 86400 ))
                      if [ "$AGE" -ge {{ .Values.backup.retentionDays }} ]; then
                        echo "Deleting $FILE_NAME (age: $AGE days)"
                        aws --endpoint-url {{ .Values.aws.endpoint }} s3 rm s3://{{ .Values.aws.bucket }}/$FILE_NAME
                      fi
                    fi
                  done
          restartPolicy: OnFailure

步骤 4：Chart 元数据 + 辅助模板

Chart.yaml：

apiVersion: v2
name: mysql-backup
description: MySQL 自动备份 + OCS 上传 Helm Chart
version: 0.1.0

 templates/_helpers.tpl：

{{- define "mysql-backup.fullname" -}}
{{- printf "%s-mysql-backup" .Release.Name -}}
{{- end -}}

步骤 5：README.md 说明（简略）

# MySQL 自动备份 Helm Chart

## 功能
- 支持多个数据库
- 自动上传到 OCS (NooBaa)
- 支持自动清理历史版本

## 安装

```bash
helm install mysql-backup ./mysql-backup-chart -n mysql-ocs

卸载

helm uninstall mysql-backup -n mysql-ocs

七、 S3 SDK调用示例

使用 Python 的 boto3 SDK 调用 S3（兼容 OCS/NooBaa） 示例，可用于列出、上传、下载、删除对象。

1、环境准备

安装依赖：

pip install boto3

2 、配置连接参数（兼容 NooBaa）

import boto3
from botocore.client import Config

# 配置参数（替换成你的实际值）
s3 = boto3.client(
    's3',
    aws_access_key_id='YOUR_ACCESS_KEY',
    aws_secret_access_key='YOUR_SECRET_KEY',
    endpoint_url='https://s3-openshift.noobaa.svc',  # NooBaa S3 endpoint
    config=Config(signature_version='s3v4'),
    region_name='us-east-1'  # NooBaa 通常不限制区域
)

3、S3 操作示例

1. 列出 Bucket 中的文件

response = s3.list_objects_v2(Bucket='mysql-backup-prod')
for obj in response.get('Contents', []):
    print(obj['Key'], obj['LastModified'])

2. 上传文件到 S3

s3.upload_file('localfile.sql', 'mysql-backup-prod', 'qxdb-2025-04-10.sql')

3. 下载文件从 S3 

s3.download_file('mysql-backup-prod', 'qxdb-2025-04-10.sql', 'downloaded.sql')

4. 删除指定文件

s3.delete_object(Bucket='mysql-backup-prod', Key='qxdb-2025-04-01.sql')

5. 清理 7 天前的备份文件（自动计算） 

import datetime

seven_days_ago = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=7)

response = s3.list_objects_v2(Bucket='mysql-backup-prod')
for obj in response.get('Contents', []):
    if obj['LastModified'] < seven_days_ago:
        print("Deleting:", obj['Key'])
        s3.delete_object(Bucket='mysql-backup-prod', Key=obj['Key'])

 这个脚本可以直接作为 自动清理脚本 运行在备份容器里或另一个维护 Job 中。

4、S3 自动清理任务（Python + CronJob）

1.镜像设计（附带 boto3 + python3）

可以基于以下 Dockerfile 构建清理用容器镜像：

FROM python:3.10-slim

RUN pip install boto3

COPY cleanup.py /app/cleanup.py

ENTRYPOINT ["python", "/app/cleanup.py"]

2.Python 脚本 cleanup.py

import boto3
from botocore.client import Config
import datetime
import os

access_key = os.getenv("AWS_ACCESS_KEY_ID")
secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
endpoint = os.getenv("S3_ENDPOINT")
region = os.getenv("AWS_REGION")
bucket = os.getenv("S3_BUCKET")
retention_days = int(os.getenv("RETENTION_DAYS", "7"))

s3 = boto3.client(
    's3',
    aws_access_key_id=access_key,
    aws_secret_access_key=secret_key,
    endpoint_url=endpoint,
    config=Config(signature_version='s3v4'),
    region_name=region
)

cutoff = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=retention_days)

response = s3.list_objects_v2(Bucket=bucket)
for obj in response.get('Contents', []):
    if obj['LastModified'] < cutoff:
        print(f"Deleting {obj['Key']} (LastModified: {obj['LastModified']})")
        s3.delete_object(Bucket=bucket, Key=obj['Key'])

3.Helm Chart 中新增 CronJob（templates/s3-cleaner.yaml） 

apiVersion: batch/v1
kind: CronJob
metadata:
  name: {{ include "mysql-backup.fullname" . }}-s3cleaner
spec:
  schedule: "0 2 * * *"  # 每天凌晨2点执行
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: s3-cleaner
              image: your-repo/s3-cleaner:latest
              env:
                - name: AWS_ACCESS_KEY_ID
                  value: {{ .Values.aws.accessKey }}
                - name: AWS_SECRET_ACCESS_KEY
                  value: {{ .Values.aws.secretKey }}
                - name: AWS_REGION
                  value: {{ .Values.aws.region }}
                - name: S3_ENDPOINT
                  value: {{ .Values.aws.endpoint }}
                - name: S3_BUCKET
                  value: {{ .Values.aws.bucket }}
                - name: RETENTION_DAYS
                  value: "{{ .Values.backup.retentionDays }}"
          restartPolicy: OnFailure

4.补充说明

需要：

• 构建并推送清理镜像：

docker build -t your-repo/s3-cleaner:latest .
docker push your-repo/s3-cleaner:latest

• 在 values.yaml 中补充：

cleanup:
  enabled: true
  image: your-repo/s3-cleaner:latest

•  在模板中添加 if .Values.cleanup.enabled 判断逻辑（可选）