i have got a new Linux Server (Debian 6.0) with a Database (MySQL) which is accessed by Port 3306 like as usual.
Now I'd like to access the database due port problems of some users (because port 3306 is often blocked by network firewalls) by port 80 or 443. So the transfer must be redirected from Port 80 to 3306 to keep the Database working.
I have tried following command:
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3306
but I got following error:
iptables: No chain/target/match by that name.
Does anyone can help me solve this problem? The NAT table is empty (PREROUTING,POSTROUTING,OUTPUT have no entries) (checked with iptables -t nat -n -L)
In iptables Kernel modules required for NAT functionality:
Run following command to load modules in kernel:
# modprobe iptable_nat
# modprobe ipt_REDIRECT
Make sure you have above modules compiled in kernel:
[root#instructor tmp]# grep REDIRECT /boot/config-$( uname -r )
CONFIG_IP_NF_TARGET_REDIRECT=m
CONFIG_BRIDGE_EBT_REDIRECT=m
In VPS Server:
Enable modules on host server using modprobe command
Execute following command from the host server to enable all the modules for the VPS
vzctl set VEID --iptables iptable_nat --iptables ipt_REDIRECT
Add rules in file /etc/vz/conf/veid.conf
IPTABLES="iptable_nat ipt_REDIRECT"
I apparently have a redis-server instance running because when I try to start a new server by entering redis-server, I'm greeted with the following:
Opening port: bind: Address already in use
I can't figure out how to stop this server and start a new one.
Is there any command I can append to redis-server when I'm typing in the CLI?
My OS is Ubuntu 10.04.
Either connect to node instance and use shutdown command or if you are on ubuntu you can try to restart redis server through init.d:
/etc/init.d/redis-server restart
or stop/start it:
/etc/init.d/redis-server stop
/etc/init.d/redis-server start
On Mac
redis-cli shutdown
A cleaner, more reliable way is to go into redis-cli and then type shutdown
In redis-cli, type help #server and you will see this near the bottom of the list:
SHUTDOWN - summary: Synchronously save the dataset to disk and then
shut down the server since: 0.07
And if you have a redis-server instance running in a terminal, you'll see this:
User requested shutdown...
[6716] 02 Aug 15:48:44 * Saving the final RDB snapshot before exiting.
[6716] 02 Aug 15:48:44 * DB saved on disk
[6716] 02 Aug 15:48:44 # Redis is now ready to exit, bye bye...
redis-cli shutdown is most effective. The accepted answer does not work for me (OSX Lion). Thanks, #JesseBuesking.
For OSX, I created the following aliases for starting and stopping redis (installed with Homebrew):
alias redstart='redis-server /usr/local/etc/redis/6379.conf'
alias redstop='redis-cli -h 127.0.0.1 -p 6379 shutdown'
This has worked great for local development!
Homebrew now has homebrew-services that can be used to start, stop and restart services. homebrew-services
brew services is automatically installed when run.
brew services start|run redis
brew services stop redis
brew services restart redis
If you use run, then it will not start it at login (nor boot). start will start the redis service and add it at login and boot.
stop the redis server type in terminal with root user
sudo service redis-server stop
the message will be display after stop the redis-server
Stopping redis-server: redis-server.
if you want to start the redis-server type
sudo service redis-server start
if you want to restart the server type
sudo service redis-server restart
Type SHUTDOWN in the CLI
or
if your don't care about your data in memory, you may also type SHUTDOWN NOSAVE to force shutdown the server.
Try killall redis-server. You may also use ps aux to find the name and pid of your server, and then kill it with kill -9 here_pid_number.
Option 1: go to redis installation directory and navigate to src , in my case :
/opt/redis3/src/redis-cli -p 6379 shutdown
where 6379 is the default port.
Option 2: find redis process and kill
ps aux | grep redis-server
t6b3fg 22292 0.0 0.0 106360 1588 pts/0 S+ 01:19 0:00 /bin/sh /sbin/service redis start
t6b3fg 22299 0.0 0.0 11340 1200 pts/0 S+ 01:19 0:00 /bin/sh /etc/init.d/redis start
And Then initiate kill:
kill -9 22292
kill -9 22299
I'm using Centos 6.7 , x86_64
hope it helps
I would suggest to disable Redis-server, which prevents auto start while computer restarts and very useful to use docker like tools etc.
Step 1: Stop the redis-server
sudo service redis-server stop
Step 2: Disable the redis-server
sudo systemctl disable redis-server
if you need redis, you can start it as:
sudo service redis-server start
Another way could be:
ps -ef | grep -i 'redis-server'
kill -9 PID owned by redis
Works on *NIX & OSX
MacOSX - It Worked :)
Step 1 : Find the previously Running Redis Server
ps auxx | grep redis-server
Step 2 : Kill the specific process by finding PID (Process ID) - Redis Sever
kill -9 PID
if you did make install (e.g ubuntu) while installing redis then you can do:
redis-cli shutdown
as pointed by #yojimbo87 :)
systemd, ubuntu 16.04:
$ sudo systemctl is-active redis-server
active
$ sudo systemctl is-enabled redis-server
enabled
$ sudo systemctl disable redis-server
Synchronizing state of redis-server.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install disable redis-server
Removed /etc/systemd/system/redis.service.
$ sudo systemctl stop redis-server
Usually this problem arises after I shut down my computer ( or leaving running ) an irregular way.. I believe the port gets stuck open, while the process stops but continues to be bound to the previous port.
9/10 times the fix can be:
$ ps aux | grep redis
-> MyUser 2976 0.0 0.0 2459704 320 ?? S Wed01PM 0:29.94 redis-server *:6379
$ kill 2976
$ redis-server
Good to go.
Another way could be :
brew services stop redis
If you know on what port it would be running(by default it would be 6379), you can use below command to get the pid of the process using that port and then can execute kill command for the same pid.
sudo lsof -i : <port> | awk '{print $2}'
the above command will give you pid.
kill <pid>;
This would shutdown your server.
Following worked for me on MAC
ps aux | grep 'redis-server' | awk '{print $2}' | xargs sudo kill -9
If you know on which port(default:6379) your redis server is running you can go with option 1 or you can check your redis process and you can kill with option 2
option 1:Kill process on port:
check : sudo lsof -t -i:6379
kill : sudo kill `sudo lsof -t -i:6379`
option 2:
Find the previously Running Redis Server:
ps auxx | grep redis-server
Kill the specific process by finding PID (Process ID) - Redis Sever
kill -9 PID
Now start your redis server with
redis-server /path/to/redis.conf
In my case it was:
/etc/init.d/redismaster stop
/etc/init.d/redismaster start
To find out what is your service name, you can run:
sudo updatedb
locate redis
And it will show you every Redis files in your system.
If you are running redis in a docker container, none of the present answers will help. You have to stop redis container. Otherwise, redis process will keep respawning.
$ docker ps
CONTAINER ID IMAGE PORTS
e1c008ab04a2 bitnami/redis:4.0.8-r0 0.0.0.0:6379->6379/tcp
$ docker stop e1c008ab04a2
e1c008ab04a2
To stop redis server
sudo service redis-server stop
and check the status of it using
sudo service redis-server status
If Redis is installed via snap:
sudo snap stop redis.server
I don't know specifically for redis, but for servers in general:
What OS or distribution? Often there will be a stop or /etc/init.d/... command that will be able to look up the existing pid in a pid file.
You can look up what process is already bound to the port with sudo netstat -nlpt (linux options; other netstat flavors will vary) and signal it to stop. I would not use kill -9 on a running server unless there really is no other signal or method to shut it down.
The commands below works for me on Ubuntu Server
$ service /etc/init.d/redis_6379 stop
$ service /etc/init.d/redis_6379 start
$ service /etc/init.d/redis_6379 restart
Redis has configuration parameter pidfile (e.g. /etc/redis.conf - check redis source code), for example:
# If a pid file is specified, Redis writes it where specified at startup
# and removes it at exit.
#
# When the server runs non daemonized, no pid file is created if none is
# specified in the configuration. When the server is daemonized, the pid file
# is used even if not specified, defaulting to "/var/run/redis.pid".
#
pidfile /var/run/redis.pid
If it is set or could be set, instead of searching for process id (pid) by using ps + grep something like this could be used:
kill $(cat /var/run/redis.pid)
If required one can make redis stop script like this (adapted default redis 5.0 init.d script in redis source code):
PIDFILE=/var/run/redis.pid
if [ ! -f $PIDFILE ]
then
echo "$PIDFILE does not exist, process is not running"
else
PID=$(cat $PIDFILE)
echo "Stopping ..."
kill $PID
while [ -x /proc/${PID} ]
do
echo "Waiting for Redis to shutdown ..."
sleep 1
done
echo "Redis stopped"
fi
On MacOSX,
This is what worked for me
/etc/init.d/redis restart
/etc/init.d/redis stop
/etc/init.d/redis start
One thing to check if the redis commands are not working for you is if your redis-server.pid is actually being created. You specify the location of where this file is in
/etc/systemd/system/redis.service
and it should have a section that looks something like this:
[Service]
Type=forking
User=redis
Group=redis
ExecStart=/usr/bin/redis-server /etc/redis/redis.conf
PIDFile=/run/redis/redis-server.pid
TimeoutStopSec=0
Restart=always
Check the location and permissions of the PIDFile directory (in my case, '/run/redis'). I was trying to restart the service logged in as deploy but the directory permissions were listed as
drwxrwsr-x 2 redis redis 40 Jul 20 17:37 redis
If you need a refresher on linux permissions, check this out. But the problem was I was executing the restart as my deploy user which the permissions above are r-x, not allowing my user to write to the PIDFile directory.
Once I realized that, I logged in using root, reran the restart command on the redis (service redis restart) and everything worked. That was a headache but hopefully this saves someone a little time.
To gracefully shutdown specific instances with passwords and not resorting to brute-force kill commands, use:
redis-cli -p <port> -a <pass> shutdown
root#machine:~# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 105 0.1 0.0 60552 10772 ? Ssl 23:27 0:02 redis-server 127.0.0.1:10002
root 111 0.1 0.0 60552 10900 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10003
root 117 0.1 0.0 60552 10872 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10004
root#machine:~# redis-cli -p 10002 -a mypassword shutdown
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.
root#machine:~# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 111 0.1 0.0 60552 10900 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10003
root 117 0.1 0.0 60552 10872 ? Ssl 23:28 0:02 redis-server 127.0.0.1:10004
root#machine:~#
Having a ton of instances warrants writing a batch script to loop through them all for a master shutdown.
The service name of redis is redis-server, so you can disable and stop redis with this command:
sudo systemctl disable redis-server
sudo systemctl stop redis-server
You can try this code:
sudo kill -9 $(ps aux | grep 'redis' | awk '{print $2}')
Using CentoS 5.5.
I have an Apache 2.x server running on port 9999 and I am trying to find it using fuser.
I can find it using netstat, i.e.:
netstat -an | grep 9999
outputs:
tcp 0 0 :::9999 :::* LISTEN
Question 1: Why is netstat displaying the port using IPv6 syntax?
Question 2: What fuser command can I use to find the pid of the server? None of the following work:
fuser -n tcp :::9999
fuser -n tcp 9999
fuser -4 -n tcp 9999
fuser -6 -n tcp 9999
fuser -6 -n tcp :::9999
Thanks!
Why is it listening on IPv6? Well, by default on Linux, binding to [::] will not only bind to IPv6, but will also bind to an IPv4–compatible address. The ::ffff:0.0.0.0/96 space in IPv6 is used for IPv4–compatible connections.
The advantage of the software doing this is that it only needs to bind to the one socket. It makes the coding slightly simpler.
Not all distros or operating systems do this. For example, Windows requires you to bind to both [::] or 0.0.0.0 explicitly in order to support IPv6 or IPv4. And on Linux, if the net.ipv6.bindv6only sysctl is set to 1 (like it is on Debian, but not most other distros, including CentOS or Ubuntu), then you will need to explicitly bind to [::] and 0.0.0.0 to support both.
As for how to look it up in fuser, do it like this:
# fuser 80/tcp
80/tcp: 3052 3143 3144 3146 3147 3148
Or to show what process is bound to the port:
# fuser -v 80/tcp
USER PID ACCESS COMMAND
80/tcp: root 3052 F.... apache2
www-data 3143 F.... apache2
www-data 3144 F.... apache2
www-data 3146 F.... apache2
www-data 3147 F.... apache2
www-data 3148 F.... apache2
One was fix was to disable ipv6:
Added to /etc/modprobe.conf:
alias net-pf-10 off
I don't think fuser likes ipv6.