
I have a Synology NAS at home that I use for various purposes. One of the things I do with it is run a Docker Compose
project that contains a few services.

I have a few services that I want to run on a schedule. For example, a backup service that
runs every night or a media optimizer container that takes my movie library and converts it to playback formats, that
are more suitable for older smart TVs.

In this post, I will show you how to run a Docker Compose project on a schedule using the Synology Container Manager and
the Synology Task Scheduler.

### Prerequisites

You will need to use Google Chrome or another browser that allows you to inspect Network requests.

### Getting the Docker Compose project ID

Inspecting the Network requests is the only way to retrieve the unique ID that Synology uses to identify the Docker
Compose project.

We will need this ID later, so let's first explore how to find it.

Assuming you already created a "Project" inside "Container Manager" (a project is a fancy name that DSM uses for Docker
Compose stacks). Open the "Container Manager" and navigate to the project you want to run on a schedule. If it was
already running, stop it.

Before starting it again, open the Network inspector of your browser. If you are using Chrome on a Mac, you can do this
via `Cmd + Option + I` and then click on the "Network" tab. Other browsers obviously have similar developer tools but
you need to Google a bit how to find it, if you haven't used it before.

Hit the "Clear network log" button at the left of this floating window if you want to reduce clutter. Finally, start the
project by clicking the "Start" button in the Container Manager and observe the Network requests. You should find one
that looks like this:

```
SYNO.Docker.Project
```

Open it, and inside the "Payload" tab, you will find a JSON object that contains the ID of the project. It should be
something long and random looking, for example:

```
9fb91ca5-d817-42f8-8ddc-2acdf4d94494
```

![](/images/2024/03/21/synology-cron-docker-compose/synology-get-docker-project-id.png)

Take note of this ID, because you will need it in the next step.

### Scheduling a CRON job via Synology Task Scheduler

Open the Control Panel of your Synology NAS and navigate to the "Task Scheduler" app. Click on "Create" and then "
Scheduled Task" -> "User-defined script".

Name your task based on your preferences, e.g. "Run Backup service on schedule".

In the "User" dropdown, select "root"; otherwise Synology will not have the necessary permissions to run the Docker
Compose project.

![](/images/2024/03/21/synology-cron-docker-compose/synology-user-root.png)

In the "Schedule" tab pick the schedule that suits your needs.

In the "Task Settings" tab, inside the "User-defined script" text box, paste the following script:

```bash
synowebapi --exec api=SYNO.Docker.Project method="start_stream" version=1 id="9fb91ca5-d817-42f8-8ddc-2acdf4d94494"
```

![](/images/2024/03/21/synology-cron-docker-compose/synology-run-command.png)

Note: Replace the `id` value with the ID you found in the previous step.

That's it! Synology will not start the Project based on the schedule that you provided.


Synology - Container Manager - Run a Docker Compose Project on CRON schedule


In the last few projects where I worked on, as part of teams, using the AWS CDK framework as a way to declare and
provision Infrastructure as Code, we had a common problem: the cleanup of CloudFormation stacks. We had a lot of stacks
that were created for testing, development, and production environments, and we needed to delete them. The problem was
that we had to delete them one by one, and we had to wait for the deletion of one stack to start the deletion of the
next one. This was a time-consuming task, and we needed to automate it.

In this post, I will show you how to automate the deletion of such CloudFormation stacks. We could use the AWS web based
UI to do this, but this is a time consuming and error-prone process.

After spending some time on doing this manually, I decided to build a small Go application to automate this process. It
uses the AWS SDK for Go under the hood. I've published it as an open-source project on
GitHub: [cf-purge](https://github.com/Dzhuneyt/cf-purge).

The installation instructions are already available in the repository and are dependent on the OS you are using, so we
won't be repeating them here. Instead, we will focus on how to use the tool.

I am assuming in your organization you have some sort of CI/CD that uses something like AWS CDK, SST or Terraform. I
will assume your developer environments are prefixed with the developer's name (e.g. "john-dev", "jane-dev"), and your
production environment is prefixed with "prod". This is a common pattern I've seen in many organizations.

Temporary environments can be created around short lived Git branches, like "feature-123", "bugfix-456", etc - where the
branch name can serve as the prefix for CloudFormation stacks for that environment.

This pattern is good in practice, but you can quickly end up with a lot of stale stacks that you need to delete at some
point from the AWS account:

- When testing is completed on the given Git branch, and it's ready to be merged
- When a developer leaves the company and their environment is no longer needed
- When a certain environment needs to be recreated from scratch for certain technical reasons

Using the `cf-purge` tool, you would do it in the following way:

If the environment was a temporary environment around a Git branch called "feature-123", you would run:

```bash
cf-purge --glob "feature-123-*"
```

If the environment as a dev environment for an engineer and was prefixed with "jane-dev", you would run:

```bash
cf-purge --glob "jane-dev-*"
```

After a few minutes of waiting, the stacks should be gone. The tool will also print out the names of the stacks it
deletes.


Synology - Container Manager - Run a Docker Compose Project on CRON schedule

Deletion of CloudFormation Stacks in Bulk