Skip to content

Infrastructure Jobs ​

Infrastructure jobs run a workflow once on an Ordyn Runner. They are intended for build work, infrastructure administration, and other tasks that should execute once rather than once per endpoint.

Infrastructure jobs have their own library under Operations > Infrastructure Jobs. This library has an independent folder tree and contains only infrastructure-scoped jobs.

Requirements ​

Before running an infrastructure job:

  • create a Runner pool
  • enroll at least one compatible Windows or Linux Runner in the pool
  • keep the pool's Cache Node active and reachable
  • select the Runner pool in the job overview

The Runner must provide the platform and capabilities required by every Runner-backed step in the job.

Create An Infrastructure Job ​

Create a job under Operations → Infrastructure Jobs, select its Runner pool and platform, and add the required tasks. Set a timeout that covers both waiting for a Runner and execution.

Save the job, configure any job variables, and test a manual run before enabling automation.

For repository builds, enable Git source under Features. Choose a separate checkout pool when the build Runners cannot access the repository.

Use an infrastructure template to share tasks and build features across jobs.

Isolated Builds ​

Enable Isolated build under Features to restrict Linux build scripts and executables to their workspace, private home, temporary storage, and approved build tools. Select a pool with a Runner that supports isolation.

Steps share the workspace and home. Each step starts with fresh temporary storage, and its background processes stop when it finishes. Cleanup removes the private home after success, failure, or cancellation. Published outputs keep their configured retention. Isolated builds use separate cache entries.

Choose Host network for downloads, package registries, and remote services. Choose Disabled to block network access from build code. Ordyn-managed checkout and transfers remain available with either choice.

Use host execution for isolated steps. Place managed Git checkout before scripts, file imports, and cache restoration; perform later repository operations in a build script.

Execution Model ​

Each infrastructure job run has one infrastructure target and does not select endpoints.

The first Runner-backed step reserves one compatible Runner from the selected pool. That Runner executes every Runner-backed step for the complete run. Each Runner handles one reserved job target at a time.

If all compatible Runners are busy or offline, the run waits for capacity. Waiting time is part of the job's target timeout. A reserved run remains associated with the same Runner if its connection is interrupted and waits for that Runner to reconnect until the timeout expires.

Runner-backed steps share one managed host workspace for the run. Files created by one step remain available to later Runner-backed steps through:

text
ORDYN_WORKSPACE

Runner runtime fields can also use {{ job.workspace }}. Host tasks receive the host workspace path. Docker tasks mount the same workspace at the job's configured container workspace path, which defaults to /workspace; both ORDYN_WORKSPACE and {{ job.workspace }} contain the path appropriate to the current execution environment. Ordyn removes the managed workspace after the run reaches a terminal state.

Use {{ job.workspace }} in inline Runner script content, executable paths and arguments, string parameter values, job and container environment values, and stored files whose content is rendered during placement. Saved Runner script content is executed verbatim; use ORDYN_WORKSPACE in the script or pass the workspace through a string parameter.

Workspace destinations and collection patterns remain relative. Do not use {{ job.workspace }} in a Runner working directory, file-placement destination, Git checkout destination, or artifact path.

Available Tasks ​

Use the task reference for Runner scripts, workspace files, artifacts, and package publishing. Infrastructure jobs also support control flow and endpoint-job composition.

For common infrastructure workflows, see WinPE builds, Windows update preparation, and Intel ODCA trust.

Write inline content to the job workspace ​

Use Write file in an infrastructure job to create a file from inline content or a runtime reference such as {{ trigger.webhook.raw_body }}. Set a workspace-relative destination such as input/event.json. Subsequent host and Docker steps can read the file from the shared job workspace.

Content references are resolved once. Quotes, newlines and template delimiters inside the resolved value remain literal. The step supports UTF-8 or base64 content, overwrite, parent-folder creation and skipping unchanged files. Use Place file for an existing library file, package file or earlier artifact.

For a webhook consumer, write the raw body to input/event.json, then pass input/event.json as the input-file argument to your consuming command from the workspace. This avoids passing the event body through environment variables.

Place file ​

Use Place file to put a library file, package file, or earlier task artifact at a Workspace destination such as input/setup.exe. Endpoint files are unavailable in infrastructure jobs. Enable template rendering for configuration text and overwrite only when replacing existing content is intended.

Individual files and the shared workspace are limited to 100 GiB.

Sync A File Folder In The Runner Workspace ​

Sync copies a library folder's contents into the selected workspace-relative directory. For example, syncing Offline installer to input/vendor places its setup.exe at input/vendor/setup.exe.

Enable recursion for subfolders. Enable pruning only when files absent from the source should be deleted from the destination. Contents are copied unchanged; use individual file placement for template rendering. A sync supports up to 100 files and 100 GiB of input.

Build once, deploy independently ​

Publish build output to a Library file so deployment jobs can use later builds without changing their file selection.

  1. In Library → Files, choose Actions → Create file reference and name it release.zip.
  2. Create an infrastructure job that builds and tests the release, then writes dist/release.zip in its Runner workspace.
  3. Add Collect runner artifacts after those steps. Set the artifact path to dist/release.zip and select release.zip under Publish to file.
  4. Create an endpoint job with Place file using release.zip, followed by the steps that install or extract it. Run the build before starting this deployment job.

Publish Artifacts To A Software Package ​

Collect named artifacts from the Runner workspace, then map them to a package's primary installer or staged ZIP archives. The collector must be an earlier top-level step, and its artifacts must remain available until publication.

Add Extract staged install archive to the package workflow when endpoints need the ZIP's contents. Publication supports up to 100 mappings; each ZIP can contain up to one million entries and 100 GiB of expanded content. Packages generated from Ordyn releases cannot be selected.

Changed content reapplies the product's package-approval policy. Identical content leaves approval unchanged. See package publishing for a worked workflow.

Reuse Build Caches ​

Enable Features → Build cache to reuse dependency directories between runs. Enabled caches restore before job tasks, after Git checkout when configured. Choose whether each cache publishes after success, failure, or cancellation; the default is success. Disable a cache to keep its settings without using it.

Use a key such as node-{{ vars.runtime }} to separate dependency sets by runtime version. Inspect stored caches from the job's Caches tab. Select one or more variants and open the context menu to clear the selected variants or all variants of their cache names. Clearing a name includes variants outside the current view. Active readers can finish; runs already started cannot republish the cleared cache.

Enable Serialized access when overlapping runs must restore the preceding run’s published cache. Set Acquisition wait timeout to allow longer waits; it defaults to 30 minutes and is shared by all caches. Waiting consumes the job timeout and keeps the Runner reserved, so leave enough job time for the wait and the work. A longer acquisition wait does not extend the 30-minute restore-transfer or publication windows. If acquisition expires, the waiting run fails while the owner continues.

HTML reports ​

Publish a self-contained HTML report as a named tab in a run. Your administrator must first enable the isolated reports domain.

  1. Generate the report and its assets in the Runner workspace.
  2. Add Collect runner artifacts to collect the report directory or an existing ZIP archive.
  3. Enable Features → HTML reports and add a report. Select its collection step and named artifact, then set the entry page to the HTML file's path inside the ZIP.

Directory collection preserves workspace-relative paths. For a report generated at reports/coverage/index.html, collect reports/coverage and use reports/coverage/index.html as the entry page.

Bundle the report's scripts, styles, images and data, and use relative resource links. External resources and API calls are blocked.

Enable Required report when a missing or invalid report should fail an otherwise successful run. Leave it optional when some runs do not produce a report. Put the collector in Cleanup to collect reports after failed or cancelled work.

Open the named tab in the job's run details or Reporting → Job Runs.

Start A Run Manually ​

Open the infrastructure job and select Run job. Enter any prompted variable values and confirm the selected Runner pool to create one run. Leave a field untouched to use its effective inherited or job-level value.

Jobs with a Git source also let you select a branch or pull-request ref for this run.

The job validity windows apply to manual and automatic starts. A run that has already started continues when its start window closes.

Automations ​

Use the job's Automations tab for schedules, completion follow-ups, Git changes, webhooks, or Windows update approval triggers. See Automations for their behavior.

Monitor Runs ​

For Git builds, the Runs table shows each run's recorded branch or ref. Use it to distinguish concurrent builds and identify historical builds even after the job's Git configuration changes.

Open Parameters in a run to search its recorded values, types, and sources. These values describe that execution, including when the job's configuration has changed; secret values remain redacted.

The run header shows elapsed wall-clock time and the recorded branch or ref for Git builds. Elapsed time includes waits and Cleanup between the recorded start and completion times. These details are also available through Reporting → Job Runs.

Open a run to follow its journal, inspect a failed step, or download collected artifacts. When a step calls an endpoint job, follow its child run to investigate individual devices.

Expand a step in Output to inspect its log. Type in Search output to filter messages, and combine the search with the step and message filters. Heading timestamps show when execution started; a blank timestamp means no start time is available. Scroll through long output to load more entries. Use Step start, Run start, or Latest to move directly to the relevant part of the run.

For repository builds, open Changes to inspect Git source and changes and identify the exact commit and changes since the comparison build.

Use Test reports to collect JUnit XML or publish TeamCity test messages. The run's Tests tab shows results and failure details, with the original XML retained as artifacts.

Runner steps stream stdout and stderr to the run log. Docker steps also show system entries for preparation, execution, and cleanup timings. The step remains active until output capture, temporary credential cleanup, and configured workspace ownership restoration finish.

Capture notices identify interruptions to captured output. They do not themselves mean the task failed; check the task result.

Captured output can be truncated. Write large diagnostics to files and collect artifacts when complete output is needed. Secrets are redacted from ordinary output, but scripts must still avoid disclosing transformed secrets or sensitive files.

Completed infrastructure runs are retained for 90 days by default. Set jobs.infrastructure_run_retention_days to change retention; zero disables age-based removal. See Artifact retention for how run cleanup affects collected content.

Use Job Runs for cross-job investigation.

Abort A Run ​

Use Abort job run from an active infrastructure run. See Job Runs for cancellation and Cleanup guidance.

Job Settings ​

Review the Runner pool, platform, workspace location, timeout, and validity windows for the job's operational needs. Endpoint-specific settings belong to endpoint jobs.

Roles ​

Combine Job Designer for authoring or Job Operator for execution with Service Operator for Runner work. Platform Admin also supports these workflows.