Can AutoSys Run PowerShell Scripts?

 ## Can AutoSys Run PowerShell Scripts?

AutoSys, a job scheduling tool that automates complex workflows across multiple platforms, can be configured to execute different types of scripts, including PowerShell scripts. PowerShell is a powerful scripting language designed by Microsoft, often used to manage and automate system tasks in Windows environments.

In this article, we will explore how to configure AutoSys to run PowerShell scripts and highlight the key steps involved in creating and scheduling these jobs using AutoSys Job Information Language (JIL).

### Prerequisites

Before configuring AutoSys to run PowerShell scripts, ensure the following:

1. **AutoSys is Installed**: AutoSys should be correctly installed and configured on the server where the job will run.

2. **PowerShell is Available**: PowerShell must be installed on the target machine where the script is to be executed. Most modern Windows systems come with PowerShell pre-installed.

3. **Permissions**: The user running the AutoSys job should have the necessary permissions to execute PowerShell scripts.

### Basic Steps to Run a PowerShell Script via AutoSys

1. **Create the PowerShell Script**: 

   First, create your PowerShell script (`.ps1` file) and ensure it works as expected when run manually. For example, create a script `example.ps1` that writes "Hello World" to a file:

   ```powershell

   # example.ps1

   Write-Output "Hello World" > C:\output.txt

   ```

2. **Create a JIL File to Define the AutoSys Job**:

   Next, you will create a JIL file to define an AutoSys job that runs the PowerShell script. The JIL file specifies the job’s details, including the command to execute, the machine it will run on, and other attributes.

   Here is an example of a JIL file for running a PowerShell script:

   ```jil

   insert_job: powershell_job

   job_type: c

   machine: <target_machine>

   owner: <user>

   command: powershell -ExecutionPolicy Bypass -File C:\scripts\example.ps1

   std_out_file: C:\logs\powershell_job_output.log

   std_err_file: C:\logs\powershell_job_error.log

   alarm_if_fail: 1

   ```

   Explanation of key attributes:

   - **insert_job**: This defines the name of the job (`powershell_job` in this case).

   - **job_type**: Specifies the type of job. In this case, `c` represents a command job.

   - **machine**: Defines the machine on which the script will run. Replace `<target_machine>` with the actual machine name.

   - **owner**: The user under which the script will run. Replace `<user>` with the actual username.

   - **command**: Specifies the PowerShell command to execute. `-ExecutionPolicy Bypass` ensures that any script execution policies on the machine do not block the script, while `-File` specifies the path to the PowerShell script.

   - **std_out_file**: Defines the file where the job’s standard output will be written.

   - **std_err_file**: Defines the file where the job’s standard error output will be written.

   - **alarm_if_fail**: Raises an alarm if the job fails (`1` means alarm on failure).

3. **Load the JIL File into AutoSys**:

   Once your JIL file is ready, you need to load it into AutoSys. This can be done using the `jil` command:

   ```bash

   jil < example_job.jil

   ```

   This command loads the job into AutoSys. Once loaded, the job will be registered and ready to run according to its schedule or on-demand.

4. **Schedule and Run the Job**:

   You can schedule the job to run at specific intervals or execute it manually using the `sendevent` command:

   ```bash

   sendevent -E FORCE_STARTJOB -J powershell_job

   ```

   This will immediately trigger the job to execute the PowerShell script.

5. **Monitor the Job**:

   After the job runs, you can check the output and error logs defined in the JIL file (`powershell_job_output.log` and `powershell_job_error.log`). Use the `autorep` command to monitor the job’s status:

   ```bash

   autorep -J powershell_job

   ```

   This will display the job's current status and execution history.

### Example Use Case

Suppose you want to automate a system maintenance task, such as clearing temporary files on a Windows server. You can write a PowerShell script (`clear_temp.ps1`) to delete the temporary files and then use AutoSys to schedule it to run every night at midnight.

Here’s the PowerShell script (`clear_temp.ps1`):

```powershell

# clear_temp.ps1

Remove-Item -Path "C:\Temp\*" -Recurse -Force

```

And the corresponding JIL file to schedule this task:

```jil

insert_job: clear_temp_job

job_type: c

machine: windows_server

owner: admin_user

command: powershell -ExecutionPolicy Bypass -File C:\scripts\clear_temp.ps1

start_times: "00:00"

std_out_file: C:\logs\clear_temp_output.log

std_err_file: C:\logs\clear_temp_error.log

alarm_if_fail: 1

```

This job will delete all files in the `C:\Temp\` directory at midnight every day.

### Conclusion

AutoSys is highly flexible and can be configured to run PowerShell scripts, making it a valuable tool for automating tasks in Windows environments. By integrating AutoSys with PowerShell, you can automate a wide range of administrative tasks, from system maintenance to report generation.

Make sure to test your PowerShell script independently and ensure the AutoSys job has the necessary permissions to execute the script successfully.