🐳 Using PowerShell to Run Scripts When a Linux Docker Container Stops

Docker is now a staple for deploying containerized applications, and PowerShell has grown into a versatile, cross-platform automation solution. Although running PowerShell on Linux may seem unusual at first, it’s a standard practice in modern DevOps — thanks to the introduction of PowerShell Core (pwsh).

Contents

🐳 Using PowerShell to Run Scripts When a Linux Docker Container Stops 🔍 Why Execute Scripts on Container Stop?📦 Docker Container Lifecycle Basics ⚙️ PowerShell on Linux 🧭 Overview of Strategies ✅ Method 1: Docker Events Listener Step 1: Create the PowerShell Script Step 2: Create a Bash Event Listener Step 3: Run in Background ✅ Method 2: Entrypoint Trap Inside Dockerfile Dockerfile Example entrypoint.sh Example ✅ Method 3: External Watcher Script 🛠️ Practical Use Cases 🔒 Security Best Practices 🪛 Debugging Tips ✅ Summary

This tutorial walks you through how to automatically trigger a PowerShell script when a Docker container stops on a Linux system — a technique commonly used for log handling, resource cleanup, sending alerts, or initiating CI/CD operations.

🔍 Why Execute Scripts on Container Stop?

Triggering actions when a container stops is helpful for:

🧹 Cleaning up temporary files or system resources
🗂️ Backing up logs or application data
📣 Sending alerts via email, webhook, or messaging services
🚀 Kicking off downstream workflows or shutdown routines
📋 Capturing audit information

In traditional scripting, Linux uses signals like SIGTERM with trap. Docker, however, offers more advanced event handling, and with PowerShell Core, it becomes even more powerful.

📦 Docker Container Lifecycle Basics

Docker containers move through these states:

Created
Running
Paused
Stopped
Dead

The key moment for script execution is during the transition from Running to Exited, which can be caused by:

Manual docker stop
App crashing or exiting normally
Reaching resource limits (CPU, RAM)
Host system shutdown

⚙️ PowerShell on Linux

PowerShell Core is open-source and runs natively on Linux. It can be installed via apt, yum, or snap, or included directly in Docker images.

Install Example (Ubuntu):

sudo apt update
sudo apt install -y powershell

Run PowerShell:

pwsh

Basic Script Example:

 Write-Output "Container is stopping..."
# Add custom cleanup logic here

🧰 Prerequisites

To get started, you’ll need:

Docker installed on your Linux machine
PowerShell Core (pwsh)
Basic knowledge of shell scripting
(Optional) Understanding of Docker event handling or entrypoints

🧭 Overview of Strategies

Method	Description	Best Use Case
Docker Events Listener	Monitors lifecycle events globally	Multiple containers
Entrypoint Trap	Uses signal traps inside containers	Container-specific automation
External Watcher	Monitors container status from outside	Legacy systems or custom logic

Let’s explore each.

✅ Method 1: Docker Events Listener

This method uses Docker’s event stream to listen for container stop events.

Step 1: Create the PowerShell Script

# stop-action.ps1
Write-Output "Container stopped at $(Get-Date)"
# Insert your logic here

Step 2: Create a Bash Event Listener

#!/bin/bash
docker events --filter 'event=die' --format '{{json .}}' | while read event; do
echo "Detected stop: $event"
pwsh /opt/scripts/stop-action.ps1
done

Step 3: Run in Background

chmod +x /opt/scripts/docker-listener.sh
nohup /opt/scripts/docker-listener.sh &

✅ Method 2: Entrypoint Trap Inside Dockerfile

Use signal traps in a container’s entrypoint to run a script during shutdown.

Dockerfile Example

FROM ubuntu:22.04
RUN apt update && apt install -y wget apt-transport-https software-properties-common \
&& wget -q https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb \
&& dpkg -i packages-microsoft-prod.deb \
&& apt update && apt install -y powershell \
&& rm packages-microsoft-prod.deb

COPY cleanup.ps1 /opt/cleanup.ps1
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

entrypoint.sh Example

#!/bin/bash

trap 'echo "Signal received, running PowerShell..."; pwsh /opt/cleanup.ps1' SIGTERM SIGINT

echo "Container running. Press Ctrl+C to exit."
while true; do sleep 1; done

✅ Method 3: External Watcher Script

Monitor a specific container’s status using polling.

#!/bin/bash

CONTAINER_NAME="myapp"

while true; do
STATUS=$(docker inspect -f '{{.State.Status}}' "$CONTAINER_NAME" 2>/dev/null)
if [[ "$STATUS" != "running" ]]; then
echo "Container $CONTAINER_NAME stopped."
pwsh /opt/scripts/stop-action.ps1
break
fi
sleep 2
done

🛠️ Practical Use Cases

1. Logging on Stop:

Get-Content /var/log/app.log | Out-File "/backup/app-log-$(Get-Date -Format 'yyyyMMdd-HHmmss').log"

2. Database Backup:

$timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
pg_dump -U postgres dbname | Out-File "/backups/db-backup-$timestamp.sql"

3. Send Notification:

Invoke-RestMethod -Uri "https://yourwebhook.url" -Method POST -Body (@{
message = "Container stopped at $(Get-Date)"
} | ConvertTo-Json)

🔒 Security Best Practices

Never run untrusted PowerShell scripts.
Use Microsoft’s official repositories for installation.
Apply strict file permissions to all external scripts.
Enable logging to create audit trails.

Logging Example:

Start-Transcript -Path "/var/log/container-exit.log"
# Add logic
Stop-Transcript

🪛 Debugging Tips

Test PowerShell scripts outside Docker first.
Use Write-Verbose with -Verbose flag for clarity.
Check logs using docker logs <container>.
Use volume mounts to retain logs across container runs.

✅ Summary

Method	Advantages	Drawbacks
Docker Events	Works globally	Must run externally
Entrypoint Trap	Simple and native to Docker	Works only within that container
External Watcher	Easy to implement	Polling may add delay or overhead

Using PowerShell Core alongside Docker on Linux opens up powerful automation opportunities. Whether you’re managing logs, handling shutdown events, or integrating into CI/CD pipelines, these methods let you respond automatically when containers stop.