Configure dynamic pipelines with parameters

Parameters in Ascend provide a powerful mechanism for dynamically configuring your data Flows and Components. Rather than hardcoding values, parameters allow you to create flexible, reusable, and maintainable data pipelines that can adapt to different environments and scenarios.

What you'll learn

In this tutorial, you'll learn:

• How parameters work within the Ascend platform
• The hierarchy and precedence of Parameter settings
• How to define and use parameters in various Component types
• Best practices for securely managing parameters
• Common Parameter use cases and examples

Hierarchy of parameters

parameters can be set at multiple levels in Ascend, with more specific settings overriding more general ones:

1. Flow run parameters (highest priority)

   • Applied to a specific execution of a Flow
   • Ideal for one-time configuration changes

2. Flow parameters

   • Defined within a Flow definition
   • Apply to all runs of that Flow unless overridden

3. Profile parameters

   • Defined in Profiles to be used across multiple Flows
   • Great for Environment-specific configurations

4. Project parameters (lowest priority)

   • Applied globally across your Project
   • Used for organization-wide settings

This hierarchy allows you to set default values at higher levels while providing the flexibility to override them for specific scenarios when needed.

How parameters work

Parameters in Ascend are stored in Vaults and can be referenced using the ${...} notation. This approach provides both security and convenience:

• Secure storage: Sensitive information is kept in centralized, access-controlled Vaults
• Dynamic references: Use the ${parameters.<param_name>} syntax to reference parameters
• Real-time resolution: Parameter values are resolved at runtime, allowing for flexibility

Examples

Let's explore how to use parameters in different Component types:

YAML Read Component (e.g., S3, ABFS, Database)

You can define parameters at the Flow or Component level and reference them in your YAML using ${parameters.<param_name>}:

component:
  read:
    Connection: read_gcs_lake
    gcs:
      path: ${parameters.gcs_lake_path}
      include:
        - glob: "*/month=*/day=*/*.parquet"

This allows you to easily change the input path without modifying the Component definition.

YAML Write Component

Parameters can be used for output paths, table names, or other configuration details:

component:
  write:
    Connection: write_s3
    input:
      name: my_component
      flow: my_flow
    s3:
      path: { $parameters.s3_path }
      formatter: csv
      manifest:
        name: _ascend_manifest.json

YAML Alias or External Table Component

Parameters can define locations or other properties for alias Components:

component:
  alias:
    location: "${parameters.database}.${parameters.schema}.MY_TABLE_NAME"

Python Read Component

In Python Components, parameters are accessed via context.parameters:

read_params.py

import pandas as pd
from ascend.application.context import ComponentExecutionContext
from ascend.resources import read


@read()
def read_guides(context: ComponentExecutionContext) -> pd.DataFrame:
    df = pd.read_csv(context.parameters["guides_path"])
    return df

Python Transform Component

Parameters are accessed the same way in Transforms:

transform_params.py

from ascend.resources import application_subcomponent_name, ref, test, transform


@transform(
    name=application_subcomponent_name("python_transform"),
    inputs=[
        ref("ft_all_cabs_enriched"),
    ],
    tests=[test("count_greater_than_or_equal", count=0)],
)
def python_transform(ft_all_cabs_enriched, context):
    trip_distance_threshold = context.parameters["trip_distance_threshold"]
    app_context = context.application_component_context
    vendor_id = app_context.config["parameters"]["vendor_id"]

    tb = (
        ft_all_cabs_enriched.filter((ft_all_cabs_enriched.trip_distance > trip_distance_threshold) & (ft_all_cabs_enriched.vendor_id == vendor_id))
        .mutate(tip_percentage=((ft_all_cabs_enriched.tip_amount * 100) / ft_all_cabs_enriched.fare_amount))
        .select("dropoff_zone", "pickup_zone", "tip_percentage", "pickup_datetime")
    )
    return tb

Python Task Component

Task Components also access parameters via context.parameters:

task_params.py

import ibis
from ascend.application.context import ComponentExecutionContext
from ascend.common.events import log
from ascend.resources import ref, task


@task(dependencies=[ref("top_guides")])
def task_top_guide_metrics(
    top_guides: ibis.Table,
    context: ComponentExecutionContext,
) -> None:
    # Access parameters with defaults
    min_rating = context.parameters.get("min_rating", 0)
    min_expeditions = context.parameters.get("min_expeditions", 0)

    # Filter using parameters
    filtered = top_guides.filter((top_guides["customer_rating"] >= min_rating) & (top_guides["total_expeditions_led"] >= min_expeditions))

    # Compute metrics using Ibis expressions
    metrics_expr = filtered.aggregate(
        average_customer_rating=filtered["customer_rating"].mean(),
        total_expeditions_led=filtered["total_expeditions_led"].sum(),
    )
    # Materialize the results as a pyarrow Table
    metrics_arrow = metrics_expr.to_pyarrow()
    average_customer_rating = metrics_arrow.column("average_customer_rating")[0].as_py()
    total_expeditions_led = metrics_arrow.column("total_expeditions_led")[0].as_py()

    log(f"Average Customer Rating: {average_customer_rating}")
    log(f"Total Expeditions Led: {total_expeditions_led}")

Use cases

Parameters are particularly valuable for:

1. Environment configuration

   • Different database Connections for dev, test, and production
   • Varying resource allocations based on environment needs

2. Path management

   • Dynamic input/output locations
   • Date-based or version-based path construction

3. Runtime behavior control

   • Feature flags for enabling/disabling functionality
   • Processing thresholds or limits

4. Secure credential management

   • Database credentials
   • API keys and tokens

Next steps

Now that you understand how parameters work in Ascend, you can apply this knowledge to create more flexible and reusable data pipelines.