13.1.1 Pipeline Image Workflow

Pipeline image workflow describes the complete sequence of steps a CI/CD pipeline typically follows for a containerized application — checking out source code, building the image, running tests, tagging, pushing to a registry, and triggering deployment — each step depending on the successful completion of the one before it.

The Complete Sequence

Each stage of the pipeline builds on the previous one's output, forming a coherent, dependent sequence.

jobs:
  pipeline:
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t myapp:${{ github.sha }} .
      - run: docker run --rm myapp:${{ github.sha }} npm test
      - run: docker tag myapp:${{ github.sha }} registry.example.com/myapp:${{ github.sha }}
      - run: docker push registry.example.com/myapp:${{ github.sha }}
      - run: ./deploy.sh registry.example.com/myapp:${{ github.sha }}

This single, complete sequence checks out code, builds an image, tests it, tags it appropriately for the registry, pushes it, and triggers a deployment using that specific, now-published image.

Why Each Step Should Only Proceed if the Previous One Succeeded

A failure at any stage — a failing test, an unsuccessful push — should halt the pipeline, preventing a broken or unverified image from being deployed.

jobs:
  build:
    runs-on: ubuntu-latest
  test:
    needs: build
  push:
    needs: test
  deploy:
    needs: push

This explicit dependency chain ensures deployment only happens after every preceding stage has actually succeeded.

Why Breaking This Into Distinct, Visible Stages Improves Troubleshooting

Clearly separated pipeline stages make it immediately apparent exactly where a failure occurred, considerably easier to diagnose than a single, undifferentiated script attempting everything at once.

docker run --rm myapp:abc123 npm test

Reproducing a specific failing stage locally, using the exact image and command from that stage, aids in diagnosing the actual cause.

Why Pipeline Image Workflow Matters

A clear, well-structured sequence of distinct pipeline stages, each gated on the success of the one before it, produces a reliable, troubleshoot-able process for getting a containerized application from source code to a deployed, running state.