菜鸟学习Nginx之平滑升级

最新推荐文章于 2024-05-11 07:56:34 发布
最新推荐文章于 2024-05-11 07:56:34 发布
阅读量665 收藏 2
点赞数
分类专栏： 开源软件 Nginx 文章标签： Nginx平滑升级 Nginx热部署 Nginx版本升级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxb249/article/details/84797864
版权

Nginx高可用、高可靠性体现它的平滑升级--在升级过程中能够保证业务不间断，那它是如何实现的呢？接下来我们一起探讨它的实现原理。

一、升级过程

1.1、查看进程信息

先通过命令行感性的了解一下Nginx是如何进行平滑升级的？首先通过命令行查看进程信息，可知，一个master进程、两个worker进程，如下所示：

[root@localhost ~]# ps -ef | grep nginx | grep -v grep
root      2850     1  0 08:24 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2851  2850  0 08:24 ?        00:00:00 nginx: worker process      
root      2852  2850  0 08:24 ?        00:00:00 nginx: worker process      
[root@localhost ~]#

地址监听信息如下： 

[root@localhost ~]# netstat -apn | grep tcp| grep nginx 
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      2850/nginx          
[root@localhost ~]#

1.2、升级版本

通过命令行，发送SIGUSR2给master进程（Nginx定义SIGUSR2是版本升级），进行版本升级。

[root@localhost ~]# kill -USR2 `cat /usr/local/nginx/logs/nginx.pid`
[root@localhost ~]#
[root@localhost ~]# ps -ef | grep nginx | grep -v grep
root      2850     1  0 08:24 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2851  2850  0 08:24 ?        00:00:00 nginx: worker process      
root      2852  2850  0 08:24 ?        00:00:00 nginx: worker process      
root      2942  2850  0 08:39 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2943  2942  0 08:39 ?        00:00:00 nginx: worker process      
root      2944  2942  0 08:39 ?        00:00:00 nginx: worker process      
[root@localhost ~]#

变化内容：

1）会发现会多出一组master和worker进行（新master进程id是2942，新woker进程是2943、2944） ，其中新master进程的父进程是2850，即旧master进程。

2）nginx.pid文件发生改变，变成新的master进程id，这点很重要，后面再操作nginx.pid时，应该警惕，如下：

[root@localhost ~]# 
[root@localhost ~]# cat /usr/local/nginx/logs/nginx.pid
2942
[root@localhost ~]#

地址监听信息，没有变化：

[root@localhost ~]# netstat -apn | grep tcp| grep nginx
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      2850/nginx          
[root@localhost ~]#

此时我们进行访问Nginx服务（浏览器输入地址），然后查看链接信息：

[root@localhost ~]# 
[root@localhost ~]# netstat -apn | grep tcp| grep nginx
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      2850/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52980          ESTABLISHED 2944/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52979          ESTABLISHED 2944/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52983          ESTABLISHED 2944/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52981          ESTABLISHED 2944/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52982          ESTABLISHED 2851/nginx          
tcp        0      0 192.168.12.129:80           192.168.12.1:52984          ESTABLISHED 2943/nginx          
[root@localhost ~]#

发现提供服务worker进程分别是2944、2851、2943，其中2851是旧worker进程。

1.3、旧版本服务下线

通过发送WINCH信号，使旧版本worker进程不在处理新请求且结束进程，注意：发送WINCH，不能使用nginx.pid文件，必须使用进程id。

[root@localhost ~]# 
[root@localhost ~]#  kill -WINCH 2850
[root@localhost ~]# 
[root@localhost ~]# ps -ef|grep nginx |grep -v grep
root      2850     1  0 09:04 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2942  2850  0 09:06 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2943  2942  0 09:06 ?        00:00:00 nginx: worker process      
root      2944  2942  0 09:06 ?        00:00:00 nginx: worker process      
[root@localhost ~]#
[root@localhost ~]# netstat -apn | grep nginx |grep tcp
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      2850/nginx   
[root@localhost ~]#

通过查看命令行可知，旧worker进程都已经退出，但是旧的master进程并没有退出，此时监听地址信息，进程id号仍然是旧master进程id号。

1.4、关闭旧master进程

关闭旧master进程，可以直接通过kill命令行，将其杀死，如下：

[root@localhost ~]# kill 2580
[root@localhost ~]# ps -ef|grep nginx |grep -v grep
root      2942     1  0 09:06 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
root      2943  2942  0 09:06 ?        00:00:00 nginx: worker process      
root      2944  2942  0 09:06 ?        00:00:00 nginx: worker process      
[root@localhost ~]#

最后查看，监听信息，进程信息变成新master进程id：

[root@localhost ~]# netstat -apn | grep nginx |grep tcp
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      2942/nginx          
[root@localhost ~]# 
[root@localhost ~]#

二、升级实现原理

上面只是演示如何进行平滑升级，这里再从源码级别深入探讨平滑升级的流程。

通过上面演示，可知Nginx进行平滑升级采用的是进程间通信方式--信号。通过命令行kill（也是一个进程）发送信号给master进程，那么master进程才可以针对不同信号进行处理。既然是通过信号方式，必然要先注册信号，否则应用程序是无法处理的。

2.1、信号注册

信号注册是在main函数中调用，信号注册方式一般有两种，一种signal和sigaction，nginx采用sigaction，如下：

ngx_int_t
ngx_init_signals(ngx_log_t *log)
{
    ngx_signal_t      *sig;
    struct sigaction   sa;

    for (sig = signals; sig->signo != 0; sig++) {
        ngx_memzero(&sa, sizeof(struct sigaction));
        sa.sa_handler = sig->handler;
        sigemptyset(&sa.sa_mask);
        if (sigaction(sig->signo, &sa, NULL) == -1) {//注册信号，当信号发生由sig->handler处理
#if (NGX_VALGRIND)
            ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
                          "sigaction(%s) failed, ignored", sig->signame);
#else
            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                          "sigaction(%s) failed", sig->signame);
            return NGX_ERROR;
#endif
        }
    }

    return NGX_OK;
}

信号表signals主要定义信号和处理函数映射关系，具体定义如下：

ngx_signal_t  signals[] = {
    { ngx_signal_value(NGX_RECONFIGURE_SIGNAL),
      "SIG" ngx_value(NGX_RECONFIGURE_SIGNAL),
      "reload",
      ngx_signal_handler },
    { ngx_signal_value(NGX_REOPEN_SIGNAL),
      "SIG" ngx_value(NGX_REOPEN_SIGNAL),
      "reopen",
      ngx_signal_handler },
    { ngx_signal_value(NGX_NOACCEPT_SIGNAL),
      "SIG" ngx_value(NGX_NOACCEPT_SIGNAL),
      "",
      ngx_signal_handler },
    { ngx_signal_value(NGX_TERMINATE_SIGNAL),
      "SIG" ngx_value(NGX_TERMINATE_SIGNAL),
      "stop",
      ngx_signal_handler },
    { ngx_signal_value(NGX_SHUTDOWN_SIGNAL),
      "SIG" ngx_value(NGX_SHUTDOWN_SIGNAL),
      "quit",
      ngx_signal_handler },
    { ngx_signal_value(NGX_CHANGEBIN_SIGNAL),
      "SIG" ngx_value(NGX_CHANGEBIN_SIGNAL),
      "",
      ngx_signal_handler },
    { SIGALRM, "SIGALRM", "", ngx_signal_handler },
    { SIGINT, "SIGINT", "", ngx_signal_handler },
    { SIGIO, "SIGIO", "", ngx_signal_handler },
    { SIGCHLD, "SIGCHLD", "", ngx_signal_handler },
    { SIGSYS, "SIGSYS, SIG_IGN", "", SIG_IGN },
    { SIGPIPE, "SIGPIPE, SIG_IGN", "", SIG_IGN },
    { 0, NULL, "", NULL }
};

2.2 、信号处理

  由上一小节可知，信号处理函数均是ngx_signal_handler方法：

static void
ngx_signal_handler(int signo)
{
    char            *action;
    ngx_int_t        ignore;
    ngx_err_t        err;
    ngx_signal_t    *sig;

    ignore = 0;

    err = ngx_errno;

    for (sig = signals; sig->signo != 0; sig++) {//根据信号 查找具体信号组
        if (sig->signo == signo) {
            break;
        }
    }

    ngx_time_sigsafe_update();//跟新时间

    action = "";

    switch (ngx_process) {//ngx_process代表当前进程角色
    /* master进程 */
    case NGX_PROCESS_MASTER:
    case NGX_PROCESS_SINGLE:
        switch (signo) {

        case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
            ngx_quit = 1;
            action = ", shutting down";
            break;

        case ngx_signal_value(NGX_TERMINATE_SIGNAL):
        case SIGINT:
            ngx_terminate = 1;
            action = ", exiting";
            break;

        case ngx_signal_value(NGX_NOACCEPT_SIGNAL):
            if (ngx_daemonized) {
                ngx_noaccept = 1;
                action = ", stop accepting connections";
            }
            break;

        case ngx_signal_value(NGX_RECONFIGURE_SIGNAL):
            ngx_reconfigure = 1;
            action = ", reconfiguring";
            break;

        case ngx_signal_value(NGX_REOPEN_SIGNAL):
            ngx_reopen = 1;
            action = ", reopening logs";
            break;
        /* 平滑升级 接收到的信号 */
        case ngx_signal_value(NGX_CHANGEBIN_SIGNAL):
            if (getppid() > 1 || ngx_new_binary > 0) {

                /*
                 * Ignore the signal in the new binary if its parent is
                 * not the init process, i.e. the old binary's process
                 * is still running.  Or ignore the signal in the old binary's
                 * process if the new binary's process is already running.
                 */

                action = ", ignoring";
                ignore = 1;
                break;
            }

            ngx_change_binary = 1;//这里只是把标志位设置为1
            action = ", changing binary"; 
            break;

        case SIGALRM:
            ngx_sigalrm = 1;
            break;

        case SIGIO:
            ngx_sigio = 1;
            break;
        /**
         * 当worker进程异常退出时，会向父进程发送SIGCHLD信号
         * 当master进程收到该信号，就会重新调度起worker进程
         */
        case SIGCHLD:
            ngx_reap = 1;
            break;
        }

        break;
    /* worker进程 */
    case NGX_PROCESS_WORKER:
    case NGX_PROCESS_HELPER:
        switch (signo) {

        case ngx_signal_value(NGX_NOACCEPT_SIGNAL):
            if (!ngx_daemonized) {
                break;
            }
            ngx_debug_quit = 1;
            /* fall through */
        case ngx_signal_value(NGX_SHUTDOWN_SIGNAL):
            ngx_quit = 1;
            action = ", shutting down";
            break;

        case ngx_signal_value(NGX_TERMINATE_SIGNAL):
        case SIGINT:
            ngx_terminate = 1;
            action = ", exiting";
            break;

        case ngx_signal_value(NGX_REOPEN_SIGNAL):
            ngx_reopen = 1;
            action = ", reopening logs";
            break;

        case ngx_signal_value(NGX_RECONFIGURE_SIGNAL):
        case ngx_signal_value(NGX_CHANGEBIN_SIGNAL):
        case SIGIO:
            action = ", ignoring";
            break;
        }

        break;
    }

    ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
                  "signal %d (%s) received%s", signo, sig->signame, action);

    if (ignore) {
        ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, 0,
                      "the changing binary signal is ignored: "
                      "you should shutdown or terminate "
                      "before either old or new binary's process");
    }

    if (signo == SIGCHLD) {//当子进程异常退出时，需要修改退出的子进程的状态
        ngx_process_get_status();
    }

    ngx_set_errno(err);
}

2.3、信号产生方式

有两种方式处理方式：一种是nginx自身发起信号，一种是kill命令行。针对平滑升级来说，我们通过kill方式，发送USR2信号给master进程，因此上面流程会进入：

/* 平滑升级 接收到的信号 */
case ngx_signal_value(NGX_CHANGEBIN_SIGNAL):
	if (getppid() > 1 || ngx_new_binary > 0) {

		/*
		 * Ignore the signal in the new binary if its parent is
		 * not the init process, i.e. the old binary's process
		 * is still running.  Or ignore the signal in the old binary's
		 * process if the new binary's process is already running.
		 */

		action = ", ignoring";
		ignore = 1;
		break;
	}

	ngx_change_binary = 1;//这里只是把标志位设置为1
	action = ", changing binary"; 
	break;

 此时退出该函数表示，信号中断处理函数已经结束，那么master进程应该如何处理呢？

三、信号事件后续处理

我们在《菜鸟学习Nginx之启动流程2》已经说明了，master进程会阻塞在sigsuspend函数这里，当有信号产生时，进程会被中断，转而调用信号处理函数。当信号处理函数结束后sigsuspend阻塞函数返回，执行后续代码流程。这段流程需要谨记于心。

        /**
         * 当master进程接收到USR2信号，表明进行平滑升级
         */
        if (ngx_change_binary)
        {
            ngx_change_binary = 0;
            ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "changing binary");
            ngx_new_binary = ngx_exec_new_binary(cycle, ngx_argv);
        }

进入ngx_exec_new_binary函数：

ngx_pid_t
ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
{
    char             **env, *var;
    u_char            *p;
    ngx_uint_t         i, n;
    ngx_pid_t          pid;
    ngx_exec_ctx_t     ctx;
    ngx_core_conf_t   *ccf;
    ngx_listening_t   *ls;

    ngx_memzero(&ctx, sizeof(ngx_exec_ctx_t));

    ctx.path = argv[0];
    ctx.name = "new binary process";
    ctx.argv = argv;

    n = 2;
    env = ngx_set_environment(cycle, &n);
    if (env == NULL) {
        return NGX_INVALID_PID;
    }

    var = ngx_alloc(sizeof(NGINX_VAR)
                    + cycle->listening.nelts * (NGX_INT32_LEN + 1) + 2,
                    cycle->log);
    if (var == NULL) {
        ngx_free(env);
        return NGX_INVALID_PID;
    }

    p = ngx_cpymem(var, NGINX_VAR "=", sizeof(NGINX_VAR));

    ls = cycle->listening.elts;
    for (i = 0; i < cycle->listening.nelts; i++) {
        p = ngx_sprintf(p, "%ud;", ls[i].fd);
    }

    *p = '\0';

    env[n++] = var;

#if (NGX_SETPROCTITLE_USES_ENV)

    /* allocate the spare 300 bytes for the new binary process title */

    env[n++] = "SPARE=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
               "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
               "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
               "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
               "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

#endif

    env[n] = NULL;

#if (NGX_DEBUG)
    {
    char  **e;
    for (e = env; *e; e++) {
        ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0, "env: %s", *e);
    }
    }
#endif

    ctx.envp = (char *const *) env;

    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
    //重命名pid文件 把旧的pid文件重名为pid.old
    if (ngx_rename_file(ccf->pid.data, ccf->oldpid.data) == NGX_FILE_ERROR) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      ngx_rename_file_n " %s to %s failed "
                      "before executing new binary process \"%s\"",
                      ccf->pid.data, ccf->oldpid.data, argv[0]);

        ngx_free(env);
        ngx_free(var);

        return NGX_INVALID_PID;
    }

    pid = ngx_execute(cycle, &ctx);/* 执行exec家族函数 启动新进程 */

    if (pid == NGX_INVALID_PID) {
        if (ngx_rename_file(ccf->oldpid.data, ccf->pid.data)
            == NGX_FILE_ERROR)
        {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          ngx_rename_file_n " %s back to %s failed after "
                          "an attempt to execute new binary process \"%s\"",
                          ccf->oldpid.data, ccf->pid.data, argv[0]);
        }
    }

    ngx_free(env);
    ngx_free(var);

    return pid;
}

ngx_pid_t
ngx_execute(ngx_cycle_t *cycle, ngx_exec_ctx_t *ctx)
{
    return ngx_spawn_process(cycle, ngx_execute_proc, ctx, ctx->name,
                             NGX_PROCESS_DETACHED);
}

static void
ngx_execute_proc(ngx_cycle_t *cycle, void *data)
{
    ngx_exec_ctx_t  *ctx = data;

    /**
     * 如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno 中
     * 当执行成功之后进程上下文就会切换，因此也没有必要返回
     */
    if (execve(ctx->path, ctx->argv, ctx->envp) == -1) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "execve() failed while executing %s \"%s\"",
                      ctx->name, ctx->path);
    }

    exit(1);
}

四、总结

这里有一个问题：新进程是如何将继续监听原先listening socket呢？主要通过两种方式：

1、启动平滑升级时，旧master会把监听socket文件句柄(数字)写到环境变量中。

2、旧master在fork出子进程后，从环境变量中读取出listen socket，然后子进程在执行exec函数，进行替换。这里需要提示父子进程空间是共享的，所以子进程可以操作listen socket。

Nginx这种升级方式，是比较经典的升级方式，为了日后工作提供了指导方向。但是我个人感觉Nginx升级方式有点不完美，不完美之处在于需要敲三次命令行，才能完成升级。

xxb249
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解nginx平滑升级的过程
09-30
**Nginx 平滑升级过程详解** 在 IT 领域，特别是在 Web 服务器管理中，保持软件的更新和安全至关重要。Nginx 是一款高性能的 HTTP 和反向代理服务器，广泛应用于网站服务。当有新版本发布时，平滑升级 Nginx 可以...
Nginx 菜鸟教程从初学到应用
持续学习，持续更新
07-17 4405
虚拟主机是一种特殊的软硬件技术，它可以将网络上的每一台计算机分成多个虚拟主机，每个虚拟主机可以独立对外提供www服务，这样就可以实现一台主机对外提供多个web服务，每个虚拟主机之间是独立的，互不影响的。需要再html中新建nihao.com和wohao.com,里面都新建一个index.html。通过nginx可以实现虚拟主机的配置，nginx支持三种类型的虚拟主机配置。配置两个虚拟主机,一个端口88，一个端口80。请求80端口显示的为nihao。88端口显示的wohao。在请求一下88端口的。......
Nginx源码分析与实践---进程间通信机制（信号）
ZX714311728的博客
03-28 1196
在前面我们分析了nginx进程间通信机制的共享内存和套接字。这次我们分析剩下一种进程间通信机制---信号。 首先要区分信号和信号量：信号是用于进程间通信的机制，而信号量是用于保证共享资源不被并发访问的机制，如可使用信号量作为互斥锁实现多进程下对共享资源的同步。 1.nginx中什么地方用到了信号？ 比如我们输入命令：./nginx -s reload或./nginx -s stop，
最全nginx的平滑升级（热部署）_nginx平滑升级的项目实施方案，2024年最新已获千赞
最新发布
2401_84563933的博客
05-11 1220
【代码】最全nginx的平滑升级（热部署）_nginx平滑升级的项目实施方案，2024年最新已获千赞。
菜鸟学习Nginx之启动流程(2)
程序员的世界
12-06 397
上一篇介绍了启动流程中关于初始化ngx_cycle_t。由于ngx_cycle_t是Nginx核心结构，Nginx整个架构均是围绕它构建起来的。虽然用了一整篇文章介绍ngx_cycle_t，但是感觉还是有些内容没有介绍清楚。初始化ngx_cycle_t有一部分代码没有介绍，ngx_conf_parse，该函数解析配置文件nginx.conf函数。此函数就是单纯解析配置文件，里面代码比较枯燥乏味，理...
nginx平滑升级
多看多听多总结
02-18 754
nginx平滑升级
Nginx简单了解
weixin_46249709的博客
11-29 1378
nginx
Nginx平滑升级的详细操作方法
09-30
主要介绍了Nginx平滑升级的详细操作方法,适应编译安装ningx的情况,yum安装的直接用yum更新即可,需要的朋友可以参考下
nginx1.8平滑升级
11-16
nginx 1.8 平滑升级到 1.11.2 本文档旨在介绍如何将 nginx 1.8 版本平滑升级到 1.11.2 版本。平滑升级是指不停机升级，保证服务不中断的升级方式。 在开始升级之前，我们需要了解当前 nginx 的版本信息。使用命令 ...
Nginx1.8.0版本平滑升级新版本1.9.7
09-30
在本文中，我们将详细探讨如何进行Nginx 1.8.0版本到1.9.7版本的平滑升级过程。平滑升级是确保Web服务器在不中断服务的情况下更新软件的重要方法，这对于保持系统安全性和性能至关重要。 首先，确认当前运行的Nginx...
Nginx实现平滑升级
RAB
09-25 3297
Nginx实现平滑升级。
Nginx平滑升级版本或添加模块
秦子腾
06-12 1万+
原因：Nginx平滑升级是根据环境变量来进行的 ，找不到 nginx目录 是因为上次启动nginx不是 使用完全路径启动的 而环境变量中并没有 nginx这个目录 所以导致 这个问题！一般有两种情况下需要升级 nginx，一种是确实要升级 nginx 的版本，另一种是要为 nginx 添加新的模块。问题：执行完成 “发送平滑迁移信号 USR2” 没有出现新的Master进程信息。发送平滑迁移信号 USR2: 启动新的主进程，实现热升级。按照原来的编译参数安装 nginx 的方法进行安装，
nginx-----master中的信号处理
simply the best
12-25 1506
1.nginx信号集 ngx_signal_t signals[] = { { ngx_signal_value(NGX_RECONFIGURE_SIGNAL), "SIG" ngx_value(NGX_RECONFIGURE_SIGNAL), "reload", ngx_signal_handler }, { ngx_signal_va
nginx报错"worker_processes" directive is duplicate
热门推荐
network_dream的博客
01-23 1万+
查看nginx的错误日志error.log 报错信息：“worker_processes”指令重复在nginx.conf 发现nginx.conf配置出现了两份。不知道什么原因生成的两份。 解决：删除一份，重启成功。 ...
nginx worker process未启动，导致curl无法正常访问
u013220323的专栏
11-25 1295
nginx 通过浏览器无法正常访问问题
nginx信号及平滑升级
weixin_30312563的博客
09-03 75
1、nginx信号 nginx进程处理命令： kill -signals PID PID即nginx进程ID signals的参数解释如下所示： TERM,INT快速关闭进程 QUIT优雅的关闭，如果有请求则等待请求结束后停止 HUP 重载新的配置文件，对于旧的进程还用旧的配置文件，新的进程会使用新的配置文件 USR1重新打开日志文件，常用于日志切割 ...
如何对nginx进行平滑升级
仗剑走天涯的博客
12-21 3762
nginx平滑升级，不影响线上业务的运行 这里nginx的安装目录是：nginx 第一步：查看nginx版本号： [root@localhost nginx-web]# nginx -v nginx version: nginx/1.15.12 这里的版本号是1.10.3，对比下官网的版本号： 第二步：下载上传并解压nginx安装包 我这里下载的是1.21.4的版本号 nginx-1.21.4，下载下来后上传到服务器， 下载地址：http://nginx.org/en/downloa
Nginx平滑升级及添加新功能
weixin_72435491的博客
10-12 680
Nginx平滑升级及添加新功能
nginx 平滑升级
09-14
Nginx 平滑升级是指在不中断服务的情况下更新 Nginx 服务器的版本或配置。下面是一种常用的平滑升级方法： 1. 备份 Nginx 配置文件和相关的配置目录。 2. 下载新版本的 Nginx，并解压到一个新的目录。 3. 在新版本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值