Reputation: 25157

How to run a shell script at startup

On an Amazon S3 Linux instance, I have two scripts called start_my_app and stop_my_app which start and stop forever (which in turn runs my Node.js application). I use these scripts to manually start and stop my Node.js application. So far so good.

My problem: I also want to set it up such that start_my_app is run whenever the system boots up. I know that I need to add a file inside init.d and I know how to symlink it to the proper directory within rc.d, but I can't figure out what actually needs to go inside the file that I place in init.d. I'm thinking it should be just one line, like, start_my_app, but that hasn't been working for me.

Upvotes: 526

Answers (25)

Hemant kumar

Reputation: 5879

First create your startup script i.e. @ /home/user/startup.sh, and make it executable

chmod +x /home/user/startup.sh

Then set a crontab for it:

$ crontab -e
@reboot  /home/user/startup.sh

Now, your startup.sh script will run at every start.

Upvotes: 584

Ali Ait-Bachir

Reputation: 720

On Ubuntu 20, following this tutorial worked fine:

https://linuxconfig.org/how-to-run-script-on-startup-on-ubuntu-20-04-focal-fossa-server-desktop

First, create a Systemd service file as in an example below in /etc/systemd/system/ :

[Unit]
After=network.target

[Service]
ExecStart=/usr/local/bin/disk-space-check.sh

[Install]
WantedBy=default.target

Set appropriate permissions for both, the Systemd service unit and script:

$ sudo chmod 744 /usr/local/bin/disk-space-check.sh
$ sudo chmod 664 /etc/systemd/system/disk-space-check.service

In addition, you can specify a given user that runs the script :

    [Service]
    ExecStart=/usr/local/bin/disk-space-check.sh
    User=MyUserName

Next enable the service unit:

$ sudo systemctl daemon-reload
$ sudo systemctl enable disk-space-check.service

Then reboot

Upvotes: 0

VasiliNovikov

Reputation: 10236

Using systemd

Create a new file: sudo nano /lib/systemd/system/my-simple-service.service

[Unit]
Description=my simple service

[Service]
Type=oneshot
ExecStart=/home/user/bin/myscript

[Install]
WantedBy=multi-user.target

Enable it:

systemctl enable --now my-simple-service.service

Done. The "oneshot" parameter above means that the script will be run exactly once, at startup.

Upvotes: 1

Gilles Quénot

Reputation: 184955

A simple approach is to add a line in /etc/rc.local:

/PATH/TO/MY_APP &

Or, if you want to run the command as a special user:

su - USER_FOOBAR -c /PATH/TO/MY_APP &

(the trailing ampersand backgrounds the process and allows the rc.local file to continue executing).

Alternatively, if you want a full init.d script, Debian distros have a template file which you can copy like this:

cp /etc/init.d/skeleton /etc/init.d/your_app

...and use by adapting it a bit.

For the /etc/rc.local approach, here is an empty example /etc/rc.local file that came on older distributions of Linux Ubuntu. With one of the example commands above in it, it would look like this:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Add your cmds you want to run as sudo at every boot here.

su - USER_FOOBAR -c /PATH/TO/MY_APP &

exit 0

Upvotes: 129

Bipul Jaishwal

Reputation: 323

Solutions

Without further ado, let’s give execute permission to your script:

$ chmod +x YOUR_SCRIPT.sh

Now let’s see how to schedule its execution.

1. Using cron Let’s begin with the easiest solution, which involves using cron. In order to do this, we need to edit our crontab file:

$ crontab -e

Here we’ll add a line using the @reboot expression, which will execute our code once at startup:

@reboot sh /home/ec2-user/YOUR_SCRIPT.sh

This solution is quick and clean, since we don’t have to deal with additional configuration, but not every version of cron supports @reboot.

2. Using rc.local Now let’s consider another solution that takes advantage of the /etc/rc.d/rc.local file. Since this file already runs at startup, we can append a line that invokes our script:

sh /home/ec2-user/YOUR_SCRIPT.sh

In order for this to work, we need to ensure that the rc.local file itself is executable:

$ chmod +x /etc/rc.d/rc.local

3. Using init.d Similar to the previous solution, the /etc/init.d folder contains lifecycle executables of the services managed by the system. We can also add our own by creating an LSB-compliant wrapper that starts our service:

#! /bin/sh
# chkconfig: 345 99 10
case "$1" in
  start)
    # Executes our script
    sudo sh /home/ec2-user/YOUR_SCRIPT.sh
    ;;
  *)
    ;;
esac
exit 0

This wrapper will launch our code when it’s invoked with the start argument. However, we must include a line with the chkconfig configuration, which contains the service runlevel and the start/stop priority.

After placing the wrapper in the init.d folder, we need to register our service for startup execution:

$ chkconfig --add service_wrapper.sh

Since the chkconfig command isn’t available on Debian systems, update-rc.d can be used as an alternative there:

$ update-rc.d service_wrapper.sh defaults

Hope it helps, if yes, please upvote.

Upvotes: 1

Renan Moura

Reputation: 55

Working with Python 3 microservices or shell; using Ubuntu Server 18.04 (Bionic Beaver) or Ubuntu 19.10 (Eoan Ermine) or Ubuntu 18.10 (Cosmic Cuttlefish) I always do like these steps, and it worked always too:

Creating a microservice called p example "brain_microservice1.service" in my case:
```
$ nano /lib/systemd/system/brain_microservice1.service
```

Inside this new service that you are in:

[Unit]
Description=brain_microservice_1
After=multi-user.target

[Service]
Type=simple
ExecStart=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices    /microservice_1.py -k start -DFOREGROUND
ExecStop=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices/microservice_1.py -k graceful-stop
ExecReload=/usr/bin/python3.7 /root/scriptsPython/RUN_SERVICES/microservices/microservice_1.py -k graceful
PrivateTmp=true
LimitNOFILE=infinity
KillMode=mixed
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Give the permissions:

$ chmod -X /lib/systemd/system/brain_microservice*
$ chmod -R 775 /lib/systemd/system/brain_microservice*

Give the execution permission then:
```
$ systemctl daemon-reload
```
Enable then, this will make then always start on startup
```
$ systemctl enable brain_microservice1.service
```
Then you can test it;
```
$ sudo reboot now
```
Finish = SUCCESS!!

This can be done with the same body script to run shell, react ... database startup script ... any kind os code ... hope this help you...

...

Upvotes: 1

aerijman

Reputation: 2762

In Lubuntu I had to deal with the opposite situation. Skype start running after booting and I found in ~/.config/autostart/ the file skypeforlinux.desktop. The content of the file is as follows:

[Desktop Entry]
Name=Skype for Linux
Comment=Skype Internet Telephony
Exec=/usr/bin/skypeforlinux
Icon=skypeforlinux
Terminal=false
Type=Application
StartupNotify=false
X-GNOME-Autostart-enabled=true

Deleting this file helped me.

Upvotes: 1

akbar ali

Reputation: 25

Here is a simpler method!

First: write a shell script and save it a .sh here is an example

#!/bin/bash
Icoff='/home/akbar/keyboardONOFF/icon/Dt6hQ.png'
id=13
fconfig=".keyboard"
echo "disabled" > $fconfig
xinput float $id
notify-send -i $Icoff "Internal Keyboard disabled";

this script will disable the internal keyboard at startup.

Second: Open the application " Startup Application Preferences"

enter image description here

Third: click Add. fourth: in the NAME section give a name. fifth: In the command section browse to your .sh . sixth: edit your command section to:

bash <space> path/to/file/<filename>.sh <space> --start

seventh: click Add. Thats it! Finished!

Now confirm by rebooting your pc.

cheers!

Upvotes: 1

Mikhail Ionkin

Reputation: 617

For Debian 9 see https://askubuntu.com/questions/228304/how-do-i-run-a-script-at-start-up. It is helped me. Short version for Debian 9: add commands (as root) to /etc/rc.local

/path_to_file/filename.sh ||  exit 1   # Added by me
exit 0

Probably, /path_to_file/filename.sh should be executable (I think so).

Upvotes: 0

王子1986

Reputation: 3599

I refered to this blog, always sound a good choice

https://blog.xyzio.com/2016/06/14/setting-up-a-golang-website-to-autorun-on-ubuntu-using-systemd/

vim /lib/systemd/system/gosite.service

[Unit]
Description=A simple go website
ConditionPathExists=/home/user/bin/gosite
 
[Service]
Restart=always
RestartSec=3
ExecStart=/home/user/bin/gosite
 
[Install]
WantedBy=multi-user.target

systemctl enable gosite.service

Upvotes: 5

Dohd

Reputation: 379

Edit the rc.local file using nano or gedit editor and add your scripts in it. File path could be /etc/rc.local or /etc/rc.d/rc.local.

sudo nano /etc/rc.local

This is the edit:

#!/bin/sh
/path-to-your-script/your-scipt-name.sh

once done press ctrl+o to update, pressEnter then ctrl+x.

Make the file executable.

sudo chmod 755 /etc/rc.local

Then initiate the rc-local service to run script during boot.

sudo systemctl start rc-local

Upvotes: 13

Saule

Reputation: 589

This is the way I do it on Red Hat Linux systems.

Put your script in /etc/init.d, owned by root and executable. At the top of the script, you can give a directive for chkconfig. Example, the following script is used to start a Java application as user oracle.

The name of the script is /etc/init.d/apex

#!/bin/bash
# chkconfig: 345 99 10
# Description: auto start apex listener
#
case "$1" in
 'start')
   su - oracle -c "cd /opt/apex ; java -jar apex.war > logs/apex.log 2>logs/apex_error.log &";;
 'stop')
   echo "put something to shutdown or kill the process here";;
esac

This says that the script must run at levels 3, 4, and 5, and the priority for start/stop is 99 and 10.

Then, as user root you can use chkconfig to enable or disable the script at startup:

chkconfig --list apex
chkconfig --add apex

And you can use service start/stop apex.

Upvotes: 39

Jonathan Muller

Reputation: 7516

The file you put in /etc/init.d/ have to be set to executable with:

chmod +x /etc/init.d/start_my_app

As pointed out by @meetamit, if it still does not run you might have to create a symbolic link to the file in /etc/rc.d/

ln -s /etc/init.d/start_my_app /etc/rc.d/

Please note that on the latest versions of Debian, this will not work as your script will have to be LSB compliant (provide at least the following actions: start, stop, restart, force-reload, and status): https://wiki.debian.org/LSBInitScripts

As a note, you should always use the absolute path to files in your scripts instead of the relative one, it may solve unexpected issues:

/var/myscripts/start_my_app

Finally, make sure that you included the shebang on top of the file:

#!/bin/sh

Upvotes: 356

Ridox

Reputation: 1379

multi ways to finish it:

crontab
rc.local
init.d
systemd

Upvotes: 2

Roland

Reputation: 5226

Many answers on starting something at boot, but often you want to start it just a little later, because your script depends on e.g. networking. Use at to just add this delay, e.g.:

at now + 1 min -f /path/yourscript

You may add this in /etc/rc.local, but also in cron like:

# crontab -e
@reboot at now + 1 min -f /path/yourscript

Isn't it fun to combine cron and at? Info is in the man page man at.

As for the comments that @reboot may not be widely supported, just try it. I found out that /etc/rc.local has become obsolete on distros that support systemd, such as ubuntu and raspbian.

Upvotes: 6

SagarSave

Reputation: 29

For some people, this will work:

You could simply add the following command into System → Preferences → Startup Applications:

bash /full/path/to/your/script.sh

Upvotes: -7

Juko

Reputation: 39

Painless, easiest and the most universal method is simply executing it with ~.bash_profile or ~.profile (if you don't have bash_profile file).

Just add the execution command at the bottom of that file and it will be executed when system started.

I have this one at the bottom an example; ~\Desktop\sound_fixer.sh

Upvotes: 0

user3140639

Reputation: 529

Enter cron using sudo:

sudo crontab -e

Add a command to run upon start up, in this case a script:

@reboot sh /home/user/test.sh

Save:

Press ESC then :x to save and exit, or hit ESC then ZZ (that's shift+zz)

Test Test Test:

Run your test script without cron to make sure it actually works.
Make sure you saved your command in cron, use sudo crontab -e
Reboot the server to confirm it all works sudo @reboot

Upvotes: 38

Ciro Santilli OurBigBook.com

Reputation: 382442

Create your own /init executable

This is not what you want, but it is fun!

Just pick an arbitrary executable file, even a shell script, and boot the kernel with the command line parameter:

init=/path/to/myinit

Towards the end of boot, the Linux kernel runs the first userspace executable at the given path.

Several projects provide popular init executables used by major distros, e.g. systemd, and in most distros init will fork a bunch of processes used in normal system operation.

But we can hijack /init it to run our own minimal scripts to better understand our system.

Here is a minimal reproducible setup: https://github.com/cirosantilli/linux-kernel-module-cheat/tree/f96d4d55c9caa7c0862991025e1291c48c33e3d9/README.md#custom-init

Upvotes: 3

Kibrom Gebre

Reputation: 129

Add your script to /etc/init.d/ directory
Update your rc run-levels: $ update-rc.d myScript.sh defaults NN where NN is the order in which it should be executed. 99 for example will mean it would be run after 98 and before 100.

Upvotes: 0

shshnk

Reputation: 1681

This simple solution worked for me on an Amazon Linux instance running CentOS. Edit your /etc/rc.d/rc.local file and put the command there. It is mentioned in this file that it will be executed after all other init scripts. So be careful in that regards. This is how the file looks for me currently.. Last line is the name of my script.

Upvotes: 3

Luciano Ghilarducci

Reputation: 189

Just have a line added to your crontab..

Make sure the file is executable:

chmod +x /path_to_you_file/your_file

To edit crontab file:

crontab -e

Line you have to add:

@reboot  /path_to_you_file/your_file

That simple!

Upvotes: 18

IR PRO

Reputation: 75

You can do it :

chmod +x PATH_TO_YOUR_SCRIPT/start_my_app

then use this command

update-rc.d start_my_app defaults 100

Please see this page on Cyberciti.

Upvotes: 7

fieldsweeper

Reputation: 57

The absolute easiest method if all you want to run is a simple script, (or anything) is if you have a gui to use system > preferences then startup apps.

just browse to the script you want and there you go. (make script executable)

Upvotes: 3

chris

Reputation: 37440

Another option is to have an @reboot command in your crontab.

Not every version of cron supports this, but if your instance is based on the Amazon Linux AMI then it will work.

Upvotes: 14

How to run a shell script at startup

Answers (25)

Using systemd

Related Questions