Centos7 系统下搭建.NET Core2.0+Nginx+Supervisor+Mysql环境

内容预览:

  • 直到微软推出完全开源的.NET Core~
  • 一方面,这个小巧的框架可以让某…~
  • 问题3:如果服务器宕机或需要重启我们则还是需要连入shell进行启动~

好记性不如烂笔头!

一、简介

一直以来,微软只对自家平台提供.NET支持,这样等于让这个“理论上”可以跨平台的框架在Linux和macOS上的支持只能由第三方项目提供(比如Mono .NET)。直到微软推出完全开源的.NET Core。这个开源的平台兼容.NET Standard,并且能在Windows、Linux和MacOS上提供完全一致的API。虽然这个小巧的.NET框架只是标准.NET的一个子集,但是已经相当强大了。

一方面,这个小巧的框架可以让某些功能性应用同时运行在三个平台上(就像某些功能性的Python脚本一样),另一方面,这也可以让服务器运维人员将ASP .NET服务程序部署在Linux服务器上(特别是对于运行Windows Server较为吃力的服务器)。

官网参考资料:https://www.microsoft.com/net/core#linuxcentos

二、.NET Core2.0 环境部署前准备

1.环境说明

服务器系统:CentOS 7.2.1511

2.安装前准备(关闭防火墙、关闭selinux)

1)关闭firewall:

systemctl stop firewalld.service #停止firewall
systemctl disable firewalld.service #禁止firewall开机启动
firewall-cmd --state #查看默认防火墙状态(关闭后显示notrunning,开启后显示running)

2)关闭selinux

sed -i "s/SELINUX=enforcing/SELINUX=disabled/g" /etc/selinux/config

查看改后文件如下:

[root@localhost ~]# cat /etc/selinux/config 

# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#     enforcing - SELinux security policy is enforced.
#     permissive - SELinux prints warnings instead of enforcing.
#     disabled - No SELinux policy is loaded.
SELINUX=disabled
# SELINUXTYPE= can take one of three two values:
#     targeted - Targeted processes are protected,
#     minimum - Modification of targeted policy. Only selected processes are protected. 
#     mls - Multi Level Security protection.
SELINUXTYPE=targeted

3)重启Centos

reboot

三、部署.NET Core2.0 环境

1.添加DOTNET产品

在安装.NET核心之前,您需要注册微软产品提要。这只需要做一次。首先,注册微软签名密钥,然后添加微软产品提要。

rpm --import https://packages.microsoft.com/keys/microsoft.asc                                     
sh -c 'echo -e "[packages-microsoft-com-prod]nname=packages-microsoft-com-prod nbaseurl=https://packages.microsoft.com/yumrepos/microsoft-rhel7.3-prodnenabled=1ngpgcheck=1ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/dotnetdev.repo'

2.安装.NET核心SDK

在下一步之前,请从您的系统中删除.NET .NET以前的任何预览版本。

以下命令更新用于安装的产品列表,安装.NET核心所需的组件,然后安装.NET核心SDK。

yum update
yum install libunwind libicu -y
yum install dotnet-sdk-2.0.0 -y

3.检查dotnet是否安装成功与版本查看

dotnet --info

dotnet --version

四、测试.NET Core2.0 环境

1.在home目录下初始化一个测试环境并输出”Hello World “内容 (测试方式一,可忽略)

cd /home
dotnet new console -o hwapp
cd hwapp
dotnet run

输出空内容如下:

[root@localhost hwapp]# dotnet run
Hello World!

2.上传.net core的实例页面进行测试 (测试方式二、推荐)

Centos 下.net core 2 环境测试用例 (把它上传到/home目录下或自定义的目录)

下载地址:

http://down.51cto.com/data/2334968

执行以下命令

cd /home/WebApplication1
dotnet restore   //如果使过用测试方式一,就需先执行这命令重新加载一下当前新的网站文件
dotnet run

运行后如下图:

未分类

通过IE访问测试页

五、安装配置nginx对ASP.NET Core应用的转发

1.安装Nginx环境

[root@localhost ~]#curl -o  nginx.rpm http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm
[root@localhost ~]#rpm -ivh nginx.rpm
[root@localhost ~]#yum install nginx -y

输入:systemctl start nginx 来启动nginx。

[root@localhost ~]# systemctl start nginx

输入:systemctl enable nginx 来设置nginx的开机启动(linux宕机、重启会自动运行nginx不需要连上去输入命令)

[root@localhost ~]#systemctl enable nginx
Created symlink from /etc/systemd/system/multi-user.target.wants/nginx.service to /usr/lib/systemd/system/nginx.service.

2.通过iE检查能否访问

[root@localhost nginx-1.8.1]# ps -ef|grep nginx
root      14626      1  0 08:47 ?        00:00:00 nginx: master process nginx
nginx     14627  14626  0 08:47 ?        00:00:00 nginx: worker process
root      14636   3269  0 08:49 pts/1    00:00:00 grep --color=auto nginx

nginx常用的操作命令

systemctl start nginx.service               #启动nginx服务

systemctl enable nginx.service             #设置开机自启动

systemctl disable nginx.service            #停止开机自启动

systemctl status nginx.service             #查看服务当前状态

systemctl restart nginx.service           #重新启动服务

systemctl list-units –type=service        #查看所有已启动的服务

3.防火墙配置(如果系统有防火墙就需要进行写入规则)

命令:firewall-cmd –zone=public –add-port=80/tcp –permanent(开放80端口)

命令:systemctl restart firewalld(重启防火墙以使配置即时生效)

4.配置nginx对ASP.NET Core应用的转发

修改 /etc/nginx/conf.d/default.conf 文件。

将文件内容替换为

    server {
        listen 80;
        location / {
            proxy_pass http://localhost:88;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection keep-alive;
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }
    }

重新加载nignx

[root@localhost nginx]# nginx -s reload

nginx的配置己完成

5.开启dotnet run进行测试

[root@localhost ~]# cd /home/WebApplication1/
[root@localhost WebApplication1]# dotnet run
Using launch settings from /home/WebApplication1/Properties/launchSettings.json...
Hosting environment: Development
Content root path: /home/WebApplication1
Now listening on: http://[::]:88
Application started. Press Ctrl+C to shut down.

通过IP 80端口访问

六、配置守护服务(Supervisor)

目前存在三个问题

问题1:ASP.NET Core应用程序运行在shell之中,如果关闭shell则会发现ASP.NET Core应用被关闭,从而导致应用无法访问,这种情况当然是我们不想遇到的,而且生产环境对这种情况是零容忍的。

问题2:如果ASP.NET Core进程意外终止那么需要人为连进shell进行再次启动,往往这种操作都不够及时。

问题3:如果服务器宕机或需要重启我们则还是需要连入shell进行启动。

为了解决这个问题,我们需要有一个程序来监听ASP.NET Core 应用程序的状况。在应用程序停止运行的时候立即重新启动。这边我们用到了Supervisor这个工具,Supervisor使用Python开发的。

1.安装Supervisor

[root@localhost /]# yum install python-setuptools -y
[root@localhost /]#easy_install supervisor

2.配置Supervisor

[root@localhost /]#mkdir /etc/supervisor
[root@localhost /]#echo_supervisord_conf > /etc/supervisor/supervisord.conf

修改supervisord.conf文件,将文件尾部的配置

[root@localhost /]# vi /etc/supervisor/supervisord.conf

将里面的最后两行:

;[include]                                                   
;files = relative/directory/*.ini

改为

[include]
files = conf.d/*.conf

ps:如果服务已启动,修改配置文件可用“supervisorctl reload”命令来使其生效

3.配置对ASP.NET Core应用的守护

创建一个 WebApplication1.conf文件,内容大致如下

[root@localhost /]# vi WebApplication1.conf
[program:WebApplication1]
command=dotnet WebApplication1.dll ; 运行程序的命令
directory=/home/WebApplication1/ ; 命令执行的目录
autorestart=true ; 程序意外退出是否自动重启
stderr_logfile=/var/log/WebApplication1.err.log ; 错误日志文件
stdout_logfile=/var/log/WebApplication1.out.log ; 输出日志文件
environment=ASPNETCORE_ENVIRONMENT=Production ; 进程环境变量
user=root ; 进程执行的用户身份
stopsignal=INT

将文件拷贝至:“/etc/supervisor/conf.d/WebApplication1.conf”下

[root@localhost /]#mkdir /etc/supervisor/conf.d
[root@localhost /]#cp WebApplication1.conf /etc/supervisor/conf.d/

运行supervisord,查看是否生效

[root@localhost /]#supervisord -c /etc/supervisor/supervisord.confsupervisord -c /etc/supervisor/supervisord.conf
[root@localhost /]# ps -ef | grep WebApplication1
root      29878  29685  0 09:57 ?        00:00:00 dotnet WebApplication1.dll
root      29892  29363  0 09:57 pts/3    00:00:00 grep --color=auto WebApplication1 

如果存在dotnet WebApplication1.dll 进程则代表运行成功,这时候在使用浏览器进行访问。

至此关于ASP.NET Core应用程序的守护即配置完成。

Supervisor守护进程常用操作

【启动supervisord】
确保配置无误后可以在每台主机上使用下面的命令启动supervisor的服务器端supervisord
supervisord

【停止supervisord】
supervisorctl shutdown

【重新加载配置文件】
supervisorctl reload

七 、配置Supervisor开机启动

新建一个“supervisord.service”文件

[root@localhost /]# vi supervisord.service
# dservice for systemd (CentOS 7.0+)
# by ET-CS (https://github.com/ET-CS)
[Unit]
Description=Supervisor daemon
[Service]
Type=forking
ExecStart=/usr/bin/supervisord -c /etc/supervisor/supervisord.conf
ExecStop=/usr/bin/supervisorctl shutdown
ExecReload=/usr/bin/supervisorctl reload
KillMode=process
Restart=on-failure
RestartSec=42s
[Install]
WantedBy=multi-user.target

将文件拷贝至:“/usr/lib/systemd/system/supervisord.service”

[root@localhost /]# cp supervisord.service /usr/lib/systemd/system/

执行命令:systemctl enable supervisord

[root@localhost /]# systemctl enable supervisord
Created symlink from /etc/systemd/system/multi-user.target.wants/supervisord.service to /usr/lib/systemd/system/supervisord.service.

执行命令:systemctl is-enabled supervisord #来验证是否为开机启动

[root@localhost /]# systemctl is-enabled supervisord

重启系统看能否能成功访问

[root@localhost /]# reboot

CentOS&.NET Core初试-4-安装守护服务(Supervisor)

Supervisor是什么?

Supervisor 是一个用 Python 写的进程管理工具,可以很方便的用来启动、重启、关闭进程(不仅仅是 Python 进程)。除了对单个进程的控制,还可以同时启动、关闭多个进程,比如很不幸的服务器出问题导致所有应用程序都被杀死,此时可以用 supervisor 同时启动所有应用程序而不是一个一个地敲命令启动。

Supervisor能干什么?

Supervisor帮助我们解决在开发过程中遇到的以下问题:

  • ASP.NET Core应用程序运行在shell之中,如果关闭shell则会发现ASP.NET Core应用被关闭,从而导致应用无法访问,这种情况当然是我们不想遇到的,而且生产环境对这种情况是零容忍的。

  • 如果ASP.NET Core进程意外终止那么需要人为连进shell进行再次启动,往往这种操作都不够及时。

  • 如果服务器宕机或需要重启我们则还是需要连入shell进行启动。

安装Supervisor

首先安装Python包管理工具(Supervisor使用Python开发的),然后再安装supervisor。

yum install python-setuptools
easy_install supervisor

supervisor安装完成后会生成三个执行程序:

  • supervisortd :supervisor的守护进程服务(用于接收进程管理命令)

  • supervisorctl :客户端(用于和守护进程通信,发送管理进程的指令)

  • echo_supervisord_conf :生成初始配置文件程序。

配置Supervisor

添加supervisor文件夹以及conf.d配置文件夹

mkdir /etc/supervisor
echo_supervisord_conf > /etc/supervisor/supervisord.conf
mkdir /etc/supervisor/conf.d

修改supervisord.conf文件,在文件尾部:

[include]
files=/etc/supervisor/conf.d/*.conf

启动Supervisor服务

supervisord -c /etc/supervisor/supervisord.conf

program的配置

在supervisor的conf.d文件夹下新建一个程序配置文件,hellocore.conf:

#配置程序名称
[program:hellocore]
#运行程序的命令
command=dotnet hellocore.dll 
#命令执行的目录
directory=/home/hellocore/ 
#错误日志文件
stderr_logfile=/var/log/hellocore.err.log
#输出日志文件
stdout_logfile=/var/log/hellocore.out.log 
#进程环境变量
environment=ASPNETCORE_ENVIRONMENT=Production 
#进程执行的用户身份
user=root
#程序是否自启动
autostart=true
#程序意外退出是否自动重启
autorestart=true
#启动时间间隔(秒)
startsecs=5
stopsignal=INT

重载Supervisor的配置文件

supervisorctl reload #重新加载配置文件

客户端相关命令:

supervisorctl status #查看程序配置的状态
supervisorctl stop programname    #停止某一个程序配置
supervisorctl start programname   #加载某一个程序配置
supervisorctl restart programname #重新加载某一个程序配置
supervisorctl reload #重新加载配置
supervisorctl update

查看配置程序是否启动:

ps -ef | grep hellocore #programdllname

如下图,则Supervisor配置成功:

未分类

Supervisor配置成功

设置Supervisor开机启动

在 /usr/lib/systemd/system文件夹下新建supervisor.service配置文件,内容如下:

[Unit]
Description=supervisor
[Service]
Type=forking
ExecStart=/usr/bin/supervisord -c /etc/supervisor/supervisord.conf
ExecStop=/usr/bin/supervisorctl shutdown
ExecReload=/usr/bin/supervisorctl reload
KillMode=process
Restart=on-failure
RestartSec=42s
[Install]
WantedBy=multi-user.target

将服务设置为开机启动:

systemctl enable supervisor.service
systemctl start supervisor.service

supervisor开机启动服务配置成功

未分类

配置Supervisor图形化管理

打开supervisor的配置文件

vi /etc/supervisor/supervisord.conf

找到配置:

;[inet_http_server]         ; inet (TCP) server disabled by default
;port=127.0.0.1:9001        ; (ip_address:port specifier, *:port for all iface)
;username=user              ; (default is no username (open server))ls
;password=123               ; (default is no password (open server))

修改成:

[inet_http_server] ; inet (TCP) 服务,默认是关闭的
port=*:9001      ;ip:端口,*代表所有IP
username=root               ;登陆账号,可以不设
password=root123              ;登陆账户,可以不设

保存好修改后,重启supervisor。

supervisorctl reload

防火墙查看9001端口是否开启

firewall-cmd --list-ports #查看已开放的端口

开启端口:

firewall-cmd --zone=public  --add-port=9001/tcp --permanent
firewall-cmd --reload #重启防火墙

命令含义:

--zone #作用域
--add-port=9001/tcp  #添加端口,格式为:端口/通讯协议
--permanent  #永久生效,没有此参数重启后失效

成功访问:

未分类

为laravel/lumen queue 配置 supervisor

近期工作中使用了 laravel框架中的队列服务,需要运行队列处理器 php /path/to/artisan queue:work --tries 3 命令

测试环境部署时需要:

  • 终止原有queue:work命令
  • 开启新queue:work命令

依照laravel教程(https://laravel-china.org/docs/laravel/5.6/queues/1395#supervisor-configuration)推荐使用进程管理工具 supervisor

Supervisor 安装

yum install supervisor  # centos
sudo apt-get install supervisor  # ubuntu

supervisord 是进程管理的服务端,常驻进程辅助干活
supervisorctl 是客户端,用来执行查看、加载等命令

Supervisor 配置

生成配置文件

echo_supervisord_conf > /etc/supervisord.conf

编辑配置文件

vim /etc/supervisord.conf

配置文件中配置除了最后两行,使用默认的就行。vim中使用G把光标跳到文件末尾,将最后一行修改为如下。

# file: /etc/supervisord.conf
...
[include]
files = /etc/supervisor/*.conf

创建文件夹

mkdir -p /etc/supervisor/

创建queue work启动脚本

vim /etc/supervisor/lumen_worker.conf

lumen_worker.conf 文件内容 注意修改项目artisan文件路径

[program:lumen_worker]
process_name=%(program_name)s_%(process_num)02d
command=php /path/to/artisan queue:listen --tries 3 --sleep 3
autostart=true
autorestart=true
user=root
numprocs=1
redirect_stderr=true
stdout_logfile=/tmp/lumen_worker.log

启动 supervisor

supervisord  
# 启动supervisord服务,默认使用/etc/supervisord.conf配置文件。
# 如果报错Error: Another program is already listening on a port that one of our HTTP servers is configured to use.说明已经启动,继续即可。

supervisorctl reload  # 重启 supervisord
supervisorctl reread  # 重新读取配置文件 supervisord
supervisorctl start lumen_worker:*  # 启动lumen_worker服务

supervisorctl restart lumen_worker:*  # 重启lumen_worker服务

启动后查看一下运行状态

supervisorctl status

应该能看到lumen_worker处于RUNNING状态:

[root@X /etc/supervisor]# supervisorctl status
lumen_worker:lumen_worker_00     RUNNING   pid 19317, uptime 0:01:49

supervisor更改某项目配置后 需要重新启动才有效

在linux服务器上部署了node项目,使用supervisor进行管理,supervisor是个好工具,具体介绍见这里http://www.cnblogs.com/xueweihan/p/6195824.html

梗概了该项目对的某些配置后,重新启动项目,发现问题仍在,通过日志内容才知道原来新的配置没有被应用。 
要使更新的配置得以应用,需要重新启动supervisor服务。具体操作如下: 参考文章http://www.codeweblog.com/supervisor%E9%87%8D%E6%96%B0%E5%8A%A0%E8%BD%BD%E9%85%8D%E7%BD%AE%E5%90%AF%E5%8A%A8%E6%96%B0%E7%9A%84%E8%BF%9B%E7%A8%8B/

1、更新新的配置到supervisord

supervisorctl update

2、重新启动配置中的所有程序

supervisorctl reload

3、启动某个进程(program_name=你配置中写的程序名称)

supervisorctl start program_name

4、查看正在守候的进程

supervisorctl

5、停止某一进程 (program_name=你配置中写的程序名称)

pervisorctl stop program_name

6、重启某一进程 (program_name=你配置中写的程序名称)

supervisorctl restart program_name

7、停止全部进程

supervisorctl stop all

linux下使用supervisor监控应用程序

1、应用场景

应用程序需要24小时不间断运行。这时可使用supervisor监控应用程序的进程。当发生应用程序内部错误退出、进程被杀死等情况时,自动重启应用程序。

2、supervisor

supervisor由python写成, 简单好用。官方网站 http://supervisord.org,上面有详细的指南文档。

3、安装supervisor

1)安装 setuptools

$sudo apt-get install python-setuptools

2) 使用easy_install安装 supervisor

$sudo easy_install supervisor

安装完成后出现:

/usr/bin/supervisord --supervisor服务守护进程
/usr/bin/supervisorctl--supervisor服务控制程序

4、配置文件

以下命令可以将配置文件示例打印到控制台:

$ echo_supervisord_conf

若要生成配置文件,使用命令:

$ sudo echo_supervisord_conf > /etc/supervisord.conf

或者在当前目录生成:

$ echo_supervisord_conf > supervisord.conf

Notice: 如何停止子进程

场景:如果supervisord.conf中配置的command是执行一个bash,而bash里执行java,那么当使用supervisorctl stop [programname]停止程序时,只有上层进程被停止,而java进程没有被停止。

解决办法:

在配置文件中设置:

stopasgroup=true               
killasgroup=true 

5、配置要运行的程序

在上面生成的配置文件后,追加:

[program:helloworld]
command=./helloworld              ;执行命令
process_name=%(program_name)s
autostart=true                   ; 程序是否随supervisor启动而启动
autorestart=true                 ;程序停止时,是否自动重启
startsecs=10

6、启动supervisor

$ supervisord -c supervisord.conf

7、使用supervisorctl管理程序

1)开启/停止某个程序

# supervisorctl [start | stop] [program名称]      //在supervisord.conf中定义的

2)查看进程状态

$supervisorctl status

8、通过web方式查看状态

配置文件中配置:

[inet_http_server]         ; inet (TCP) server disabled by default
port=127.0.0.1:9001        ; (ip_address:port specifier, *:port for all iface)

那么可以从浏览器通过访问 localhost:9001来查看进程状态

9、添加supervisord为Linux系统服务,开机自动启动

1)将supervisord.conf拷贝到 /etc 目录下

2)启动脚本 supervisord.sh (centos/redhat)

#!/bin/sh
#
# /etc/rc.d/init.d/supervisord
#
# Supervisor is a client/server system that
# allows its users to monitor and control a
# number of processes on UNIX-like operating
# systems.
#
# chkconfig: - 64 36
# description: Supervisor Server
# processname: supervisord

# Source init functions
. /etc/rc.d/init.d/functions

prog="supervisord"

prog_bin="/usr/local/bin/supervisord"
PIDFILE="/tmp/supervisord.pid"

start()
{
        echo -n $"Starting $prog: "

# Source init functions
. /etc/rc.d/init.d/functions

prog="supervisord"

prog_bin="/usr/local/bin/supervisord"
PIDFILE="/tmp/supervisord.pid"start()
{
        echo -n $"Starting $prog: "
        daemon $prog_bin --pidfile $PIDFILE
        [ -f $PIDFILE ] && success $"$prog startup" || failure $"$prog startup"
        echo
}

stop()
{
        echo -n $"Shutting down $prog: "
        [ -f $PIDFILE ] && killproc $prog || success $"$prog shutdown"
        echo
}

case "$1" in
  start)
    start
  ;;
  stop)
    stop
  ;;
  status)
        status $prog
  ;;
  restart)
    stop
    start
  ;;
  *)
    echo "Usage: $0 {start|stop|restart|status}"
  ;;

esac

3)添加为系统服务

# mv supervisord.sh  /etc/init.d/supervisord
# chkconfig --add  supervisord
# chkconfig --level 345 supervisord on

4) 开启/停止服务

# service supervisord [start | stop]

使用 supervisor 管理 logkit-pro

对于logkit-pro这样的服务,我们推荐使用supervisor作为守护进程进行管理,这样即使程序由于某种原因异常关闭,还能通过supervisor自动重启。

logkit-pro在设计上保证了即使异常重启也保证数据不会丢失,最坏情况是意外中断后重启导致出现部分数据重复,正常情况都是不重不漏发送

Supervisor是用Python开发的Linux/Unix系统下的一个进程管理工具。它可以很方便的监听、启动、停止、重启一个或多个进程。用Supervisor管理的进程,当一个进程意外终止,supervisor监听到进程不存活时,会自动将它重新拉起,很方便的做到进程自动恢复的功能,不再需要自己写脚本来控制。

安装supervisor

如果您的机器已经安装了 supervisor,可以跳过这一步。

supervisor 是 python 编写的,所以机器上首先要安装 python,一般的 Linux 发行版都已经自带 python 了。

supervisor 官方推荐的安装方式,第一种是使用 easy_install 工具安装。

所以如果您机器上没有easy_install,需要先安装一下。

安装 easy_install

wget --no-check-certificate https://bootstrap.pypa.io/ez_setup.py -O - | sudo python

通过easy_install安装supervisor

easy_install supervisor

Ubuntu用户安装supervisor

只需执行如下命令:

sudo apt-get install supervisor

配置logkit-pro

安装完成后,supervisor的主配置文件一般存放在 /etc/supervisor/supervisord.conf

打开可以看到

[include]
files = /etc/supervisor/conf.d/*.conf

会监听 /etc/supervisor/conf.d/ 下的配置文件。

如果没有这个主配置文件,你就要创建一个/etc/supervisor文件夹,然后用如下命令生成

echo_supervisord_conf > /etc/supervisor/supervisord.conf

根据实际情况对supervisor的配置文件做修改。

也可以将下列配置文件手动写入到 /etc/supervisor/supervisord.conf 中。

; supervisor config file
[unix_http_server]
file=/var/run/supervisor.sock   ; (the path to the socket file)
chmod=0700                       ; sockef file mode (default 0700)
[supervisord]
logfile=/var/log/supervisor/supervisord.log ; (main log file;default $CWD/supervisord.log)
pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
childlogdir=/var/log/supervisor            ; ('AUTO' child log dir, default $TEMP)
; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
[supervisorctl]
serverurl=unix:///var/run/supervisor.sock ; use a unix:// URL  for a unix socket
; The [include] section can just contain the "files" setting.  This
; setting can list multiple files (separated by whitespace or
; newlines).  It can also contain wildcards.  The filenames are
; interpreted as relative to this file.  Included files *cannot*
; include files themselves.
[include]
files = /etc/supervisor/conf.d/*.conf

修改配置文件后,重启下supervisord

service supervisord restart

如果service中没有supervisord,参考文档https://serverfault.com/questions/96499/how-to-automatically-start-supervisord-on-linux-ubuntu

至此,supervisor守护进程已经安装完毕。

我们假设logkit已经下载并解压缩到 /home/qiniu/logkit-pro/ 目录下,并包含了运行所需的所有文件,如下所示。

$ ls /home/qiniu/logkit-pro/
auths.conf      logkit-pro      logkit-pro.conf public

我们编写配置文件 logkit_supervisor.conf 并放置到 /etc/supervisor/conf.d/ 目录,编写的配置内容如下所示。

[program:logkit-pro]
command=/home/qiniu/logkit-pro/logkit-pro -f /home/qiniu/logkit-pro/logkit-pro.conf
directory=/home/qiniu/logkit-pro/
priority=999
autostart=true
startsecs=3
stopwaitsecs=200
autorestart=true
user=qiniu
redirect_stderr=true
log_level=info
stdout_logfile=/home/qiniu/logkit-pro/logkit-pro.log
stdout_logfile_maxbyte=200MB
stdout_logfile_backups=2

其中

  • program 表示使用supervisor管理时进程的名称
  • command 表示运行的命令
  • directory 表示启动的工作目录,即进程运行时的当前目录。
  • user 表示运行进程的用户组
  • stdout_logfile 表示程序输出的日志文件路径
  • startsecs 表示启动时等待程序程序运行的世界
  • stopwaitsecs 表示正常关闭后等待时间,如果超过等待时间则发送SIGKILL强制关闭,因为logkit关停需要时间结束发送等过程,建议设置时间稍长,supervisor默认配置的时间为10s

supervisor重载配置并启动logkit-pro

配置完成后,我们要让supervisor载入当前的新配置,执行如下命令:

supervisorctl reread

supervisor感知到新配置后,我们就可以将logkit-pro加入到管理中,执行如下命令:

supervisorctl add logkit-pro

然后程序就已经正常运行了,可以通过supervisor查看

supervisorctl status

通过supervisor停止、启动、重启的命令如下:

supervisorctl stop logkit-pro
supervisorctl start logkit-pro
supervisorctl restart logkit-pro

详细的命令可以参考supervisor的官方文档

查看日志

根据我们的supervisor配置,logkit-pro的日志存放在

/home/qiniu/logkit-pro/logkit-pro.log

而supervisor本身的日志可以在supervisor的主配置文件中查看

cat /etc/supervisor/supervisord.conf

默认情况下存放在

/var/log/supervisor/supervisord.log

Centos7.3配置Supervisor遇到的一些小问题

Laravel 手册是以 Ubuntu 为例写的,这里是Centos,与手册不同:

首先安装:

yum install -y supervisor

然后创建扩展配置文件:

cd /etc/supervisord.d
vi laravel-worker.ini

写入以下内容:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /你的Linux完整项目地址/artisan queue:work redis --sleep=3 --tries=3
autostart=true
autorestart=true
user=www
numprocs=8
redirect_stderr=true
stdout_logfile=/www/wwwroot/app/worker.log

以下是说明:

command:XX 程序启动命令
autostart=true ;在supervisord启动的时候也自动启动
autorestart=true ;程序退出后自动重启,可选值:[unexpected,true,false],默认为unexpected,表示进程意外杀死后才重启
user=www ;用哪个用户启动进程,默认是root
numprocs=8 ;指定 Supervisor 运行 8 个 queue:work 进程并且监管它们,
redirect_stderr=true ;stderr重定向到stdout,默认false
stdout_logfile=/www/wwwroot/app/worker.log ;stdout 日志文件,需要注意当指定目录不存在时无法正常启动,所以需要手动创建目录(supervisord 会自动创建日志文件)

执行命令启动Supervisor:

执行:

sudo supervisorctl reread

但是报错:

error: <class 'socket.error'>, [Errno 2] No such file or directory: file: /usr/lib64/python2.7/socket.py line: 224

执行:

supervisord

再执行:

sudo supervisorctl reread

sudo supervisorctl update

sudo supervisorctl start laravel-worker:*

OK了

Python Web 腾讯云部署:flask+fabric+gunicorn+nginx+supervisor

最近看了《Flask Web开发–基于Python的Web应用开发实战》,还有廖雪峰老师的Python教程,前者是基于Web框架flask进行开发,后者是自己搭建了一个Web框架。Web框架致力于如何生成HTML代码,而Web服务器用于处理和响应HTTP请求。Web框架和Web服务器之间的通信,需要一套双方都遵守的接口协议。WSGI协议就是用来统一这两者的接口的。

为了部署一个完整的环境,本文将使用flask作为Web框架,Gunicorn作为WSGI容器,Nginx作为Web服务器,同时使用Supervisor进行进程管理,并使用Fabric实现自动化部署。

前期准备

申请一个腾讯云服务器Ubuntu Server 16.04.1 LTS 64位:

账户:ubuntu
密码:**********
内网ip:172.16.0.17
外网ip:139.199.184.183

使用《Flask Web开发》源码:

$ mkdir web
$ cd web
~/web$ git clone https://github.com/miguelgrinberg/flasky.git

设置并进入虚拟环境:

~/web$ cd flasky
~/web/flasky$ virtualenv venv
~/web/flasky$ source venv/bin/activate

安装对应的库:

(venv) ~/web/flasky$ cd requirements
(venv) ~/flasky/requirements$ pip3 install -r common.txt
(venv) ~/flasky/requirements$ pip3 install -r dev.txt
(venv) ~/flasky/requirements$ pip3 install -r heroku.txt
(venv) ~/flasky/requirements$ pip3 install -r prod.txt

创建数据库:

(venv) ~/flasky/requirements$ cd ..
(venv) ~/flasky/$ python3 manage.py deploy

Fabric

Fabric入门看这里https://www.jianshu.com/p/0be28f6c4607

新开一个终端,远程登陆服务器:

$ ssh [email protected]

在服务器端定义好部署结构:

ubuntu@VM $ mkdir web
ubuntu@VM $ mkdir web/flasky
ubuntu@VM $ mkdir web/log

即:

  • web/    Web App根目录
    • flasky/  存放python文件
    • log/    存放日志文件

我们使用Fabric将代码上传到服务器,首先,安装Fabric:

(venv) ~/web$ sudo apt-get install fabric

在web目录下创建fabfile.py(必须这个名字),写入:

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import os, re
from datetime import datetime

# 导入Fabric API:
from fabric.api import *

# 服务器登录用户名:
env.user = 'ubuntu'
# sudo用户为root:
env.sudo_user = 'root'
# 服务器地址,可以有多个,依次部署:
env.hosts = ['139.199.184.183']

_TAR_FILE = 'dist-flasky.tar.gz'

def build():
    includes = ['app', 'migrations', 'requirements', 'tests', 'venv', *.py', '*.sqlite']
    excludes = ['.*', '*.pyc', '*.pyo']
    local('rm -f dist/%s' % _TAR_FILE)
    with lcd(os.path.join(os.path.abspath('.'), 'flasky')):
        cmd = ['tar', '--dereference', '-czvf', '../dist/%s' % _TAR_FILE]
        cmd.extend(['--exclude='%s'' % ex for ex in excludes])
        cmd.extend(includes)
        local(' '.join(cmd))


_REMOTE_TMP_TAR = '/tmp/%s' % _TAR_FILE
_REMOTE_BASE_DIR = '/home/ubuntu/web/flasky'

def deploy():
    newdir = 'flask-%s' % datetime.now().strftime('%y-%m-%d_%H.%M.%S')
    # 删除已有的tar文件:
    run('rm -f %s' % _REMOTE_TMP_TAR)
    # 上传新的tar文件:
    put('dist/%s' % _TAR_FILE, _REMOTE_TMP_TAR)
    # 创建新目录:
    with cd(_REMOTE_BASE_DIR):
        sudo('mkdir %s' % newdir)
    # 解压到新目录:
    with cd('%s/%s' % (_REMOTE_BASE_DIR, newdir)):
        sudo('tar -xzvf %s' % _REMOTE_TMP_TAR)
    # 重置软链接:
    with cd(_REMOTE_BASE_DIR):
        sudo('rm -f flask')
        sudo('ln -s %s flask' % newdir)
        sudo('chown ubuntu:ubuntu flask')
        sudo('chown -R ubuntu:ubuntu %s' % newdir)
    # 重启Python服务和nginx服务器:
    #with settings(warn_only=True):
    #    sudo('supervisorctl stop flask')
    #    sudo('supervisorctl start flask')
    #    sudo('/etc/init.d/nginx reload')

使用fab命令将代码打包:

(venv) ~/web$ mkdir dist
(venv) ~/web$ fab build

将代码传上服务器:

(venv) ~/web$ fab deploy

Gunicorn部署

gunicorn入门看这里https://www.jianshu.com/p/260f18aa5462

代码上传给服务器后,可以直接运行manage.py文件,就可以访问网站了。可是实际情景中需要处理高并发访问的情况,我们使用Gunicorn来解决这个问题。

在服务器上进入flask所在目录,激活虚拟环境,并安装gunicorn:

ubuntu@VM ~/web/flasky/flask$ source venv/bin/activate
(venv) ubuntu@VM ~/web/flasky/flask$  sudo apt-get install gunicorn

使用gunicorn运行web应用(支持4个并发请求):

(venv) ubuntu@VM ~/web/flasky/flask$ gunicorn -w 4 -b 172.16.0.17:5000 manage:app

其中172.16.0.17是服务器内网ip,这样设置后就可以通过外网ip访问网站了。在浏览器地址栏中输入139.199.184.183:5000,就可以看到网站了。

Nginx

Nginx入门看这里

使用gunicorn的话,需要将端口暴露给外界,这不利于服务器的安全问题。Nginx是一个高性能的HTTP和反向代理服务器,通过配置一个代理服务器,可以实现反向代理的功能。所谓反向代理,是指一个请求,从互联网过来,先进入代理服务器,再由代理服务器转发给局域网的目标服务器。

先安装nginx:

(venv) ubuntu@VM ~$ sudo apt-get install nginx

设置反向代理服务器:在服务器,进入目录/etc/nginx/sites-available/,在目录下的default文件写入一个server。

首先,先备份default文件:

$ cd /etc/nginx/sites-available/
$ sudo cp default default-backup

在default文件中写入server:

server {
    listen 80;
    root /home/ubuntu/web/flasky/flask/;

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Forward-For $proxy_add_x_forwarded_for;
    }
}

配置完成后,重启nginx:

$ sudo nginx -s reload

此时,该反向代理服务器就开始监听80端口。80端口是为HTTP开放的端口,浏览网页服务默认的端口号都是80 (8080端口跟80端口一样)。只要访问服务器,代理服务器就会将请求转发到127.0.0.1:5000.

回到目录/home/ubuntu/web/flasky/flask/下,再次使用gunicorn运行web app:

(venv) ubuntu@VM ~/web/flasky/flask$ gunicorn -w 4 -b 127.0.0.1:5000 manage:app

用的ip地址是127.0.0.1

而外界要访问网站只需要在浏览器地址栏输入139.199.184.183,使用默认端口80。这样web app实际使用的5000就不用暴露了。

Supervisor

supervisor入门看这里https://www.jianshu.com/p/0226b7c59ae2

如果你需要进程一直执行,若该进程因各种原因中断,也会自动重启的话,supervisor是一个很好的选择。

supervisor管理进程,是通过fork/exec的方式将这些被管理的进程当作supervisor的子进程来启动,所以我们只需要将要管理进程的可执行文件的路径添加到supervisor的配置文件中就好了。此时被管理进程被视为supervisor的子进程,若该子进程异常终端,则父进程可以准确的获取子进程异常终端的信息,通过在配置文件中设置autostart=true,可以实现对异常中断的子进程的自动重启。

安装supervisor:

(venv) ubuntu@VM ~$ sudo apt-get install supervisor

在目录/etc/supervisor/conf.d/下创建flask.conf,并加入:

;/etc/supervisor/conf.d/flask.conf

[program:flask]

command     = /home/ubuntu/.local/bin/gunicorn -w 4 -b 127.0.0.1:5000 manage:app
;这里/home/ubuntu/.local/bin/是我服务器上gunicorn的安装目录
directory   = /home/ubuntu/web/flasky/flask
user        = ubuntu
startsecs   = 3
autostart   = true

redirect_stderr         = true
stdout_logfile_maxbytes = 50MB
stdout_logfile_backups  = 10
stdout_logfile          = /home/ubuntu/web/flasky/log/app.log

配置完后,进入目录/home/ubuntu/web/flasky/, 创建log目录:

(venv) ubuntu@VM ~/web/flasky$ mkdir log

启动supervisor:

(venv) ubuntu@VM /etc/supervisor$ sudo supervisord -c supervisor.conf                 

执行服务(运行app.py):

(venv) ubuntu@VM $ sudo supervisorctl start flask

此时,进程flask运行,执行command后边的语句,即/home/ubuntu/.local/bin/gunicorn -w 4 -b 127.0.0.1:5000 manage:app。

在浏览器地址栏输入139.199.184.183,使用默认端口80,即可访问网站。

如果supervisor遇到错误,可以在/var/log/supervisor/supervisord.log中查看日志;
如果app运行出现问题,可以在 /home/ubuntu/web/flasky/log/app.log中查看日志。

自动化部署

为了实现自动化部署,将上边fabfile.py文件的最后四个语句的注释取消,就能在将修改后的代码传上服务器后,用supervisor自动重载配置并重启flask进程。之后便可以直接访问网站。
因此,每次更改代码后,只需要执行以下两个语句,无需登陆服务器,便可以启动网站:

$ fab build
$ fab deploy

gunicorn配置文件

gunicorn的配置除了可以在命令行中设置,也可以使用配置文件实现更复杂的配置:

$ gunicorn -c gunicorn.py manage:app

gunicorn.py文件如下:

# gunicorn.py
import logging
import logging.handlers
from logging.handlers import WatchedFileHandler
import os
import multiprocessing
bind = '127.0.0.1:5000'       #绑定ip和端口号
backlog = 512                 #监听队列
chdir = '/home/test/server/bin'   #gunicorn要切换到的目的工作目录
timeout = 30      #超时
worker_class = 'gevent' #使用gevent模式,还可以使用sync 模式,默认的是sync模式
workers = multiprocessing.cpu_count() * 2 + 1    #进程数

threads = 2 #指定每个进程开启的线程数

loglevel = 'info' #日志级别,这个日志级别指的是错误日志的级别,而访问日志的级别无法设置
access_log_format = '%(t)s %(p)s %(h)s "%(r)s" %(s)s %(L)s %(b)s %(f)s" "%(a)s"'     #设置gunicorn访问日志格式,错误日志无法设置
"""
其每个选项的含义如下
        h           remote address
        l           '-'
        u           currently '-', may be user name in future releases
        t           date of the request
        r           status line (e.g. ``GET / HTTP/1.1``)
        s           status
        b           response length or '-'
        f           referer
        a           user agent
        T           request time in seconds
        D           request time in microseconds
        L           request time in decimal seconds
        p           process ID
        {Header}i   request header
        {Header}o   response header
"""
accesslog = "/home/ubutnu/web/flasky/log/gunicorn_access.log"      #访问日志文件
errorlog = "/home/ubutnu/web/flasky/log/gunicorn_error.log"        #错误日志文件

在本地将gunicorn.py放在/home/ubutnu/web/flasky/flask/目录下,在服务器端将/etc/supervisor/conf.d/flask.conf中的command改为:

command     = /home/ubuntu/.local/bin/gunicorn -c /home/ubutnu/web/flasky/flask/gunicorn.py manage:app

然后,在本地执行:

$ fab build
$ fab deploy

便可以访问网站了。

未分类

使用 Supervisor 管理服务器后台进程

Supervisor (http://supervisord.org) 是一个用 Python 写的进程管理工具,可以很方便的用来启动、重启、关闭进程(不仅仅是 Python 进程)。除了对单个进程的控制,还可以同时启动、关闭多个进程,比如很不幸的服务器出问题导致所有应用程序都被杀死,此时可以用 supervisor 同时启动所有应用程序而不是一个一个地敲命令启动。

之所以使用 Supervisor,是因为服务器的 MongoDB 进程偶尔会 Crash,需要确保让它在挂掉后自动重启确保服务正常。

0x1 安装

直接使用 pip 进行安装:

$ sudo pip install supervisor

# 可能你会收到类似的报错:Supervisor requires Python 2.4 or later but does not work on any version of Python 3.  You are using version 3.4.3 (default, Oct 28 2017, 20:59:04)
# 可以手动安装新版 Supervisor,它支持 Python3:

$ pip install git+https://github.com/Supervisor/supervisor

# 设置环境变量:
$ vim ~/.bash_profile

在后面补充: PATH=$PATH:$HOME/bin:/usr/local/python/bin

$ source ~/.bash_profile

0x2 配置

$ echo_supervisord_conf > /etc/supervisord.conf

打开配置文件:

$ vim /etc/supervisord.conf

[unix_http_server]
file=/tmp/supervisor.sock   ; UNIX socket 文件,supervisorctl 会使用
;chmod=0700                 ; socket 文件的 mode,默认是 0700
;chown=nobody:nogroup       ; socket 文件的 owner,格式: uid:gid
;username=user              ; default is no username (open server)
;password=123               ; default is no password (open server)

;[inet_http_server]         ; HTTP 服务器,提供 web 管理界面
;port=127.0.0.1:9001        ; Web 管理后台运行的 IP 和端口,如果开放到公网,需要注意安全性
;username=user              ; 登录管理后台的用户名
;password=123               ; 登录管理后台的密码

[supervisord]
logfile=/tmp/supervisord.log ; 日志文件,默认是 $CWD/supervisord.log
logfile_maxbytes=50MB        ; 日志文件大小,超出会 rotate,默认 50MB
logfile_backups=10           ; 日志文件保留备份数量默认 10
loglevel=info                ; 日志级别,默认 info,其它: debug,warn,trace
pidfile=/tmp/supervisord.pid ; pid 文件
nodaemon=false               ; 是否在前台启动,默认是 false,即以 daemon 的方式启动
minfds=1024                  ; 可以打开的文件描述符的最小值,默认 1024
minprocs=200                 ; 可以打开的进程数的最小值,默认 200

; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///tmp/supervisor.sock ; 通过 UNIX socket 连接 supervisord,路径与 unix_http_server 部分的 file 一致
;serverurl=http://127.0.0.1:9001 ; 通过 HTTP 的方式连接 supervisord

;包含其他的配置文件
[include]
files = relative/directory/*.ini    ; 可以是 *.conf 或 *.ini

0x3 配置需要管理的进程

这里以添加 MongoDB 进程为例,首先修改 supervisord.conf:

$ vim supervisord.conf

# 找到最后一行,并取消注释和添加:
[include]
files = /etc/supervisor/*.conf

$ mkdir /etc/supervisor
$ cd /etc/suervisor
$ vim mongodb.conf

# 填入以下内容:

[program:mongodb]
command =  /usr/bin/mongod -port 27017 --dbpath /vr/lib/mongo
autostart = true     ; 在 supervisord 启动的时候也自动启动
startsecs = 5        ; 启动 5 秒后没有异常退出,就当作已经正常启动了
autorestart = true   ; 程序异常退出后自动重启
startretries = 3     ; 启动失败自动重试次数,默认是 3

0x4 启动 Supervisor

Supervisor 有两个主要的组成部分:

  1. supervisord,运行 Supervisor 时会启动一个进程 supervisord,它负责启动所管理的进程,并将所管理的进程作为自己的子进程来启动,而且可以在所管理的进程出现崩溃时自动重启。

  2. supervisorctl,是命令行管理工具,可以用来执行 stop、start、restart 等命令,来对这些子进程进行管理。

$ supervisord -c /etc/supervisord.conf
$ supervisorctl -c /etc/supervisord.conf status

> mongodb       RUNNING   pid 2366, uptime 0:01:00

未分类

0x5 可视化管理进程

$ vim /etc/supervisord.conf

# 取消注释和更改设置
[inet_http_server]         ; HTTP 服务器,提供 web 管理界面
port=0.0.0.0:8080          ; Web 管理后台运行的 IP 和端口,如果开放到公网,需要注意安全性
username=user              ; 登录管理后台的用户名
password=123               ; 登录管理后台的密码

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=http://0.0.0.0:8080    ; 通过 HTTP 的方式连接 supervisord

通过浏览器打开网站 url:8080,输入帐号密码,可以在网页中查看进程:

未分类

0x6 开机自启动 Supervisor

Linux 在启动的时候会执行 /etc/rc.local 里面的脚本,所以只要在这里添加执行命令就可以:

# 如果是 Centos 添加以下内容
/usr/bin/supervisord -c /etc/supervisord.conf

# 以上内容需要添加在 exit 命令前,而且由于在执行 rc.local 脚本时,PATH 环境变量
# 未全部初始化,因此命令需要使用绝对路径。可以使用一下命令查看绝对路径:

$ sudo find / -name supervisord
> /usr/local/python/bin/supervisord

所以要改下路径:
/usr/local/python/bin/supervisord -c /etc/supervisord.conf

0x7 常见问题

在启动 supervisorctl 的时候可能会接受到 refuse connection 的报错,解决办法:

# 找到 supervisor.sock 的地址
$ find / -name supervisor.sock

# unlink 掉它,*** 换成真实地址
$ unlink /***/supervisor.sock

还遇到了另外一个问题,在 supervisor 运行一段时间后,web 端会访问不了,在后台企图通过 supervisorctl -c /etc/supervisord.conf 登录,发现还是报 refuse connection 的错误,还有

Error: Another program is already listening on a port that one of our HTTP servers is configured to use.  Shut this program down first before starting supervisord. 

尝试将[supervisorctl] 里面的属性 serverurl 修改成 unix 前缀,如 unix:///tmp/supervisord.sock,过一段时间再做观察。

进程管理工具-Supervisor安装与配置

Supervisor(http://supervisord.org/)是用Python开发的一个client/server服务,是Linux/Unix系统下的一个进程管理工具,不支持Windows系统。它可以很方便的监听、启动、停止、重启一个或多个进程。用Supervisor管理的进程,当一个进程意外被杀死,supervisort监听到进程死后,会自动将它重新拉起,很方便的做到进程自动恢复的功能,不再需要自己写shell脚本来控制。

因为Supervisor是Python开发的,安装前先检查一下系统否安装了Python2.4以上版本。下面以CentOS7,Python2.7版本环境下,介绍Supervisor的安装与配置步聚:

一、安装Python包管理工具(easy_install)

easy_install是setuptools包里带的一个命令,使用easy_install实际上是在调用setuptools来完成安装模块的工作,所以安装setuptools即可。

wget --no-check-certificate https://bootstrap.pypa.io/ez_setup.py -O - | sudo python

二、安装supervisor

easy_install supervisor

supervisor安装完成后会生成三个执行程序:supervisortd、supervisorctl、echo_supervisord_conf,分别是supervisor的守护进程服务(用于接收进程管理命令)、客户端(用于和守护进程通信,发送管理进程的指令)、生成初始配置文件程序。

三、配置

运行supervisord服务的时候,需要指定supervisor配置文件,如果没有显示指定,默认在以下目录查找:

$CWD/supervisord.conf
$CWD/etc/supervisord.conf
/etc/supervisord.conf
/etc/supervisor/supervisord.conf (since Supervisor 3.3.0)
../etc/supervisord.conf (Relative to the executable)
../supervisord.conf (Relative to the executable)

$CWD表示运行supervisord程序的目录。

可以通过运行echo_supervisord_conf程序生成supervisor的初始化配置文件,如下所示:

mkdir /etc/supervisor
echo_supervisord_conf > /etc/supervisor/supervisord.conf

四、配置文件参数说明

supervisor的配置参数较多,下面介绍一下常用的参数配置,详细的配置及说明,请参考官方文档介绍。
注:分号(;)开头的配置表示注释

[unix_http_server]  
file=/tmp/supervisor.sock   ;UNIX socket 文件,supervisorctl 会使用  
;chmod=0700                 ;socket文件的mode,默认是0700  
;chown=nobody:nogroup       ;socket文件的owner,格式:uid:gid  

;[inet_http_server]         ;HTTP服务器,提供web管理界面  
;port=127.0.0.1:9001        ;Web管理后台运行的IP和端口,如果开放到公网,需要注意安全性  
;username=user              ;登录管理后台的用户名  
;password=123               ;登录管理后台的密码  

[supervisord]  
logfile=/tmp/supervisord.log ;日志文件,默认是 $CWD/supervisord.log  
logfile_maxbytes=50MB        ;日志文件大小,超出会rotate,默认 50MB,如果设成0,表示不限制大小  
logfile_backups=10           ;日志文件保留备份数量默认10,设为0表示不备份  
loglevel=info                ;日志级别,默认info,其它: debug,warn,trace  
pidfile=/tmp/supervisord.pid ;pid 文件  
nodaemon=false               ;是否在前台启动,默认是false,即以 daemon 的方式启动  
minfds=1024                  ;可以打开的文件描述符的最小值,默认 1024  
minprocs=200                 ;可以打开的进程数的最小值,默认 200  

[supervisorctl]  
serverurl=unix:///tmp/supervisor.sock ;通过UNIX socket连接supervisord,路径与unix_http_server部分的file一致  
;serverurl=http://127.0.0.1:9001 ; 通过HTTP的方式连接supervisord  

; [program:xx]是被管理的进程配置参数,xx是进程的名称  
[program:xx]  
command=/opt/apache-tomcat-8.0.35/bin/catalina.sh run  ; 程序启动命令  
autostart=true       ; 在supervisord启动的时候也自动启动  
startsecs=10         ; 启动10秒后没有异常退出,就表示进程正常启动了,默认为1秒  
autorestart=true     ; 程序退出后自动重启,可选值:[unexpected,true,false],默认为unexpected,表示进程意外杀死后才重启  
startretries=3       ; 启动失败自动重试次数,默认是3  
user=tomcat          ; 用哪个用户启动进程,默认是root  
priority=999         ; 进程启动优先级,默认999,值小的优先启动  
redirect_stderr=true ; 把stderr重定向到stdout,默认false  
stdout_logfile_maxbytes=20MB  ; stdout 日志文件大小,默认50MB  
stdout_logfile_backups = 20   ; stdout 日志文件备份数,默认是10  
; stdout 日志文件,需要注意当指定目录不存在时无法正常启动,所以需要手动创建目录(supervisord 会自动创建日志文件)  
stdout_logfile=/opt/apache-tomcat-8.0.35/logs/catalina.out  
stopasgroup=false     ;默认为false,进程被杀死时,是否向这个进程组发送stop信号,包括子进程  
killasgroup=false     ;默认为false,向进程组发送kill信号,包括子进程  

;包含其它配置文件  
[include]  
files = relative/directory/*.ini    ;可以指定一个或多个以.ini结束的配置文件  

include示例:

[include]
files = /opt/absolute/filename.ini /opt/absolute/*.ini foo.conf config??.ini

注:INI文件是一个无固定标准格式的配置文件。它以简单的文字与简单的结构组成,常常使用在Windows操作系统,或是其他操作系统上,许多程序也会采用INI文件做为设置程序之用。Windows操作系统后来以注册表的形式取代掉INI档。INI文件的命名来源,是取自英文“初始(Initial)”的首字缩写,正与它的用途——初始化程序相应。有时候,INI文件也会以不同的扩展名,如“.CFG”、“.CONF”、或是“.TXT”代替。

五、配置管理进程

进程管理配置参数,不建议全都写在supervisord.conf文件中,应该每个进程写一个配置文件放在include指定的目录下包含进supervisord.conf文件中。
1> 创建/etc/supervisor/config.d目录,用于存放进程管理的配置文件
2> 修改/etc/supervisor/supervisord.conf中的include参数,将/etc/supervisor/conf.d目录添加到include中

[include]
files = /etc/supervisor/config.d/*.ini

未分类

下面是配置Tomcat进程的一个例子:

[program:tomcat]
command=/opt/apache-tomcat-8.0.35/bin/catalina.sh run
stdout_logfile=/opt/apache-tomcat-8.0.35/logs/catalina.out
autostart=true
autorestart=true
startsecs=5
priority=1
stopasgroup=true
killasgroup=true

六、启动Supervisor服务

supervisord -c /etc/supervisor/supervisord.conf

七、控制进程

7.1 交互终端

supervisord启动成功后,可以通过supervisorctl客户端控制进程,启动、停止、重启。运行supervisorctl命令,不加参数,会进入supervisor客户端的交互终端,并会列出当前所管理的所有进程。

未分类

上图中的tomcat就是我们在配置文件中[program:tomcat]指定的名字。

输入help可以查看可以执行的命令列表,如果想看某个命令的作用,运行help 命令名称,如:help stop

stop tomcat  // 表示停止tomcat进程
stop all     // 表示停止所有进程
// ...

7.2 bash终端

supervisorctl status
supervisorctl stop tomcat
supervisorctl start tomcat
supervisorctl restart tomcat
supervisorctl reread
supervisorctl update

7.3 Web管理界面

未分类

出于安全考虑,默认配置是没有开启web管理界面,需要修改supervisord.conf配置文件打开http访权限,将下面的配置:

;[inet_http_server]         ; inet (TCP) server disabled by default
;port=127.0.0.1:9001        ; (ip_address:port specifier, *:port for all iface)
;username=user              ; (default is no username (open server))
;password=123               ; (default is no password (open server))

修改成:

[inet_http_server]         ; inet (TCP) server disabled by default
port=0.0.0.0:9001          ; (ip_address:port specifier, *:port for all iface)
username=user              ; (default is no username (open server))
password=123               ; (default is no password (open server))

port:绑定访问IP和端口,这里是绑定的是本地IP和9001端口
username:登录管理后台的用户名
password:登录管理后台的密码

八、开机启动Supervisor服务

8.1 配置systemctl服务

1、进入/lib/systemd/system目录,并创建supervisor.service文件

[Unit]  
Description=supervisor  
After=network.target  

[Service]  
Type=forking  
ExecStart=/usr/bin/supervisord -c /etc/supervisor/supervisord.conf  
ExecStop=/usr/bin/supervisorctl $OPTIONS shutdown  
ExecReload=/usr/bin/supervisorctl $OPTIONS reload  
KillMode=process  
Restart=on-failure  
RestartSec=42s  

[Install]  
WantedBy=multi-user.target  

2、设置开机启动

systemctl enable supervisor.service
systemctl daemon-reload

3、修改文件权限为766

chmod 766 supervisor.service

8.2 配置service类型服务

#!/bin/bash  
#  
# supervisord   This scripts turns supervisord on  
#  
# Author:       Mike McGrath <[email protected]> (based off yumupdatesd)  
#  
# chkconfig:    - 95 04  
#  
# description:  supervisor is a process control utility.  It has a web based  
#               xmlrpc interface as well as a few other nifty features.  
# processname:  supervisord  
# config: /etc/supervisor/supervisord.conf  
# pidfile: /var/run/supervisord.pid  
#  

# source function library  
. /etc/rc.d/init.d/functions  

RETVAL=0  

start() {  
    echo -n $"Starting supervisord: "  
    daemon "supervisord -c /etc/supervisor/supervisord.conf "  
    RETVAL=$?  
    echo  
    [ $RETVAL -eq 0 ] && touch /var/lock/subsys/supervisord  
}  

stop() {  
    echo -n $"Stopping supervisord: "  
    killproc supervisord  
    echo  
    [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/supervisord  
}  

restart() {  
    stop  
    start  
}  

case "$1" in  
  start)  
    start  
    ;;  
  stop)   
    stop  
    ;;  
  restart|force-reload|reload)  
    restart  
    ;;  
  condrestart)  
    [ -f /var/lock/subsys/supervisord ] && restart  
    ;;  
  status)  
    status supervisord  
    RETVAL=$?  
    ;;  
  *)  
    echo $"Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"  
    exit 1  
esac  

exit $RETVAL  

将上述脚本内容保存到/etc/rc.d/init.d/supervisor文件中,修改文件权限为755,并设置开机启动

chmod 755 /etc/rc.d/init.d/supervisor
chkconfig supervisor on

注意:修改脚本中supervisor配置文件路径为你的supervisor的配置文件路径

其它Linux发行版开机启动脚本:https://github.com/Supervisor/initscripts

注意:

Supervisor只能管理非daemon的进程,也就是说Supervisor不能管理守护进程。否则提示Exited too quickly (process log may have details)异常。例子中的Tomcat默认是以守护进程启动的,所以我们改成了catalina.sh run,以前台进程的方式运行。

yum方式安装

yum install epel-release
yum install -y supervisor

supervisor没有发布在标准的CentOS源在,需要安装epel源。这种方式安装的可能不是最新版本,但比较方便,安装完成之后,配置文件会自动帮你生成。
默认配置文件:/etc/supervisord.conf
进程管理配置文件放到:/etc/supervisord.d/目录下即可

默认日志文件:/tmp/supervisord.log,可以查看进程的启动信息。