如何在 Kubernetes 上设置 Argo 工作流程？

随着容器化技术的流行，Kubernetes成为了容器编排和管理的事实标准。而在Kubernetes上运行工作流程是一项关键的任务，Argo工作流程（Argo Workflows）为此提供了强大的解决方案。

Argo 工作流程基础

在开始之前，请确保你已经安装了Kubernetes集群，并且拥有kubectl命令行工具的访问权限。同时，我们还需要在Kubernetes集群中安装Argo工作流程的控制器。

1. 安装 Argo 工作流程控制器

首先，我们需要使用kubectl安装Argo工作流程控制器。执行以下命令：

kubectl create namespace argo
kubectl apply -n argo -f https://raw.githubusercontent.com/argoproj/argo-workflows/stable/manifests/install.yaml

这将在名为argo的命名空间中安装Argo工作流程控制器。确认控制器的Pod已经正常运行：

kubectl get pods -n argo

2. 创建第一个简单的工作流程

接下来，我们将创建一个简单的Argo工作流程以了解其基本结构。创建一个名为hello-world.yaml的文件，内容如下：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: hello-world-
spec:
  entrypoint: whalesay
  templates:
  - name: whalesay
    container:
      image: docker/whalesay
      command: [cowsay]
      args: ["Hello, Argo!"]

将工作流程提交到Kubernetes集群：

kubectl apply -n argo -f hello-world.yaml

等待工作流程完成，并查看结果：

argo list -n argo
argo logs -n argo <workflow-id>

Argo 工作流程的进阶使用

1. 参数传递和输出

Argo工作流程允许在不同步骤之间传递参数，并从工作流程中提取输出。下面是一个示例工作流程，演示如何传递参数和提取输出：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: params-example-
spec:
  entrypoint: parameters-example
  templates:
  - name: parameters-example
    inputs:
      parameters:
      - name: message
    steps:
    - - name: print-message
        template: whalesay
        arguments:
          parameters:
          - name: message
            value: "{
   
   {inputs.parameters.message}}"

  - name: whalesay
    container:
      image: docker/whalesay
      command: [cowsay]
      args: ["{
   
   {inputs.parameters.message}}"]

在这个例子中，我们定义了一个名为parameters-example的工作流程，并定义了一个输入参数message。在步骤中，我们将这个参数传递给名为whalesay的模板，并在模板中使用这个参数。

kubectl apply -n argo -f params-example.yaml

等待工作流程完成，并检查输出：

argo logs -n argo <workflow-id>

2. 并行执行

Argo工作流程支持并行执行多个步骤，这在处理大规模任务时非常有用。以下是一个并行执行的例子：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: parallel-example-
spec:
  entrypoint: parallel-example
  templates:
  - name: parallel-example
    steps:
    - - name: parallel-step
        template: whalesay
        arguments:
          parameters:
          - name: message
            value: "Step 1"
    - - name: parallel-step
        template: whalesay
        arguments:
          parameters:
          - name: message
            value: "Step 2"
    - - name: parallel-step
        template: whalesay
        arguments:
          parameters:
          - name: message
            value: "Step 3"

  - name: whalesay
    container:
      image: docker/whalesay
      command: [cowsay]
      args: ["{
   
   {inputs.parameters.message}}"]

在这个例子中，我们定义了一个名为parallel-example的工作流程，其中包含三个并行执行的步骤。这些步骤将分别输出"Step 1"、"Step 2"和"Step 3"。

kubectl apply -n argo -f parallel-example.yaml

等待工作流程完成，并检查输出：

argo logs -n argo <workflow-id>

3. 持久化存储

Argo工作流程支持在不同步骤之间共享数据，这通过使用持久化卷来实现。以下是一个使用持久化存储的例子：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: persistent-storage-example-
spec:
  entrypoint: persistent-storage-example
  templates:
  - name: persistent-storage-example
    steps:
    - - name: create-persistent-volume
        template: create-pv
        arguments:
          parameters:
          - name: message
            value: "Hello, Argo!"

    - - name: use-persistent-volume
        template: use-pv
        arguments:
          parameters:
          - name: message
            valueFrom:
              path: /mnt/workspace/output.txt

  - name: create-pv
    container:
      image: busybox
      command: [sh, -c]
      args: ["echo {
   
   {inputs.parameters.message}} > /mnt/workspace/output.txt"]

  - name: use-pv
    container:
      image: busybox
      command: [cat]
      args: ["/mnt/workspace/output.txt"]

在这个例子中，我们首先创建一个持久化卷，并将"Hello, Argo!"写入文件。然后，我们在另一个步骤中使用了这个持久化卷，读取文件内容并输出。

kubectl apply -n argo -f persistent-storage-example.yaml

等待工作流程完成，并检查输出：

argo logs -n argo <workflow-id>

Argo 工作流程在生产环境中的部署与管理

1. 安全性配置

在生产环境中，安全性是至关重要的一环。我们需要确保Argo工作流程的运行是安全的，并且只有授权的用户能够访问相关资源。

使用 Kubernetes 的 Role-Based Access Control（RBAC）来限制对Argo资源的访问。创建一个名为 argo-rbac.yaml 的文件，内容如下：

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: argo-role
  namespace: argo
rules:
- apiGroups: [""]
  resources: ["workflows", "workflowtemplates"]
  verbs: ["get", "list", "watch", "create", "update", "delete"]

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: argo-role-binding
  namespace: argo
subjects:
- kind: ServiceAccount
  name: default
  namespace: argo
roleRef:
  kind: Role
  name: argo-role
  apiGroup: rbac.authorization.k8s.io

这将创建一个名为 argo-role 的角色，授予对工作流程和工作流程模板的访问权限。然后，通过角色绑定将该角色与默认的ServiceAccount绑定。

kubectl apply -n argo -f argo-rbac.yaml

在生产环境中，建议启用HTTPS来加密通信。可以通过在Argo工作流程控制器的参数中配置 --secure 选项来启用HTTPS。确保配置了相应的 TLS 证书。

2. 高可用性配置

为了确保Argo工作流程的高可用性，我们可以在多个节点上运行工作流程控制器。

将Argo工作流程控制器部署到多个节点，可以使用Kubernetes的Deployment对象。创建一个名为 argo-ha.yaml 的文件，内容如下：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: argo-controller
  namespace: argo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: argo-controller
  template:
    metadata:
      labels:
        app: argo-controller
    spec:
      containers:
      - name: argo-controller
        image: argoproj/workflow-controller:v3.2.0 # 替换为实际的版本

这将创建一个名为 argo-controller 的 Deployment，其中包含3个副本。通过适当的标签选择器，确保Pods能够正确地被选中和负载均衡。

kubectl apply -n argo -f argo-ha.yaml

为了确保持久性和高可用性，可以考虑将Argo工作流程的数据库组件使用外部数据库。这可以是Kubernetes外的托管数据库服务，如Amazon RDS或Google Cloud SQL。

3. 监控与日志

在生产环境中，监控和日志记录对于追踪问题和性能调优至关重要。Argo工作流程提供了Prometheus指标和日志输出，我们可以集成它们到监控系统中。

Argo工作流程控制器会暴露Prometheus指标，我们可以使用Prometheus来收集这些指标。确保Prometheus已经在你的集群中安装并配置。

在Prometheus的配置中，添加以下作业配置：

- job_name: 'argo'
  kubernetes_sd_configs:
  - role: endpoints
  relabel_configs:
  - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_pod_name]
    action: keep
    regex: argo
  - source_labels: [__meta_kubernetes_namespace]
    action: replace
    target_label: kubernetes_namespace
  - source_labels: [__meta_kubernetes_pod_name]
    action: replace
    target_label: kubernetes_pod_name

Argo工作流程的日志可以通过kubectl或argo命令行工具来获取，但在生产环境中可能需要更为强大的日志聚合和检索系统，例如ELK Stack（Elasticsearch, Logstash, Kibana）。

集成Argo工作流程的日志到ELK Stack中，可以使用Fluentd或Filebeat来将日志数据转发到Elasticsearch。

Argo 工作流程的高级特性和最佳实践

1. 动态参数化

动态参数化允许我们在运行时根据条件来选择参数值。这对于处理不同环境、不同数据源或根据上一步骤的输出动态生成参数等情况非常有用。以下是一个动态参数化的示例：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: dynamic-params-example-
spec:
  entrypoint: dynamic-params-example
  templates:
  - name: dynamic-params-example
    inputs:
      parameters:
      - name: environment
        value: "dev"
    steps:
    - - name: select-param-value
        template: select-param
        arguments:
          parameters:
          - name: environment
            value: "{
   
   {inputs.parameters.environment}}"

  - name: select-param
    inputs:
      parameters:
      - name: environment
    outputs:
      parameters:
      - name: paramValue
        value: "{
   
   {if eq (inputs.parameters.environment) 'dev' }}dev-value{
   
   { else }}prod-value{
   
   { end }}"
    script:
      image: alpine
      command: [sh]
      source: |
      echo "paramValue={
   
   {outputs.parameters.paramValue}}"

在这个例子中，我们根据输入的environment参数的值，在 select-param 步骤中动态选择参数值。

kubectl apply -n argo -f dynamic-params-example.yaml

2. 外部依赖与初始化容器

在一些场景中，工作流程可能需要依赖外部系统或服务。Argo工作流程允许通过初始化容器（initContainer）来满足这些外部依赖。以下是一个使用初始化容器的示例：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: init-container-example-
spec:
  entrypoint: init-container-example
  templates:
  - name: init-container-example
    initContainers:
    - name: init-setup
      image: busybox
      command: ['sh', '-c', 'echo "Initialize external dependencies"']
    container:
      image: alpine
      command: ['sh']
      source: |
        echo "Running the main container"

在这个例子中，init-setup 初始化容器用于初始化外部依赖，然后主容器运行实际的工作负载。

kubectl apply -n argo -f init-container-example.yaml

3. 子工作流程与循环

Argo工作流程允许我们使用子工作流程来组织和复用工作流程的组件。同时，循环结构也是一种强大的工具，用于处理需要重复执行的任务。以下是一个子工作流程和循环的示例：

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: subworkflow-loop-example-
spec:
  entrypoint: subworkflow-loop-example
  templates:
  - name: subworkflow-loop-example
    steps:
    - - name: loop
        withItems:
        - "item-1"
        - "item-2"
        template: subworkflow
        arguments:
          parameters:
          - name: item
            value: "{
   
   {item}}"

  - name: subworkflow
    inputs:
      parameters:
      - name: item
    steps:
    - - name: print-item
        template: whalesay
        arguments:
          parameters:
          - name: message
            value: "{
   
   {inputs.parameters.item}}"

  - name: whalesay
    container:
      image: docker/whalesay
      command: [cowsay]
      args: ["{
   
   {inputs.parameters.message}}"]

在这个例子中，subworkflow-loop-example 工作流程包含一个循环结构，遍历两个项目并调用 subworkflow 子工作流程。

kubectl apply -n argo -f subworkflow-loop-example.yaml