精华内容
下载资源
问答
  • 简单瞧瞧uwsgi源码

    2019-10-08 23:31:16
    文章目录uwsgi.c做了什么 uwsgi.c做了什么 core/uwsgi.c: ... // !!!初始化socket协议!!! // initialize socket protocols (do it after caching !!!) uwsgi_protocols_register(); ... // !!! 绑定...

    uwsgi.c做了什么

    core/uwsgi.c:
    ...
    
        // !!!初始化socket协议!!!
        // initialize socket protocols (do it after caching !!!)
        uwsgi_protocols_register();
        ...
    
        // !!! 绑定所有未绑定的socket !!!
        uwsgi_bind_sockets();
        
        // put listening socket in non-blocking state and set the protocol
        uwsgi_set_sockets_protocols();
        ...
        
        // initialize request plugin only if workers or master are available
        if (uwsgi.sockets || uwsgi.master_process || uwsgi.no_server || uwsgi.command_mode || uwsgi.loop) {
            for (i = 0; i < 256; i++) {
                if (uwsgi.p[i]->init) {
                    uwsgi.p[i]->init();
                }    
            }    
        }
        ...
    
        if (uwsgi.has_threads) {
            ...
            // again check for workers/sockets...
            if (uwsgi.sockets || uwsgi.master_process || uwsgi.no_server || uwsgi.command_mode || uwsgi.loop) {
                for (i = 0; i < 256; i++) {
                    if (uwsgi.p[i]->enable_threads)
                        uwsgi.p[i]->enable_threads();
                }
            }
        }
        ...
    
        //init apps hook (if not lazy)
        if (!uwsgi.lazy && !uwsgi.lazy_apps) {
            uwsgi_init_all_apps();
        }
        ...
    
    
        if (!uwsgi.status.is_cheap) {
            if (uwsgi.cheaper && uwsgi.cheaper_count) {
                int nproc = uwsgi.cheaper_initial;
                if (!nproc)
                    nproc = uwsgi.cheaper_count;
                for (i = 1; i <= uwsgi.numproc; i++) {
                    if (i <= nproc) {
                        if (uwsgi_respawn_worker(i))
                            break;
                        uwsgi.respawn_delta = uwsgi_now();
                    }    
                    else {
                        uwsgi.workers[i].cheaped = 1; 
                    }    
                }    
            } 
        ...
    }
    

    uwsgi_start中uwsgi_protocols_register做了什么

    主要是初始化socket协议在这里插入图片描述

    展开全文
  • uwsgi:uWSGI应用程序服务器容器
  • 一.uWSGI下载地址 https://uwsgi-docs.readthedocs.io/en/latest/Download.html 二.安装 1.下载 wget https://projects.unbit.it/downloads/uwsgi-2.0.17.1.tar.gz 2.解压 tar -zxvf uwsgi-2.0.17.1.tar.gz ...

    一.uWSGI下载地址

    https://uwsgi-docs.readthedocs.io/en/latest/Download.html

    二.安装

    1.下载

    wget https://projects.unbit.it/downloads/uwsgi-2.0.17.1.tar.gz

    2.解压

    tar -zxvf uwsgi-2.0.17.1.tar.gz

    3.进入到解压目录

    cd uwsgi-2.0.17.1/

    4.安装

    python3 setup.py install
    

    三.启动

    如上图,这表明你的uwsgi已经在启动路径了。最后只需要结合项目进行配置,然后再运行。

    四.参考资料

    [1] uWSGI官方文档 https://uwsgi-docs.readthedocs.io/en/latest/

     

     

     

     

     

     

     

     

    展开全文
  • The uWSGI project For official documentation check: https://uwsgi-docs.readthedocs.org/en/latest/ For commercial support check: http://unbit.com/
  • 问题来源曾经遇到过一个项目涉及到了上传商品图片的问题,而我在限制图片大小的时候,是先把整个图片...但后来觉得,如果图片是先由前端的nginx完全读取后再转发给uwsgi的,那这样判断依然会影响nginx的性能。为此,我

    问题来源

    曾经遇到过一个项目涉及到了上传商品图片的问题,而我在限制图片大小的时候,是先把整个图片都读取到内存中,然后再判断其大小。这种做法当出现恶意攻击或者图片很大时,会严重影响web application的性能。原先想通过先判断首部的content-length来对大小进行限制。但后来觉得,如果图片是先由前端的nginx完全读取后再转发给uwsgi的,那这样判断依然会影响nginx的性能。为此,我查看了nginx的源码,找到了nginx和uwsgi的通信过程,下面是整个通信的具体流程。

    设置回调函数

    我们知道,nginx把浏览器等发过来的请求通过proxy_pass或者uwsgi_pass转发给上游的web application进行处理,然后把处理的结果发送给浏览器。uwsgi_pass命令的处理函数为ngx_http_uwsgi_handler,也就是说,当有请求到达配置uwsgi_pass的location时,会调用ngx_http_uwsgi_handler方法,而该方法是整个uwsgi事件处理的入口方法。下面来看该方法:

    static ngx_int_t ngx_http_uwsgi_handler(ngx_http_request_t *r)
    {
        ngx_http_upstream_t *u;
        ngx_http_uwsgi_loc_conf_t   *uwcf;
        uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);
        u = r->upstream;
        ……
        u->create_request = ngx_http_uwsgi_create_request;//根据wsgi协议创建请求包体
        u->process_header = ngx_http_uwsgi_process_status_line;//根据wsgi协议解析uwsgi发送来的头部
        ……
        rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);//从浏览器读取body数据
        ……
    }
    

    该方法的首先创建一个ngx_http_upstream_t 结构体,然后设置该结构体的几个回调函数。nginx是一个高度模块化的web server,每一个功能都是通过一个模块来实现的,和uwsgi的通信也不例外。整个通信过程是在都是由ngx_http_uwsgi_module.c这个模块文件实现的。当然,要想把每一个模块添加到nginx中,必须要有一些钩子,在nginx中就是一些链表,然后把每一个模块的处理方法添加到这些链表中,这样就会被nginx框架代码逐一调用。而与web application通信的的钩子文件就是ngx_http_upstream.c文件,至于nginx是在何时触发这些钩子函数的,简单的说就是把这些钩子函数赋值给epoll的读写事件,当有读写请求时,epoll的事件响应机制就会调用这些钩子函数。大家可以看到,上面的钩子函数,只有构造请求体,解析响应头部,确没有对包体的处理,这是因为,nginx根本不需要对包体进行处理,只是简单的存储转发。

    从浏览器读取数据

    首先看nginx如何决定需要从浏览器读取多少数据,这个很明显是由content-length首部决定的,但也会受到client_max_body_size指令的影响。我们可以在nginx.conf中添加client_max_body_size配置指令,该指令可以放在http、server和location三个地方。nginx读取完头部之后,会调用src/http/ngx_http_core_module.c文件中ngx_http_core_find_config_phase方法去根据重写后的URI检索出匹配的location块,此时配置文件已经合并完成,只是简单的检索。如果发现配置了client_max_body_size配置文件,则会通过下面的比较来判断请求体是否超过给定的大小:

    ngx_int_t ngx_http_core_find_config_phase(ngx_http_request_t *r, ngx_http_phase_handler_t *ph)
    {
        if (clcf->client_max_body_size < r->headers_in.content_length_n)
        {
          ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,"client intended to send too large body: %O bytes",
                r->headers_in.content_length_n);
        }
    }
    

    如果没有超过设定的大小,那么就把ngx_http_request_body_t结构体中rest设置为content-length的大小,表示需要读取的字节数。
    下面我们来看看真正的读取方法ngx_http_read_client_request_body,该方法传入了一个回调函数ngx_http_upstream_init,而该回调函数就是开启nginx和上游通信的入口。注意,虽然ngx_http_read_client_request_body方法不会阻塞,即当没有数据接收时会立即返回,但是,只有当数据全部接收完毕,才会调用ngx_http_upstream_init方法,具体的实现我们来看代码:

    ngx_int_t  ngx_http_read_client_request_body(ngx_http_request_t *r, ngx_http_client_body_handler_pt post_handler) 
    {
        if (rb->rest == 0) { /* 已经全部接收完body */
            if (r->request_body_in_file_only) {
                ngx_http_write_request_body(r); /* 把缓冲区的数据写入文件 */
            }
            post_handler(r); /* 调用回调函数,即ngx_http_upstream_init */
        }
        r->read_event_handler = ngx_http_read_client_request_body_handler;//设置读事件
        rc = ngx_http_do_read_client_request_body(r);
    }
    

    由此可以看出,如果读取完毕,则调用ngx_http_upstream_init开始和uwsgi进行通信,如果没有,则首先把读事件设置为ngx_http_read_client_request_body_handler方法,该方法内部除了做一些错误检查,还是仍然调用ngx_http_read_client_request_body方法,也就是说只要没读取完所有的body,nginx会通知epoll一直调用本方法进行body的读取操作。在该方法的最后,调用ngx_http_do_read_client_request_body方法进行真正的读取操作。

    static ngx_int_t  ngx_http_do_read_client_request_body(ngx_http_request_t *r) 
    {
        for ( ;; ) {
            for ( ;; ) {
                if (rb->buf->last == rb->buf->end) { /* 请求的request_body成员中的buf缓冲区已写满 */
                    rc = ngx_http_request_body_filter(r, &out);/* 对数据进行过滤并把数据移入请求体缓存中,如果空间不够,则存入临时文件 */
                }
    
                n = c->recv(c, rb->buf->last, size); //从套接字缓冲区读取包体到缓冲区中
                if (rb->rest == 0) { //已经接收到了完整的包体
                    break;
                }
            }
        }
        if (rb->temp_file || r->request_body_in_file_only) {
            ngx_http_write_request_body(r); //把数据移入请求体缓存中,如果空间不够,则存入临时文件
        }
        if (!r->request_body_no_buffering) { //nginx可以通过proxy_request_buffering关闭缓存
            r->read_event_handler = ngx_http_block_reading;
            rb->post_handler(r);//调用ngx_http_upstream_init方法
        }
        return NGX_OK;
    }
    

    从上面可以看到,如果开启了proxy_request_buffering(默认开启),则nginx是把所有的数据都读取到之后,再发送给uwsgi。

    发送数据给uwsgi

    下面看整个通信的入口函数ngx_http_upstream_init:

    void  ngx_http_upstream_init(ngx_http_request_t *r) 
    {
        ngx_http_upstream_init_request(r);
    }
    
    static void ngx_http_upstream_init_request(ngx_http_request_t *r)
    {
        u->create_request(r);//调用ngx_http_uwsgi_create_request创建请求包体
        ngx_http_upstream_connect(r, u);//建立和uwsgi的连接
    }
    

    在ngx_http_uwsgi_create_request方法中,主要的工作就是根据wsgi协议构建请求报文,主要是首部信息,然后通过建立的连接把报文发送给uwsgi。在方法ngx_http_upstream_connect中,设置了和uwsgi通信的方法:

    static void  ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)  
    {
        ……
        rc = ngx_event_connect_peer(&u->peer); //真正进行请求建立连接工作
        u->write_event_handler = ngx_http_upstream_send_request_handler; //设置向uwsgi发送请求的方法
        u->read_event_handler = ngx_http_upstream_process_header; //设置接收uwsgi请求的方法
        ……
        ngx_http_upstream_send_request(r, u, 1); //调用该方法向上游服务器发送请求
    }
    

    从uwsgi读取头部信息

    由此可知,当从uwsgi发送数据到nginx时,会触发读事件,即调用ngx_http_upstream_process_header方法:

    static void  ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u) 
    {
        for ( ;; ) {
            n = c->recv(c, u->buffer.last, u->buffer.end - u->buffer.last); //从uwsgi接收头部数据
            if (n == NGX_AGAIN) { //如果数据不够,则继续加入epoll中
                ngx_handle_read_event(c->read, 0);
            }
            rc = u->process_header(r); //调用uwsgi设置的回调函数ngx_http_uwsgi_process_status_line解析状态吗和头部
            if (rc == NGX_AGAIN) { //接收的数据不够,继续读取
             continue;
             }
            break;
        }
        /* rc == NGX_OK:解析到完整的包头 */
        if (!r->subrequest_in_memory) {
            ngx_http_upstream_send_response(r, u);//开始转发响应头部给客户端
            return;
        }
    }
    

    解析完头部信息后,就会调用ngx_http_upstream_process_header中最后的ngx_http_upstream_send_response方法发送响应头给客户端。另外在该方法中,就会涉及到用户在配置uwsgi时,是否开启接收uwsgi_buffering标志(默认开启)。如果开启,则nginx会尽可能多的把数据缓存下来再发送给浏览器,如果内存缓存不够,则会存入临时文件;如果被用户关闭,则nginx最多只缓存uwsgi_buffer_size大小的body,当缓存满时,会导致后端基于阻塞模型的uwsgi无法send而阻塞。下面分别讨论这两种情况下的数据传输。

    未开启缓存的情况下从uwsgi读取包体并转发

    在uwsgi_buffering设置为off的情况下,从uwsgi读取body和发送body给浏览器的方法分别为ngx_http_upstream_process_non_buffered_upstream和ngx_http_upstream_process_non_buffered_downstream。而这两个方法内部都是调用了ngx_http_upstream_process_non_buffered_request方法,下面具体来看该方法:

    static void ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,ngx_uint_t do_write)
    {
        /* 这是在一个大循环中执行的,也就是说,与上下游间的通信可能反复执行,即接收一点,发送一点 */
        for ( ;; ) 
        {
            if (do_write)//向下游发送响应
            {
                if (u->out_bufs || u->busy_bufs) 
                {
                    /* 向下游发送out_bufs指向的内容*/
                    rc = ngx_http_output_filter(r, u->out_bufs);
    
                }
                // 到目前为止需要向下游转发的响应包体都已经全部发送完了
                if (u->busy_bufs == NULL) 
                {
                    b->pos = b->start;
                    b->last = b->start;
                }
            }
            /* do_write为0,表示需要由上游读取响应 */
            size = b->end - b->last;//获取buffer缓冲区中还有多少剩余空间
            if (size && upstream->read->ready) 
            {
                n = upstream->recv(upstream, b->last, size);//将上游的响应接收到buffer缓冲区中
                if (n == NGX_AGAIN) 
                {//期待epoll下次有读事件时再继续调度
                    break;
                }
                if (n > 0) 
                {
                    u->state->response_length += n;
                    /* 处理包体 */
                    u->input_filter(u->input_filter_ctx, n);
                }
                /* 读取到来自上游的响应,这时设置do_write为1,准备向下游转发刚收到的响应 */
                do_write = 1;
                continue;
            }
            break;
        }
    }
    

    可以看到,该方法是读一些数据就设置do_write=1,从而触发发送事件,因此是非缓存的。

    开启缓存的情况下从uwsgi读取包体并转发

    在uwsgi_buffering设置为on的情况下,从uwsgi读取body和发送body给浏览器的方法分别为ngx_http_upstream_process_upstream 和 ngx_http_upstream_process_downstream。而这两个方法最后都是调用ngx_event_pipe方法,在该方法中,通过标志位来分别从uwsgi读取数据和向浏览器发送数据,具体如下:

    ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, ngx_int_t do_write)
    {
        for ( ;; ) 
        {
            if (do_write) 
            {
                rc = ngx_event_pipe_write_to_downstream(p);//向下游客户端发送响应包体
            }
            p->read = 0;
            p->upstream_blocked = 0;   
            /* 读取上游服务器的响应 */
            ngx_event_pipe_read_upstream(p);
            if (!p->read && !p->upstream_blocked) {
                break;
            }
            /* 当读取完所有的包体后,会把p->read设置为1,从而导致do_write为1,即开始发送数据给浏览器 */
            do_write = 1;
        }
    }
    

    从uwsgi读取数据:在这个过程中会涉及以下几种情况:1)接收响应头部时可能接收到部分包体;2)如果没有达到bufs.num上限,那么可以分配bufs.size大小的内存块充当接收缓冲区;4)如果缓冲区全部写满,则应该写入临时文件:

    static ngx_int_t ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
    {
    
        for ( ;; ) 
        {
                /* 从缓冲区链表中取出一块ngx_buf_t缓冲区 */ 
                if (p->free_raw_bufs) 
                {
                    chain = p->free_raw_bufs;
                } 
                //缓冲区已空,尝试继续分配缓冲区
                else if (p->allocated < p->bufs.num) 
                {
                    b = ngx_create_temp_buf(p->pool, p->bufs.size);//可以从内存池中分配到一块新的缓冲区
                    ……
                }
                //缓存区已满
                else if (p->cacheable|| p->temp_file->offset < p->max_temp_file_size)
                {
                    rc = ngx_event_pipe_write_chain_to_temp_file(p);//将响应文件写入临时文件中
    
                } else {
    
                    break;
                }
                //接收上游的响应
                n = p->upstream->recv_chain(p->upstream, chain);
        }
        if (p->length == 0) {//数据接收完毕,开发发送数据给浏览器
            p->upstream_done = 1;
            p->read = 1;
        }
    }
    

    可以看到该方法是尽可能多的把数据缓存下来再发送给浏览器。

    总结

    1. nginx发送数据到uwsgi:首先nginx会判断用户是否设置client_max_body_size指令,如果设置了,则会用该值来和content-length进行比较,如果发送的包体超过了设置的值,则nginx返回413包体过大的错误。如果包体在给定范围内,则nginx会根据proxy_request_buffering是否开启,来决定是否先缓存客户端发来的请求。如果关闭了proxy_request_buffering(默认开启),则nginx是接收到一部分数据就直接发送给uwsgi;如果开启了proxy_request_buffering,则nginx是是把所有的数据都读取到之后,再发送给uwsgi,如果body过大,则可能需要把body先存入临时文件中。

    2. uwsgi返回数据到nginx:如果uwsgi_buffering开启(默认开启),nginx会尽可能缓存uwsgi发送来的body,缓冲区的大小由uwsgi_buffers和uwsgi_buffer_size两个指令设置的缓冲区之和;如果还是存不下,则需要写入临时文件,临时文件的大小由uwsgi_max_temp_size和uwsgi_temp_file_write_size决定;如果关闭,则数据同步的发送给浏览器,每次最多缓存uwsgi_buffer_size的数据,可以从upstream->recv()方法看出,如果满了,会导致uwsgi无法发送数据而阻塞。

    3. 在工作中,一般是保持proxy_request_buffering和uwsgi_buffering默认开启的设置,这样才能充分利用nginx高并发的特性,不会让一个连接长时间占用后端的web application;另外如果要限制请求body的大小,如上传图片,一般是nginx开到最大合理的大小,然后python按照具体接口的业务,读一部分,超过大小就扔掉。因为nginx可能需要限制多个请求body的大小,所以一般设置一个最大值,然后在web应用中根据需求来加以限制。

    展开全文
  • uwsgiconf:从Python代码配置uWSGI
  • 文章目录一.Nginx1.简介2.相关资料3.优势4.安装4.基本操作5....塞索耶夫开发的,于2004年10月4日公开源码,以类BSD许可证形式发布 Nginx因它的稳定性,丰富的功能,示例配置文件和低系统资源的消耗而闻名

    一.Nginx

    1.简介

    Nginx是一个高性能的HTTP和反向代理服务器,也是一个IMAP/POP3/SMTP服务器。

    Nginx是一款轻量级的Web服务器/反向代理服务器以及电子邮件代理服务器,其特点是占用内存少,并发能力强,在同类型的网页服务器中表现优秀

    Nginx是由伊戈尔.塞索耶夫开发的,于2004年10月4日公开源码,以类BSD许可证形式发布

    Nginx因它的稳定性,丰富的功能,示例配置文件和低系统资源的消耗而闻名

    中国大陆使用Nginx的网站:
        淘宝,京东,腾讯,百度,新浪,网易…

    2.相关资料

    Nginx的官网:http://nginx.org/
    中文资料:
        http://www.nginx.cn/doc/index.html
        http://tengine.taobao.org/book/

    3.优势

    (1)作为We服务器:相比Apache,Nginx使用资源更少,支持更多的并发连接,体现更高的效率,使Nginx倍受欢迎,能够支持高达50000个并发连接数的响应。
    (2)作为负载均衡服务器:Nginx既可以在内部直接支持Redis和PHP,也可以支持作为HTTP代理服务器对外进行服务,Nginx使用C编写,不论是系统资源开销还是CPU使用效率都处理的非常优秀。
    (3)Nginx安装非常简单,配置文件非常简洁,Bug非常少:Nginx启动非常容易,并且几乎可以做到7 * 24小时不间断运行,即使运行数个月也不需要重新启动。

    4.安装

    (1)源码安装
    a.下载源码压缩包
    b. 安装源码编译依赖包 gcc,zlib,make…
    c. 配置编译模块
    d. make && make test
    e. make instal
    (2)包管理工具安装
    a. 去官网将所使用依赖添加到包管理工具中
    b. 更新包管理工具资源
    c. 使用包管理工具安装

    (3)安装步骤
    进入Nginx官网,有相关安装步骤,这里我是在Linux中安装Nginx,可以参考官网:http://nginx.org/en/linux_packages.html
    在这里插入图片描述
    a. 先安装依赖包:sudo yum install yum-utils
    在这里插入图片描述
    b. 创建一个文件:touch /etc/yum.repos.d/nginx.repo,并添加以下内容:

    [nginx-stable]
    name=nginx stable repo
    baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
    gpgcheck=1
    enabled=1
    gpgkey=https://nginx.org/keys/nginx_signing.key
    module_hotfixes=true
    
    [nginx-mainline]
    name=nginx mainline repo
    baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
    gpgcheck=1
    enabled=0
    gpgkey=https://nginx.org/keys/nginx_signing.key
    module_hotfixes=true
    

    c. 默认的情况下,是使用稳定的nginx软件包的存储库。如果要使用主线nginx软件包,可以运行以下命令:

    sudo yum-config-manager --enable nginx-mainline
    

    在这里插入图片描述
    d. 以上都安装好了的话,就可以安装Nginx了:sudo yum install nginx
    在这里插入图片描述

    4.基本操作

    (1)版本查看:nginx -v / -V
    在这里插入图片描述
    (2)启动Nginx
    只输入nginx命名就可以启动Nginx,其启动的配置文件默认是:/etc/nginx/nginx.conf
    若启动指定配置文件的nginx,需输入绝对路径:nginx -c configpath
    在这里插入图片描述
    网页访问,只需要输入云服务器ip地址即可。
    在这里插入图片描述
    (3)控制
    快速关闭:nginx -s stop
    优雅关闭:nginx -s quit
    重新加载:nginx -s reload
    在这里插入图片描述

    5.配置

    Nginx配置文件包含指定指令控制的模块。
      指令分为简单指令和块指令
        一个简单指令由名称和参数组成,以空格分隔,并以分号结尾
        一个块指令和简单指令具有相同的结构,但不是以分号结束,而是以一个大括号包围的一堆附加指令结束
      如果一个大括号内可以有其他的指令,它就被称为一个上下文,比如(events,http,server,location)
    在项目中创建nginx.conf,添加内容:
    在这里插入图片描述

    # 当前的用户
    user  root;
    worker_processes  1;
    
    error_log  /var/log/nginx/error.log warn;
    pid        /var/run/nginx.pid;
    
    events {
        worker_connections  1024;
    }
    http {
        include       /etc/nginx/mime.types;
        default_type  application/octet-stream;
    
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';
        access_log  /var/log/nginx/access.log  main;
    
        sendfile        on;
        #tcp_nopush     on;
    
        keepalive_timeout  65;
        #gzip  on;
        server {
    	    listen       80;
    	    server_name  localhost;	
    	    #charset koi8-r;
    	    #access_log  /var/log/nginx/host.access.log  main;
    	    # 当前项目路径
    	    root  /root/Django2002/OnlineStore;
    	    # 静态文件
    	    location /media {
    	    	 alias /root/Django2002/OnlineStore/media;
    	    }	
    	    location / {
    	        include    /etc/nginx/uwsgi_params;
    	        uwsgi_pass localhost:8080;
    	    }	
    	    #error_page  404              /404.html;	
    	    # redirect server error pages to the static page /50x.html
    	    #
    	    error_page   500 502 503 504  /50x.html;
    	    location = /50x.html {
    	        root   /usr/share/nginx/html;
    	    }   
        }
    }
    

    使用nginx -c /root/Django2002/OnlineStore/nginx.conf命令启动nginx
    在这里插入图片描述

    二.uwsgi

    1.安装

    在项目环境中进行uwsgi安装,安装命令:pip install uwsgi
    在这里插入图片描述

    2.配置

    在项目中创建uwsgi.ini文件,并复制粘贴以下内容:

    [uwsgi]
    # 使用nginx连接时 使用
    socket = 0.0.0.0:8080
    
    # 直接作为web服务器使用
    #http=0.0.0.0:8080
    # 配置工程目录
    chdir = /root/Django2002/OnlineStore
    
    # 配置项目的wsgi目录。相对于工程目录
    wsgi-file=OnlineStore/wsgi.py
    
    # 适用于flask项目部署
    # wsgi-file = manage.py
    # router
    # callable = app
    #配置进程,线程信息
    processes = 4
    
    threads = 10
    
    enable-threads = True
    
    master = True
    
    pidfile = uwsgi.pid
    
    daemonize = uwsgi.log
    

    3.使用

    (1)启动
    输入启动命令,启动uwsgi:uwsgi --ini /root/Django2002/OnlineStore/uwsgi.ini
    在这里插入图片描述
    (2)关闭
    可以使用uwsgi --stop uwsgi.pid进行uwsgi关闭或者直接杀死该进程

    三.测试

    将nginx和uwsgi都开启,并在网页上输入云服务器ip地址,看项目是否上传
    在这里插入图片描述
    我这是后端项目的上传展示。

    展开全文
  • uwsgi-哨兵 用于哨兵集成的 uWSGI 插件 特征 该插件允许您使用以下 uWSGI 子系统将事件发送到哨兵服务器: 闹钟 钩子 内部路由 异常处理程序 安装 该插件对 uWSGI 2.0 友好,需要 libcurl 开发头文件: uwsgi --...
  • UWSGI任务引擎 该软件包使其可以使用进行异步任务管理。 它比更具功能性和灵活性,并且在许多情况下可以用作替代品。 要求 该模块只能在环境中,你可能还需要建立一些或\和作为UWSGI文档中描述。 安装 简单执行pip ...
  • flask-uwsgi-websocket:u适用于由uWSGI支持的Flask应用程序的高性能WebSocket
  • uwsgi-报警插座 用于监控套接字的 uWSGI 简单插件 只需列出要监控的地址(TCP 或 UNIX),只要与它们的连接失败,就会触发 uWSGI 警报。 安装 该插件是 2.x 友好的: uwsgi --build-plugin ...
  • 部署方式:docker容器部署 nginx(vue) + uwsgi(django) 给出体验地址: 121.4.47.229:8080 因为钉钉、QQ、支付宝等回调地址的原因,为了更好的体验,请在本机hosts中添加: 121.4.47.229 image.meiduo.site 121.4.47...
  • uWSGI WordPress对象缓存 该插件使用uWSGI缓存在WordPress中进行对象缓存。 警告 该插件需要手动安装 uWSGI中存在一个错误,因此您需要包含 安装 将object-code.php文件移动到您的WP_CONTENT_DIR 添加define( '...
  • 描述 用于设置和配置应用程序的手册。 要求 属性 redis.conf 文件是从属性或通过redis_conf定义动态生成的。 您可以在attributes/default.rb看到的所有属性默认值 用法 要使用说明书,我们建议创建以应用程序命名的...
  • uwsgi-docker 用于与集成的 uWSGI 插件。 这个插件允许你在 Docker 容器中配置和运行 vassals。 一旦 Docker 守护进程启动并且你有一堆图像,你只需要编辑一个 vassal 的配置来对其进行 dockerize。 要求 至少...
  • Django 的应用程序,用于运行 uwsgi。 安装 需要 django >= 1.6 使用pip安装: 运行pip install git+https://github.com/silentsokolov/django-runuwsgi.git 或者pip install django-runuwsgi 打开settings.py并...
  • 领事 uwsgi 健康检查 该项目用于 consul 对 uwsgi 端点运行健康检查 建造 在 Docker 容器内编译 如果您只想构建应用程序,而不是在 docker 容器中运行它,请运行: docker run --rm -v $( pwd ) :/go/src/github....
  • docker-django-nginx-uwsgi-centos7 一个带有少量 shell 脚本的 dockerfile 来运行一个空的 Django 项目,结合了基于 Centos 7.x 的容器中的 Nginx、uWsgi 和 sqlite3 工具。 用法 要创建镜像docker-django-nginx-...
  • 用于libstrophe集成(xmpp)的uWSGI插件 git clone https://github.com/unbit/uwsgi-strophe cd uwsgi-strophe uwsgi --build-plugin . 构建脚本会自动克隆libstrophe并将其链接到插件 当前仅公开警报功能: ...
  • uwsgi-newrelic 具有新遗物支持的 upstart uwsgi.conf 和 app.ini 示例文件 详情: : 有关 uwsgi/new relic 的更多信息: ://newrelic.com/docs/python/python-agent-and-uwsgi
  • wagtail-uwsgi-frontendcache 基于uWSGI缓存模块的前端缓存
  • 多个Python环境安装uwsgi出错 环境:Ubuntu18.04、Python2.7、Python3.6、Python3.7 错误 plugins/python/uwsgi_python.h:2:10: fatal error: Python.h: No such file or directory #include <Python.h> ^...
  • uwsgi deb 包 自定义 uwsgi 包 用法: ./build_uwsgi 具体版本 ./build_uwsgi --version 2.0.7 使用 Python 3.4: ./build_uwsgi --version 2.0.7 --python "python3.4" 对于 Python 2.7 只需使用: ./build_...
  • NGINX和UWSGI的PYTHON烧瓶 内容 应用文件夹 uwsgi.ini nginx_config production_flask.service 用法 app文件夹-它包含完整的应用程序和目录。 请将其初始化为虚拟环境,然后安装该文件夹中包含的requirements.txt ...
  • Docker-Flask-uWSGI-Nginx Flask + uWSGI + Nginx Docker项目
  • uwsgi-pgnotify 将PostgreSQL通知系统映射到uWSGI信号框架 安装 该插件是2.x友好的 uwsgi --buid-plugin https://github.com/unbit/uwsgi-pgnotify 配置 每当本地主机上的postgresql服务器通知通道FOOBAR时,都会...
  • 基于uWSGI+Nginx 用Centos做服务器,Nginx做WebServer,uwsgi做应用程序容器。 #环境要求 Python 2.6 / 2.7 Django >=1.4 MongoDB >=1.8.0 其他依赖的Python组件: pymongo(2.2.1) pytz(2012d) Django、pymongo和...
  • 毕业设计-扩展项目网站-vue + python + flask + uwsgi + nginx + mysql 启动步骤: 启动后台: cd返回 virtualenv --no-site-packages extra_env 点安装-r requirements.txt python run.py 以上开启后台dev环境 ...
  • uwsgi-烧瓶 带有 Nginx、uWSGI 和 Hello World Flask 应用程序的 Docker 镜像。 该图像基于我的 ubuntu-python 3.4 图像(它又在 phusion/baseimage 之上运行)。 Hello World 应用程序已启用并将在端口 80 上内部...
  • uwsgi-皇帝 这个角色在Emperor模式下安装和配置uWSGI。 要求 此处应提及 Ansible 本身或角色可能未涵盖的任何先决条件。 例如,如果角色使用 EC2 模块,则在本节中提及需要 boto 包可能是个好主意。 角色变量 uwsgi_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,062
精华内容 2,824
热门标签
关键字:

uwsgi源码