k8s 容器如何定时销毁

在Kubernetes（K8s）中实现容器的定时销毁，可以通过CronJob、TTLController等方式来完成。CronJob是Kubernetes中用于按计划调度的资源对象，可以在特定时间点创建Job，从而执行包括容器销毁在内的任务。TTLController则可以设置资源对象的生存时间，到期后自动删除资源。CronJob在实际应用中更为常见，因为它的时间调度功能非常灵活，可以根据业务需求精确控制任务的执行时间。

一、CRONJOB 定时销毁容器

CronJob是Kubernetes中的一种资源对象，用于在特定时间点或时间间隔执行任务。它的创建和管理相对简单，但功能强大。创建一个CronJob来定时销毁容器的步骤如下：

定义CronJob：首先需要创建一个CronJob的YAML文件，其中定义了任务的时间计划、执行的命令等。一个典型的CronJob YAML文件如下：

apiVersion: batch/v1beta1 kind: CronJob metadata: name: example-cronjob spec: schedule: "0 0 * * *" # 每天午夜执行 jobTemplate: spec: template: spec: containers: - name: example image: busybox args: - /bin/sh - -c - "echo 'Job completed'; kubectl delete pod <your-pod-name>" restartPolicy: OnFailure

在这个例子中，CronJob会每天午夜执行一次，执行的命令是删除指定的Pod。

部署CronJob：使用kubectl apply -f <your-cronjob.yaml>命令将CronJob部署到Kubernetes集群中。
监控和管理：可以使用kubectl get cronjob命令查看CronJob的状态和执行情况，确保其按计划执行。

CronJob通过定时执行任务的方式实现了容器的定时销毁，非常适合需要定期清理资源的场景。

二、TTL CONTROLLER 自动销毁资源

TTL（Time-To-Live）Controller是Kubernetes中的一种控制器，用于在资源对象达到指定生存时间后自动删除它们。它适用于需要自动清理过期资源的场景。

设置TTL：在Pod、Job等资源对象的定义中添加ttlSecondsAfterFinished字段。例如，对于一个Job，可以这样定义：

apiVersion: batch/v1 kind: Job metadata: name: example-job spec: template: spec: containers: - name: example image: busybox args: - /bin/sh - -c - "echo 'Job completed'" restartPolicy: Never ttlSecondsAfterFinished: 3600 # Job完成后1小时删除

在这个例子中，Job在完成后1小时会自动删除。

部署和监控：使用kubectl apply -f <your-job.yaml>命令将Job部署到Kubernetes集群中。可以使用kubectl get job命令查看Job的状态，确保其按预期执行和删除。

TTL Controller通过自动管理资源的生存时间，减少了手动清理的工作量，提高了资源管理的效率。

三、脚本和自动化工具

除了CronJob和TTL Controller，还可以使用脚本和自动化工具来实现容器的定时销毁。这种方法灵活性更高，可以根据具体需求进行定制。

编写脚本：可以使用Shell、Python等脚本语言编写一个定时删除容器的脚本。例如，使用Shell脚本：
```
#!/bin/bash
kubectl delete pod $(kubectl get pods -o jsonpath='{.items[?(@.metadata.creationTimestamp < "2023-01-01T00:00:00Z")].metadata.name}')
```
这个脚本会删除创建时间早于2023年1月1日的所有Pod。
设置定时任务：在Linux系统中，可以使用cron设置定时任务执行脚本。例如，编辑crontab文件：
```
crontab -e
```
添加一行定时任务：
```
0 0 * * * /path/to/your-script.sh
```
这会每天午夜执行一次脚本，删除指定条件的Pod。
集成CI/CD工具：可以将脚本集成到CI/CD工具（如Jenkins、GitLab CI）中，实现更加复杂的自动化管理。

这种方法适用于需要高度定制化的场景，但需要更多的维护和管理。

四、使用OPERATOR实现定时销毁

Operator是Kubernetes中用于封装业务逻辑和运维任务的控制器，可以实现复杂的自动化管理任务。通过编写自定义Operator，可以实现容器的定时销毁。

定义CRD（Custom Resource Definition）：首先需要定义一个自定义资源类型，用于描述需要定时销毁的对象。例如：

apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: name: timedeletejobs.example.com spec: group: example.com versions: - name: v1 served: true storage: true schema: openAPIV3Schema: type: object properties: spec: type: object properties: schedule: type: string jobTemplate: type: object properties: spec: type: object properties: containers: type: array items: type: object properties: name: type: string image: type: string args: type: array items: type: string restartPolicy: type: string

编写Operator逻辑：使用Operator框架（如Operator SDK）编写业务逻辑，处理自定义资源的创建、更新和删除。例如，监听TimeDeleteJob资源的创建，根据spec.schedule字段设置定时任务，执行spec.jobTemplate中的命令。
部署Operator：将Operator部署到Kubernetes集群中，监听自定义资源的变化。

创建自定义资源实例：创建一个TimeDeleteJob实例，定义需要定时销毁的容器。例如：

apiVersion: example.com/v1 kind: TimeDeleteJob metadata: name: example-timedeletejob spec: schedule: "0 0 * * *" jobTemplate: spec: containers: - name: example image: busybox args: - /bin/sh - -c - "echo 'Job completed'; kubectl delete pod <your-pod-name>" restartPolicy: OnFailure

Operator通过封装复杂的业务逻辑和自动化任务，实现了更加灵活和可扩展的定时销毁容器的功能。

五、结合PROMETHEUS与GRAFANA实现监控与自动化

通过结合Prometheus与Grafana，可以实现对容器的监控与自动化操作。例如，可以设置基于监控数据的自动销毁策略。

配置Prometheus监控：首先需要在Kubernetes集群中部署Prometheus，配置监控规则，收集Pod的运行数据。例如，可以配置一个监控规则，检测Pod的运行时间：

groups:
- name: example-rules
  rules:
  - alert: PodRunningTooLong
    expr: time() - kube_pod_start_time_seconds > 86400  # 运行时间超过24小时
    labels:
      severity: warning
    annotations:
      summary: "Pod {{ $labels.pod }} is running too long"
      description: "Pod {{ $labels.pod }} has been running for more than 24 hours."

设置Grafana告警：将Prometheus数据导入Grafana，设置告警规则。例如，可以设置一个告警规则，当PodRunningTooLong告警触发时，执行自动销毁操作。

自动化处理告警：可以使用Webhook或自定义脚本处理Grafana告警，执行销毁操作。例如，可以配置一个Webhook，将告警信息发送到一个处理脚本，脚本中执行kubectl delete pod命令：

import requests
import json
def handle_alert(alert):
    pod_name = alert['labels']['pod']
    # 删除Pod
    requests.post(f'http://kubernetes-api-server/api/v1/namespaces/default/pods/{pod_name}', method='DELETE')
if __name__ == '__main__':
    # 接收Grafana告警
    alert_data = json.loads(requests.get('http://grafana-webhook-endpoint').content)
    for alert in alert_data['alerts']:
        handle_alert(alert)

通过结合Prometheus与Grafana，不仅可以实现对容器的监控，还可以根据监控数据自动执行销毁操作，提高了自动化管理的效率。

六、KUBERNETES NATIVE SCHEDULER扩展

Kubernetes的调度器负责将Pod分配到合适的节点上运行。通过扩展Kubernetes原生调度器，可以实现定时销毁容器的功能。例如，可以编写一个自定义调度器插件，检测Pod的运行时间，超过指定时间后自动删除Pod。

编写调度器插件：使用Kubernetes调度器框架编写自定义调度器插件。例如，可以编写一个插件，检测Pod的运行时间，超过指定时间后自动删除Pod。
部署自定义调度器：将自定义调度器部署到Kubernetes集群中，配置调度策略。

设置调度策略：在Pod定义中指定使用自定义调度器。例如：

apiVersion: v1 kind: Pod metadata: name: example-pod labels: scheduler: custom-scheduler spec: containers: - name: example image: busybox args: - /bin/sh - -c - "echo 'Job completed'"

通过扩展Kubernetes原生调度器，可以实现更加灵活和高效的定时销毁容器的功能。

七、结合外部服务进行自动化管理

通过结合外部服务（如AWS Lambda、Google Cloud Functions），可以实现跨平台的自动化管理。例如，可以使用AWS Lambda定时触发Kubernetes API，执行容器销毁操作。

配置AWS Lambda函数：在AWS Lambda中编写一个函数，使用AWS SDK调用Kubernetes API，执行容器销毁操作。例如：

import boto3
import requests
def lambda_handler(event, context):
    # 调用Kubernetes API删除Pod
    response = requests.delete('http://kubernetes-api-server/api/v1/namespaces/default/pods/example-pod')
    return response.content

设置定时触发器：在AWS CloudWatch中配置定时触发器，每天午夜触发一次Lambda函数。
监控和管理：通过AWS CloudWatch监控Lambda函数的执行情况，确保其按预期执行。

结合外部服务可以实现跨平台的自动化管理，提高了系统的灵活性和扩展性。

八、POLICY CONTROLLER实现自动化策略

Policy Controller是Kubernetes中的一种控制器，用于管理和执行集群策略。例如，可以使用Policy Controller定义和执行容器销毁策略。

定义策略：使用OPA（Open Policy Agent）等工具定义容器销毁策略。例如，可以定义一个策略，当Pod运行时间超过24小时时自动删除：

package kubernetes.admission
deny[msg] {
    input.request.kind.kind == "Pod"
    input.request.object.metadata.creationTimestamp < time.now_ns() - 86400 * 1e9
    msg := sprintf("Pod %s is running too long", [input.request.object.metadata.name])
}

部署Policy Controller：将Policy Controller部署到Kubernetes集群中，配置策略。
监控和管理：通过OPA等工具监控策略的执行情况，确保其按预期执行。

Policy Controller通过定义和执行自动化策略，实现了容器的定时销毁，提高了集群的安全性和可靠性。

通过这些方法，可以在Kubernetes中实现容器的定时销毁，满足不同场景下的需求。无论是使用CronJob、TTL Controller，还是结合Prometheus、Grafana、外部服务、Policy Controller等，都可以实现高效的自动化管理，提高系统的稳定性和可维护性。

相关问答FAQs：

FAQs: 如何在 Kubernetes 中定时销毁容器

1. 如何使用 Kubernetes CronJob 定时销毁容器？

Kubernetes 的 CronJob 资源使得用户能够基于时间表执行任务。要定时销毁容器，可以创建一个 CronJob 来定期运行删除命令，从而实现容器的定时销毁。以下是一个基本的示例步骤：

创建 CronJob: 在 Kubernetes 中定义一个 CronJob 资源，其中包含一个运行 kubectl delete pod 命令的 Job。这个命令将删除指定的 Pod，从而销毁容器。

定义 CronJob 配置: 在 YAML 配置文件中，指定 CronJob 的时间表和 Job 的配置。以下是一个简单的 YAML 示例：

apiVersion: batch/v1
kind: CronJob
metadata:
  name: delete-container-job
spec:
  schedule: "0 2 * * *" # 每天凌晨2点运行
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: delete-container
            image: bitnami/kubectl:latest
            command:
            - /bin/sh
            - -c
            - kubectl delete pod <pod-name> --namespace=<namespace>
          restartPolicy: OnFailure

在这个配置中，schedule 字段定义了 CronJob 的执行时间，command 字段中可以填写具体的删除命令和 Pod 名称。

2. 如何使用 Kubernetes TTL 控制器定时销毁 Pod？

Kubernetes 的 TTL（Time To Live）控制器是一个用于自动删除 Pods 的工具，可以根据配置的时间自动销毁 Pod。这个控制器最适合用来管理那些在完成任务后需要自动清理的 Pods。具体的操作步骤如下：

启用 TTL 控制器: 确保你的 Kubernetes 集群支持 TTL 控制器。它通常是集成在 Kubernetes 1.21 及以后的版本中。
配置 TTL 策略: 在创建 Pod 的 YAML 配置文件中，可以设置 ttlSecondsAfterFinished 字段来定义 Pod 在完成后多长时间被自动删除。例如：
```
apiVersion: batch/v1
kind: Job
metadata:
  name: my-job
spec:
  ttlSecondsAfterFinished: 3600 # Pod 完成后 1 小时自动删除
  template:
    spec:
      containers:
      - name: my-container
        image: my-image
      restartPolicy: OnFailure
```
在这个示例中，ttlSecondsAfterFinished 设置为 3600 秒，Pod 将在完成任务后一个小时自动被销毁。

3. 如何通过 Kubernetes Operator 实现容器的定时销毁？

Kubernetes Operator 是一种控制器模式，用于管理复杂的应用程序的生命周期。如果需要更复杂的定时销毁逻辑，可以开发一个 Kubernetes Operator，以下是实现的一般步骤：

设计 Operator: 定义 Operator 的行为，比如在特定时间或者条件满足时触发销毁操作。可以使用像 Operator SDK 这样的工具来帮助创建 Operator。
开发 Operator: 编写 Operator 的代码，利用 Kubernetes API 实现定时检查和销毁容器。可以使用 Go、Python 等语言，结合相应的 Kubernetes 客户端库。
部署 Operator: 将开发好的 Operator 部署到 Kubernetes 集群中，并配置其权限，以确保它能够管理目标容器的生命周期。
定义策略: 在 Operator 中定义规则，比如基于时间间隔、事件触发等来控制容器的销毁。可以通过自定义资源定义（CRD）来描述销毁策略，并在 Operator 的逻辑中进行处理。

通过上述方法，可以灵活地实现容器的定时销毁，满足不同的需求。

关于 GitLab 的更多内容，可以查看官网文档：
官网地址： https://gitlab.cn
文档地址： https://docs.gitlab.cn
论坛地址： https://forum.gitlab.cn

原创文章，作者：xiaoxiao，如若转载，请注明出处：https://devops.gitlab.cn/archives/49563