Generic

Overview

Generic artifacts extend Bluebricks orchestration beyond native IaC tools. Using a Generic artifact allows you to package custom logic — scripts, executables, or automation flows — into reusable Docker-based units that can be executed as part of a deployment pipeline.

Unlike Terraform or Helm artifacts, which rely on native infrastructure code, generic artifacts run inside containers you define, allowing you to integrate non-IaC workflows such as validations, API calls, security scans, or provisioning tasks written in any language.

When to Use a Generic Artifact

Use a Generic Artifact when you need to:

• Run custom scripts or binaries (e.g., bash, Python, Go, Node)

• Perform pre/post-deployment actions (e.g., notify, validate, transform)

• Integrate third-party tools (e.g., Pulumi, Ansible, internal CLIs)

• Execute custom logic that doesn’t fit into Terraform, OpenTofu, or Helm

Package Dependencies and Data Flow

Packages expose inputs (properties) and outputs, enabling them to participate in flexible, modular dependency chains orchestrated through a directed acyclic graph (DAG).

Inputs define the parameters a package requires and can be statically defined or dynamically derived using expressions that reference other packages, blueprint properties, or secrets. These expressions create explicit dependencies between packages, allowing the orchestrator to determine the correct execution order. Inputs also support conditional expressions, enabling packages to be included or excluded based on runtime context.

Outputs represent values produced during package execution—such as resource identifiers, endpoints, or computed configurations—and become available for consumption by downstream packages. This creates a bidirectional dependency flow where packages can safely reference one another’s results.

This design enables unified orchestration across multiple infrastructure-as-code technologies—Terraform, Helm, Bicep, and CloudFormation can coexist within a single blueprint, sharing data and dependencies seamlessly. The orchestrator provides a single plan, single execution flow, and unified state management regardless of the underlying IaC tool. Packages can be sourced from artifacts or directly from Git repositories, allowing complex systems to be built from small, reusable, independently versionable units. The dependency graph is calculated at plan time, ensuring deterministic execution order and enabling parallel execution where dependencies allow.