Argo Workflow Artifacts

• How artifact I/O works in Argo Workflows
• How to wire output artifacts to input artifacts across steps
• How to manage artifact lifecycle with garbage collection strategies

​

How artifact input/output works

• Producer step: writes a file inside its container (for example, /tmp/hello.txt), and declares it as an output artifact in the template.
• Controller action: Argo Workflows uploads that artifact to the configured artifact repository on step completion.
• Consumer step: declares an input artifact. Before the step runs, Argo downloads the artifact and places it inside the container at the path you specify (for example, /tmp/message.txt).

​

Example: a simple two-step workflow (generate → consume)

• generate-file creates /tmp/hello.txt and exposes it as an output artifact named MyGeneratedArtifact.
• consume-file receives that artifact as an input named MessageFromProducer and maps it to /tmp/message.txt.
• The main template wires the producer’s output to the consumer’s input using arguments.artifacts.from.

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  name: artifact-passing-example
spec:
  entrypoint: main
  templates:
    - name: main
      steps:
        - - name: generate-file
            template: generate-file
        - - name: consume-file
            template: consume-file
            arguments:
              artifacts:
                - name: MessageFromProducer
                  from: "{{steps.generate-file.outputs.artifacts.MyGeneratedArtifact}}"

    - name: generate-file
      script:
        image: busybox
        command: [sh, -c]
        source: |
          echo "Hello from the producer!" > /tmp/hello.txt
      outputs:
        artifacts:
          - name: MyGeneratedArtifact
            path: /tmp/hello.txt

    - name: consume-file
      inputs:
        artifacts:
          - name: MessageFromProducer
            path: /tmp/message.txt
      container:
        image: busybox
        command: [sh, -c]
        args: ["cat /tmp/message.txt"]

• generate-file writes /tmp/hello.txt and declares it as an output artifact named MyGeneratedArtifact.
• consume-file declares an input artifact MessageFromProducer mounted at /tmp/message.txt.
• The arguments.artifacts.from expression in main maps MyGeneratedArtifact from generate-file into MessageFromProducer for consume-file.
• Before consume-file starts, Argo downloads the artifact and places it at /tmp/message.txt, allowing the container to run cat /tmp/message.txt to print the file contents.

​

Artifact garbage collection (GC) — manage storage and retention

spec:
  entrypoint: main
  templates:
    - name: main
      script:
        image: busybox
        command: [sh, -c]
        source: "echo 'This file is temporary.' > /tmp/temporary-data.log"
      outputs:
        artifacts:
          - name: temp-log
            path: /tmp/temporary-data.log
            artifactGC:
              strategy: OnWorkflowCompletion

• Use a conservative workflow-level default (for example, OnWorkflowDeletion) to preserve artifacts unless explicitly discarded.
• Override individual artifact GC to OnWorkflowCompletion for ephemeral outputs that can be deleted when the workflow completes.
• Mark critical artifacts with Never to ensure long-term retention.

​

Best practices and tips

• Always configure an artifact repository before using artifact I/O. For S3-compatible storage, ensure credentials and endpoint configuration are set in the Argo artifact repository config.
• Use descriptive artifact names (for example, build-log, model-checkpoint) to make tracing outputs easier.
• Combine artifact GC policies with a retention and backup plan for production workflows that produce important outputs.
• For large files or many artifacts, consider storage costs and lifecycle rules on the remote repository (e.g., S3 lifecycle policies).

​

Links and references

• Argo Workflows Documentation
• Kubernetes Documentation: Volumes and Storage
• S3 (Amazon Simple Storage Service)
• Minio
• Google Cloud Storage (GCS)