Result Types

Reference for Tekton result types and usage

Results allow Tasks and Pipelines to output values that can be used by subsequent Tasks or surfaced to users.

TaskResult

Defines a result produced by a Task.

name · string · required

Name of the result.

Must be a valid identifier.

type · ResultsType · default: "string"

Type of the result.

Values:

• string - Single string value
• array - Array of strings
• object - Key-value pairs

description · string

Human-readable description of the result.

properties · map[string]PropertySpec

For object-type results, defines the structure of keys.

Show PropertySpec

type · ResultsType

Type of the property.

value · ResultValue

Expression to retrieve the result value from a Step.

Example: $(steps.stepName.results.resultName)

StepResult

Defines a result produced by a Step.

name · string · required

Name of the step result.

type · ResultsType · default: "string"

Type of the result: string, array, or object.

description · string

Description of the result.

properties · map[string]PropertySpec

For object results, property definitions.

TaskRunResult

Represents the actual result value in a TaskRun status.

name · string

Name of the result.

type · ResultsType

Type of the result.

value · ResultValue

The actual value produced.

Can be string, array, or object depending on type.

PipelineResult

Defines a result produced by a Pipeline.

name · string · required

Name of the pipeline result.

type · ResultsType · default: "string"

Type of the result.

description · string

Description of the result.

value · ResultValue · required

Expression referencing a task result.

Example: $(tasks.taskName.results.resultName)

Writing Results

Results are written to files in the container filesystem:

String Results

steps:
  - name: generate-version
    image: bash
    script: |
      #!/usr/bin/env bash
      echo -n "1.2.3" > $(results.version.path)
results:
  - name: version
    description: The generated version

Array Results

steps:
  - name: list-files
    image: bash
    script: |
      #!/usr/bin/env bash
      ls -1 | jq -R -s -c 'split("\n")[:-1]' > $(results.files.path)
results:
  - name: files
    type: array
    description: List of files

Object Results

steps:
  - name: get-metadata
    image: bash
    script: |
      #!/usr/bin/env bash
      echo -n '{"commit":"abc123","author":"user"}' > $(results.metadata.path)
results:
  - name: metadata
    type: object
    properties:
      commit:
        type: string
      author:
        type: string

Reading Results

In Subsequent Tasks

Reference results from previous tasks:

tasks:
  - name: get-version
    taskRef:
      name: version-task
  - name: build
    taskRef:
      name: build-task
    params:
      - name: version
        value: $(tasks.get-version.results.version)
    runAfter:
      - get-version

In Pipeline Results

Surface task results as pipeline results:

apiVersion: tekton.dev/v1
kind: Pipeline
spec:
  tasks:
    - name: build
      taskRef:
        name: build-image
  results:
    - name: image-digest
      description: Digest of the built image
      value: $(tasks.build.results.digest)

In Finally Tasks

Finally tasks can access results from DAG tasks:

finally:
  - name: report
    taskRef:
      name: send-notification
    params:
      - name: version
        value: $(tasks.build.results.version)

Result Size Limits

Results have size limits:

• String results: 4096 bytes (4 KB) by default
• Array/Object results: Configured per installation

Results exceeding limits cause task failure with reason TaskRunResultLargerThanAllowedLimit.

Step Results

Steps can produce results that tasks aggregate:

steps:
  - name: step-one
    image: bash
    script: |
      echo -n "value1" > $(step.results.output.path)
    results:
      - name: output
  - name: step-two
    image: bash
    script: |
      echo -n "value2" > $(step.results.output.path)
    results:
      - name: output
  - name: combine
    image: bash
    script: |
      echo "$(steps.step-one.results.output),$(steps.step-two.results.output)" \
        > $(results.combined.path)
results:
  - name: combined
    description: Combined output from both steps

Example: Complete Task with Results

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: git-info
spec:
  params:
    - name: url
      type: string
  results:
    - name: commit
      type: string
      description: The current commit SHA
    - name: branch
      type: string
      description: The current branch
    - name: metadata
      type: object
      description: Git metadata
      properties:
        author:
          type: string
        date:
          type: string
  steps:
    - name: get-info
      image: alpine/git
      script: |
        #!/bin/sh
        git clone $(params.url) repo
        cd repo
        
        # Write string results
        git rev-parse HEAD > $(results.commit.path)
        git rev-parse --abbrev-ref HEAD > $(results.branch.path)
        
        # Write object result
        echo -n "{\"author\":\"$(git log -1 --format='%an')\"," \
          "\"date\":\"$(git log -1 --format='%ai')\"}" \
          > $(results.metadata.path)

Best Practices

1. Keep results small - Use results for metadata, not large data
2. Use descriptive names - Make result purpose clear
3. Document result format - Describe expected structure
4. Validate result content - Check that written values are valid
5. Use appropriate types - Choose string/array/object based on data
6. Write atomically - Write complete result value in one operation