How do I shut down a Linux server after running for 60 minutes?

Question

I have a server that it is normally switched off for security reasons. When I want to work on it I switch it on, execute my tasks, and shut it down again. My tasks usually take no more than 15 minutes. I would like to implement a mechanism to shut it down automatically after 60 minutes.

I've researched how to do this with cron, but I don't think it's the proper way because cron doesn't take into account when the server was last turned on. I can only set periodic patterns, but they don't take that data into account.

How could I do this implementation?

Answer 1

There are a several options.

• Provide time directly to shutdown -P:

  shutdown -P +60
  

  Note that shutdown man page also points out:

  If the time argument is used, 5 minutes before the system goes down the /run/nologin file is created to ensure that further logins shall not be allowed.

• Use at command.

• Create a systemd unit file or init script which runs shutdown -P 60 at startup.

• Use cron's @reboot to run command after boot.

  Add to (root) crontab:

  @reboot shutdown -P +60
  

For the last two methods, you could also use sleep 3600 && shutdown -P now instead of using time argument to shutdown to delay the shutdown for 60 minutes. This way logins are possible to the last moment before shutdown is issued.

Answer 2

This looks like an XY problem.

My tasks take usually no more than 15 minutes. I would like to implement a mechanism to shutdown it automatically after 60 minutes.

If you shut down after 60 minutes, you run the risk that you may be running a particularly complicated problem and just need to have more time. Many of the previous solutions would not make it easy to delay the shutdown.

If the task is not an interactive task, but instead are a scripted task that is automatically triggered from another machine, @sdkks gave a great solution for that; you really should just task the machine to run poweroff as soon as the script and all its tasks finishes.

However, if your task is an interactive task, I'd suggest to do idle detection instead.

If you do your task in a GUI (X11) you can detect the idle GUI sessions using the approach described here: Run a command when system is idle and when is active again

If you do the task through a terminal, you can detect logged in users using the who command. You can set up a cronjob that shuts the machine down if who returns an empty result. Note that this will be quite a conservative approach; it will not shut down the system if you left the console connected, but idle.

If you want to be a bit more aggressive and disconnect idle terminal sessions as well, you can combine the previous approach with automatically disconnecting idle SSH sessions ClientAliveInterval and ClientAliveCountMax. Another approach for this if you don't have SSH, but have a local terminal session, is to use the terminal idle time as returned by the w command.

Answer 3

If you execute your tasks as the same user every time, you can simply add the shutdown command, optionally with the option -P, to your profile. The number stands for the amount of minutes the shutdown command is delayed. Make sure your user has the ability to execute the shutdown command via sudo without a password.

echo "sudo shutdown -P +60" >> ~/.profile

Added:

After reading most of the other answers I love the option to add "@reboot /<path to script/command>" in (root) cron. Answer given by sebasth as his fourth option. You may either add the shutdown command or write a small script that executes the shutdown and execute that via cron. WoJ also has a great solution if you use systemd.

Answer 4

Although previous answers here all satisfy the requirement to perfection, you can also make your machine power off as soon as the tasks are done.

bash scripts can be trapped, meaning certain signals can be intercepted and certain tasks can be executed when needed. EXIT is one of the signals that can be trapped.

You would be able to:

1. Set a trap for EXIT of your automated shell scripts, meaning termination of your automated tasks
2. Set a trap for your .bashrc EXIT, meaning whenever you log out of that machine, power it off.

Option #1 would be the ideal case, provided your tasks don't require adhoc inspection and manual judgement.

Option #2 would cover the cases where you'd forget to exit the terminal without powering off. There is a caveat though; if you have multiple terminals to the same machine open and you exit from one of them, it will still power off the machine all the same. (It can be scripted to avoid that, but I won't complicate the solution.)

cleanup(){
    # Do some tasks before terminating
    echo oh la la, cleaning is so nice
    echo "See you later, world"
    sudo poweroff & # finally shutdown
}
trap cleanup EXIT

This can be at the end of .bashrc for option #2, at somewhere at the top of your script for option #1.

Why not use poweroff at the end of the script?

I prefer to use set -eo pipefail at on the top of my scripts. If any error happens, it won't silently fail; it will stop executing more commands. trap of EXIT signal should cover the cases where the script terminates prematurely due to errors.

However for your tasks, this might also mean the machine will shut down before they are completed.

I have a simple bash template I use for making scripting easier to debug; maybe it might be of some use. Please see this gist.

Answer 5

The following runs command with parameters, and if it completes successfully it will turn off the box immediately, assuming the user can run poweroff. It may need to use sudo poweroff.

command --parameters && poweroff

---

Whereas the following one simply runs poweroff immediately when the command terminates:

command --parameters ; poweroff

---

If you think the command needs rest time after completion, run

command --parameters ; sleep 3600 ; poweroff

---

If you think the command might run overtime you can constrain it to an hour:

timeout 1h command --parameters ; poweroff

timeout is part of the coreutils package so you probably already have it.

Answer 6

Elaborating on @dirkt comment, you can insert an at command on your .bashrc or .profile or whichever file your shell uses on login to schedule an automatic shutdown 60 minutes after your login.

Something like:

at now + 60 minutes -f /sbin/halt

Answer 7

If you're really concerned about security, use an mechanical outlet timer on the power source. Just set it to whatever time you want it to shutdown. This way no one can login remotely and disable the shutdown. You would need physical access.

Answer 8

Try to put the script (sudo shutdown -P 3600) in the /etc/init.d directory to run it automatically at startup.

Or try using anacron, adding the command in the /etc/anacrontab file. I also suggest to use nohup in front of the command to be sure that the command is still working after logout.

Answer 9

If you are in a systemd machine, you can use a monotonic timer

The timer unit /etc/systemd/system/shutdown_after_an_hour.timer

[Unit]
Description=shutdown after an hour

[Timer]
OnBootSec=1h

[Install]
WantedBy=timers.target

The timer unit /etc/systemd/system/shutdown_after_an_hour.service:

[Unit]
Description=shutdown after an hour

[Service]
ExecStart=/sbin/poweroff --force --no-wall
Type=oneshot

It is enabled via

# systemctl enable shutdown_after_an_hour.timer

Its status (particularly how much time is left before the shutdown) is available via

# systemctl list-timers shutdown_after_an_hour.timer

It will work on the next reboot, it is not useful to systemctl start it during the session when it is created as it will either not work (because it was not triggered during the reboot) or shut down the machine right away if past one hour. I do not know which one will happen as a matter of fact, I have never tested that specific case.

Answer 10

Leverage Your Shell's Logout File

If you only need the server for interactive or non-interactive tasks started by your UID, consider putting your shutdown commands into your ~/.bash_logout file. The GNU Bash Manual says:

When an interactive login shell exits, or a non-interactive login shell executes the exit builtin command, Bash reads and executes commands from the file ~/.bash_logout, if it exists.

So, adding "sudo poweroff" or similar to your logout file would power off the server as soon as you log out of your current session, or when a non-interactive Bash session calls exit. You could also choose to use at or pass a time-delay to shutdown if you would prefer to defer the shutdown.

For a more interactive approach to this, you might put the following Bashisms into your logout file:

# Shutdown unless N or n is pressed within 30 seconds.
shopt -s nocasematch
read -t 30 -N 1 -p 'Shutdown now? (Y/n) '
[[ "$REPLY" =~ n ]] || sudo poweroff

Caveats

There are some caveats you should keep in mind about this solution:

• This will probably work even under a terminal started by X Windows, but probably wouldn't work for an X11 session that wasn't launched by startx or similar.
• If you have non-interactive scripts that call exit, you may experience shutdowns you aren't expecting.
• Your sudoers file may prompt for a password if you haven't specified NOPASSWD for the shutdown commands, or if you haven't called sudo -v before running your shutdown command.
• There are probably other edge cases I haven't thought of yet.

In short, you might want to consider whether this approach meets your actual need, or whether a completely different approach such as monitoring for an absence of logged-in users or some other alternative is a better bet. Your mileage will definitely vary.