Turn Python checks, reports and API integrations into shared Semaphore jobs. Keep code in Git, pass reusable inputs and schedule scripts with a result for every run.
Local packages, environment values and a remembered command make a useful Python script hard to hand over or run reliably every day.
Run your schema or policy checks against configuration from Git. Stop the task with a failed exit code when validation fails, before another Workflow step changes infrastructure.
Add a validation step to a WorkflowRun your API integration script with reusable environment inputs. Schedule synchronization so the team does not have to start it by hand.
Schedule an integration jobUse your Python libraries to check endpoints and application readiness after Terraform or Ansible jobs. Keep the result with the complete operation.
Connect deployment and verificationThe template points at a script in your repository, so the code stays reviewable in Git rather than on one laptop.
Add a short run message at launch to make this execution recognizable in task history, without editing the script.
The task keeps the script's full output and exit status available after the run, ready to schedule again.
Run your Python validator first. Continue to Terraform only after validation succeeds, then use Ansible to configure the environment. Each step keeps its own output.
Validate configuration
Provision infrastructure
Configure the environment
Collect diagnosticsPython tasks use python3 on the execution environment. Install your script’s dependencies there. The Docker installation supports a requirements.txt file at /etc/semaphore/requirements.txt, installed at container startup.
Variable Groups inject environment variables for your script to read through os.environ. Keep sensitive values in secret entries rather than embedding them in source.
Semaphore keeps task status and output. Your script should return a non-zero exit code on failure. Save generated files in the storage your process owns rather than treating task logs as a file store.
Run on a prepared server or use project runners in Pro for dedicated environments. Keep the Python version, packages and access to external APIs consistent across runs.
Python tasks use python3 on the execution environment. Prepare the Python version and packages your script imports there. A Task Template selects the repository and .py path, while the server or runner provides the runtime and network access.
Prepare the required packages on the execution environment. For the Docker installation, a requirements.txt file mounted at /etc/semaphore/requirements.txt is installed at container startup. This does not create a fresh virtual environment or install repository dependencies for every task.
Attach Variable Groups to the Task Template. Their values become environment variables that Python can read through os.environ. Store sensitive values as secrets rather than in source. Validate runtime inputs before using them in API requests or file paths.
Have your script write reports to durable storage used by your process, such as an object store or a shared destination. Print a useful reference in task output. Semaphore task history retains status and logs rather than serving as a general file repository.
Yes. Use your own validation script and libraries to check configuration and return a non-zero exit code when a check fails. Put that Task Template before Terraform or Ansible in a Workflow. Semaphore coordinates the tasks rather than supplying a built-in validator.
Yes. Create a Python Task Template with its script, environment inputs and required packages, then add a schedule. Your code performs the API synchronization or report generation. Semaphore records each run and can send alerts for configured task outcomes.
Yes. Add the Python Task Template after the provisioning or configuration step in a Workflow. Use it to verify application readiness or another condition your script can inspect. The task’s exit status determines whether its configured success or failure path follows.
Yes. Python and its packages run on Semaphore’s execution environment. Teammates use the saved job through the UI or API and inspect its output. Configure project roles and template inputs so they can run the operation with the access they need.
