แจแแฃแแแ แแแฃ แแแฃแญ แ แตแแ แฅแซแฐแแ แแแข 2016, แญแ
แ แฃแแแ แแแต แ
แณแญ 7-8 แแญ แแตแฎ แ แ
แซแขแซ Skolkovo แแตแฅ แฐแซแแฐ. แจNGINX แฐแแฃแญแ แ OpenResty แฅแ Lua แฅแแดแต แแซแแ แฅแแฐแแปแ แซแฅแซแซแแข
แคแ แญแตแฅแแ แแแ แฐแ, แตแ แญแแตแแญ แแฎแณแถแญ แฅแฃแแแ, แ Parallels แแญ แฅแฐแซแแ. แตแแซแด แตแแฝ แฅแแแญแแณแแแข แ แแญแแด แฆแตแต แ แซแฐแแแ แฎแต แ แแปแ แ แณแแแแแข แ แฅแฌแ แแฎแแซแแญ แแแฉแแก แ แแณแแต แแ แ แ แแ แฎแต แ แญแปแแแข แฉแฅ แ แญแแต แจแขแแฑแตแตแช แแแต แแ, แ แแฅแณ แแฐ แแญแต แจแแแฃแแ แฎแต แแปแ. แ แแณแแถแปแฝแ แจแแตแ แแแต แแ แจแแณแแแต แฎแตแข
แตแแแ แแ แซแ แ แแฅแ แฅแแฐแแ แจ แญแแฃแแณแ. แตแแฝ แแ แณแแแฃ แแฅแผ แฅแแแ แฃแ แแแต แดแซแฃแญแต แณแณแคแ แฐแฐแ แแข แ แแ แฅแแ แแ แแแ แฐแ แจแแฐแ แญแแต แแแข แแฐ แฎแแแจแแถแฝ แแ แ แจแ แแก- โแแแถแฝแฃ แแแฉแแฃ แตแแ แแจแ แ แแฝแแฃ แแแ แแแญ แฅแฉ แแ? แฅแแซ แตแแต แแฐแจแต แ แแ ? โ100 แแแฃแญแต แ แแ!โ แฅแแ แแแฑแแแข โแ แชแแฃ 100 แแแฃแญแต!โ แ แแฉแตแข แฅแ แจแแจแญ แแดแ แฅแแดแต แ แฅแแแ แแ แ แ แฅแแณแแฅแ แแซแด แฅแซแฐแฅแฉ แแ แญแข แญแแตแแฝแแแฃ แ แแฃ แฐแแน แฅแฉ แแธแแฃ แฅแ แจแแซ แฐแแแฐแ แ แฅแแแ แฃแแฅแ แดแซแฃแญแต แจแแแฅ แแณแแฝ แตแแญแฃแแ แข แฅแ แญแ - แแแจแญ แแแ. แญแ แแ แแญแแต แตแฅแฐแฃ แฅแแฐแแ แแแแต แตแฝแแแ ?
แจ20 แ แแญ แจแแฎแแซแแแ แแแแแฝแ แ แแแแแข แญแ
แตแฐแซ แแแ
แจแแ แจแฅแ แแแญ แแแข แ Erlangแฃ Cแฃ C++แฃ Luaแฃ Pythonแฃ Rubyแฃ แแ แแแญ แฎแต แญแฐแกแแณแ แฅแ แแแแ แแแจแฅ แ แแฅแแตแข แ แ แ แแแญ, แแตแจแ แแ แจแฅแ. แตแญแญแแแแ แแฅแญ แแแตแแต แ แแฐแปแแ, แแแญ แแ แ 20 แแ แ แซแฃแข แจแแ แฆแณ แแฅแฉ แ แแทแ.
แแแ แจแแจแกแต แตแญแฉแแฝ แแ แฅแแฐแแ แฅแ แแ แฅแแฐแแแฐแญแ แตแแแซแแ
แฃ แแ แซแ
แ แ แชแ แฅแแฐแแแ แฅแ แแ แฅแแฐแแแฐแญแ แ แแแแญแแข แ แ แแ แแชแซ 13 แขแฎแแฝ, แจ 300 แ แแญ แฐแซแฐแแฝ, แ แแตแฎ, แณแแ แฅแ แแแณ แแตแฅ แแแต แฅแแณแแ แฅแแแญแแณแแ. แจแแแ, แแแฐแต แฅแ แ แญแจแแต แแแแ แจแแ แฅแ แแญแฃแแ แแแ
แจแแแ แแฐ แแแณ แแแต แญแฝแแ.
แ แฐแแญแ แจแฅแ แฒแแญแตแแแต แ Python 2 แแตแฅ แญแฝแแ. แฅแ แ แแแต แตแซ แแญ แแ แฅแ แแฝแ แดแญแแแแแฝแ แแแฐแแ แญ แแ แจแแแ, แตแแแ แฅแแฐแแซแแ. แฒแแแแ แจแแแ แแแ แแแ แแแญ แตแแแ แแแฃ แฅแ แ แแตแแแ แจแแแแ แแตแฐแ แแจแแญแแแข แฅแแฒแแ MySQLแฃ Redis แฅแ NGINXแข แแแฝ แฅแ แฅแฉ แแแฎแฝแ แ แแแข MongoDB แ แแ แฃ แแชแซแแ แจแแฎแก แฅแแธแแฝ แ แแ แฃ แแแ แแแญ แ แแ - แแ แจแฅแ แ แญแฐแแ แฃ แฅแ แฅแ แ แแฐแญแแแแข
แญแแต แฌแตแฒ
แตแแซแด แแแญแฉแตแข แฅแตแฒ แแฌ แตแแแแแจแ แแแญ แฅแแแ แก-
- OpenResty แแแตแ แแ แฅแ แจแแ แแญ แแ แจแแ แแ?
- แแญแแแฃ แแตแแคแตแฃ แแคแฝแแฃ แแต แฅแ แแแ แฐแ แจแแฐแฐแตแฃแธแ แแแฝ แฅแฉ แแแฎแฝ แฅแซแแ แแแ แแ แแ แฅแแฐแแ แฅแแฐแซแแแข
- แฅแ แจแ แญแแต แฅแแต แแณแแแฝแข 3,5 แฐแ แณแต แตแแแแฅแ แชแแญแฑแ แฅแ แแแจแฅ แแ แจแฅแ, แตแแแ แฅแแต แแณแแแฝ แญแแซแ.
OpenResty NGINX แแแข แแฅแฑ แแตแแ แญแแฃแแ แ แฐแแฅ แจแฐแแ แฅแ แ แแฅแแต แจแแฐแซ แแ แ แแแแแต แซแแ แจแตแญ แ แแแแญ แ แแ. แ แฅแแแปแฝแ NGINXแ แ แแญแต แแตแฅ แฅแแ แแแแ แฅแฌ แ แตแฃแแแข แฅแฑ แแฃแ แฅแ แ แชแ แฅแแฐแแ แแแฝแแ แณแแแแฝแแข แ แแตแก แ แชแ แจแฐแแณแฐแ I/O แ แฉแฃ แตแแแ แแแ แแแญ แแฝแจแญแจแญ แ แซแตแแแแแแฃ แแญ แ แแญแแ แแตแฅ แฅแแณแฐแจแแตแข Gevent แ แชแ แแ แ แชแ แแ แแแญ แแ แฒ แฎแต แจแแ แฅแ แจแแ แฝแแญ แจแฐแแ แจ แ แแฌแแต แ แแซแแแต แแจแ แซแฅแณแแข แแแฑ แแ แจแแก แฅแแซ แแ แฅแแฐแฐแแ แจ แแแแ แแแต แแ แแแต แแ แทแแข แ แแต แฐแ แแฅแ แณแแแณแต แซแแแแจ แฃ แฝแแฉแ แซแแแ แฃ แ แญแแแจแฅ แแญ แขแฝแ แฅแ แแแ แฃแซแแแ แแฎ แแ แ แแ แฅแฅแต แฅแแแ แแ แญแข
NGINX แ แตแแตแ แแธแแซ แฅแ แจแแญแแแณแแต แญแแต แฐแจแแแแแข แ แแ แฆแณ แแญ แแแญแแฝแ แฅแแณแซแก, แจแแ แฆแณ แฅแแณแญแแแฉ, แญแ แแ แ แฐแฅแ แแแต แฅแแดแต แฅแแฐแแซแฐแญแแต แแจแแ แ แซแตแแแแแตแ. Nginx แแแฐแแซแต แ แฃแ แแน แแ, แแ แแแฐแต แฅแแณแแฆแต แแฐแฅ แ แซแตแแแแแตแ - WSGI, PHP-FPM, Gunicorn, Unicorn. Nginx แฐแญแแ, แแ แตแฐแณแณแชแแฝ แฐแฐแฅแทแ, แจแฅแฑ แแญ แฅแแดแต แฅแแฐแแฐแฉ แซแแแ. Nginx แฅแซแแแฝแ แ แฐแแแ แแแฉ แซแตแฌแณแแข แตแแแ แแณแญ แตแแฝ แแญแผ แ แแซแแแข แฃแญแฉ แฅแซแแแ แฒแแ แแฃ แฒแซแตแฐแแแต แฅแ แญแแฑแ แแฐแ แแแ แฒแซแแญแฅ แฐแจแ แ แแแข
Nginx แ แชแ แแแฃ แแแญ แแ แ แแต แฝแแญ แ แแก แแแ แฅแแณแ แแแแญ แขแฝแแ แแแถแน แแฐ แแ แฉ แฃแจแแแแต แฅแฉ แฃแ แชแซแต แฅแแณแ แ แ แ แแแณ แฐแแแแญ แ แญแฐแแแข แญแ แแญแ แ แ แ แญแฐแแ. แแแ แ แแ แจ Taobao แฐแแฝ แจแจแ แ แแ แ แแต, แจแตแแแต แ แแต แ แแต แญแแตแแ, แแ แ แ แแตแก แจแแแกแต. แแ แญแฐแฃแ?
- แแญ. แตแแฝ แแ. LuaJIT แจ100-200 แชแแฃแญแต แจแแ แฐแจ แตแแตแณ แ แแญ แฅแ แ แแตแฐแ แจแ แแแแ แตแญแ แญแฐแฃแแข
- แแฅแแต. แจ LuaJIT แ แตแฐแญแแ แ แฅแ แแแณแแฝ แจ C แแญ แญแแซแจแฃแแฃ แ แ แแณแแต แแแณแแฝ แ แแซ แญแธแแแแฃ แ แแ แ แฉแ แฐแแ แญแ แแ แแแข แแฐแแฐแ แแ แ แฃแ แฅแฉแ แจแแ แญแฒ แฎแแแแฐแญ แฅแแฐ แฅแ แฅ แแแณ แญแแ แญ แแ แญแข แ แแ แแแแแแฝ แ แ, แแ แ แฃแ แจแฃแต แแธแ, แแแณแ, แฐแแณแณแญ V8. แ แแณแแต แจแแคแต แฐแญแแแแฝ แฅแ แแซ แแตแตแแต แ แ แแณแแต แฆแณแแฝ แแฃแ แแธแแฃ แแแญ แแ แ แ แแณแแต แฆแณแแฝ แ แแแ แญแธแแแแข
- แแแแญ แแแ. แจแแญแ แฎแต แคแ แซแแ แฅแ แฅแซแตแซแแญ แซแแแ แจแแญแ แแฎแแซแแฎแฝแ แ แซแแแแข แฅแแฑ แตแแแ, แแแ แฐแแตแฐแแ, แฅแ แฅแแฑแ แแตแฐแแญ แจแ แ แฅแ แจแฃแต แแ. แแแ แแแญ แแฎแแซแแฎแฝแ แจแแแแฃ แฅแแฐแแ แแฐแแ แ แแญแ แฅแแฑแ แแแแต แแแญแฅแ แญแฝแแแข แ แแ แแณแญ แแแ แแแญ แแแ แแแข แแแแแ แแฃแต แแ แ แ แถแตแต แแแต แแตแฅ แแแญ แญแฝแแแข แแแแ แแแต แฐแแต แซแ แ แแ แถแฅแแแข แจแแแต แฐแแณแต แ แแ แ แแญแต แแตแฅ แฎแต แฅแฝแแแ แข แจแ แแต แณแแแต แแฐแ แ แแ แ แแฅแณ แแฐ แแญแต แแถ แแฐแข
แ แแคแฑแ, แญแ แแ แญแแตแแ.

แฅแแ
แฅแ แแแญ แ แแข OpenResty แแแฑแแ แแฝ แฅแ แแฐแญ แแแแฝแ แฐแฅแตแงแแข แฅแ แแแ แแแญ แแแ แแ - แจแฐแฐแแซ แฅแ แจแแฐแซแข
แแณแแแฝ
แแฅแ แญแ แแแแฃ แแฐ แฎแฑ แฅแแแตแข แตแแฝ แแ แ แแ แฅแแแก-

แแ แ แ? แญแ
แจแขแแแแฝ แแแ แแแข แ แแจแแ
แ, แจแซแณแฝแแ แแแชแซ แ แแฝแแ, แแแ แจแแแ แ แแแตแตแ - แแตแแแ แ NGINX แแตแฅ แ แแ, แฅแฉ แฅแ แฐแแ แ
แญแแต แฅแแแซแแ.
content_by_lua_block แจแแ แตแญแชแแต แ แแ แแ แญแแตแ แฅแซแแแแแ แแ แจแแ แฅแแญ แแแข แจแขแแแแฝแ แฐแแแแญ แฅแแแตแณแแ remote_addr แฅแ แ แตแแฃ string.format. แฅแแฐแแซแ แแแข sprintfแ แแ แฅแป แตแญแญแ แฅแปแข แฅแ แแฐแแ แแ แฅแแฐแ แแแ.
แ แแคแฑแ, แฅแแฐแแจแฐแแ แญแแแ.

แแ แแฐ แฅแแแฐแแ แแแ แฅแแแแตแข แแ แ แแแ แแฐ แแญแต แจแแซแฐแแซ แจแแแข แจแฅแ แแฐแแ แชแซ แฅแแแ แแ แแฐ แณแณแคแ แแญแ แแ แฆแณ แญแแณแ แฅแ แฅแ แแ แแแฝ แญแ แฅแแแข

แแ แฅแ แฐแแแฆ แญแ แฅแแแข แ แฃแ แฅแฉ แ แญแฐแแ. 100.000 แฐแ แแแแฝ แฒแแก, แแฅแ แ แฃแ แจแฃแต แแ. แตแแแ
แแแ แแฐแแ แชแซแ แฅแแฐ แแณแ แฅแแ แแแข แแตแแฝแ แแแณแ แตแแถแฝแ แฅแแแแแแ. แแ แแแแ แฅแป แณแญแแ แแแ แแแถแฝแ แฅแแฐแแแ แฅแ แฐแ แแแ "แตแแถแฝแ" แจแแแ แตแแถแฝแ, แแแซแ แตแแถแฝแ แฅแ แจแแณแฐแแตแ แฅแแแแแ. แ แแแแชแซ แจแฅแซแแแ แแจแ แ แแญแฃแ แแญ แแแแต แ แแฅแแข แญแ
แ แญแแตแแแข

แแแต แแตแแฎแฝ แจ GET แแแชแซแแฝแ แฅแแฒแซแแฑ แซแตแฝแแแณแ, แแแ แแตแฅแตแฅ แแแฎแฝ แจแแ. แ แแแ แแฃ แแแแ แแ แฅแ แ
แฅแซ แแแญแต แซแแ แจแแแฅ แแณแฃ แญแ
แแ แแจแ แจแแแแแ แแฐแ แ แจSQL แฅแซแแ แ แแ แแ แแแข แแแ แแแข แญแ
แ แญแแตแแแข

แคแฐ แแแ
แแฑแ แ แแแแแต แแญ resty.mysql, แแฐแ แฒแ แ แชแต แแตแฅ แซแแ. แแแ แแแญ แแซแ แ แซแตแแแแแ, แแแ แแแญ แแแ แแ. แฅแแดแต แฅแแฐแแแแ แฅแ แจ SQL แแ แญแ
แ แฅแแ แแแแแก-

แฅแแ
แตแแฝ แ แตแแช แแ, แแ แแแ แแแญ แญแฐแซแ. แฅแแ
10 แแฐแฅ แแ. 10 แแคแถแฝแ แฅแแแฃแแ, แฐแแ แแ, แฐแจแแช แแณแจแต แ แแแแแ. แ SQL แแตแฅ แตแแแ แแฐแฅ แจแณแ.
แ แแแ แ แแแแ แฅแซแแแฝ แตแแแฝแ แฅแแแแแ. แฅแ แฅแซแแแฝแ แฅแแฐแ แตแฃแแ แฅแ แจแฐแ แซแแ แจแแ แ แจแดแ แฅแแแแแแข reqs, แฅแ แฅแแฐแญแแแ ngx.location.capture_multi.

แฅแแแ
แแ แฅแซแแแฝ แ แตแญแฉ แฐแแจแแแฃ แฅแ แแแถแฝ แแฐ แฅแ แฐแแแฐแแแข แจแฅแซแ แแ แ แฃแ แแญแแ แจแแแ แแแฝ แแ แแญ แฅแฉแ แแแข แแแฝแแ แ 50 แแแฐแจแแถแฝ แแตแฅ แจแฐแฉแตแ, แฅแ แแถ แฅแซแแแฝแ แจแแญแ, แ 50 แแแฐแจแแถแฝ แแตแฅ แแแต แฅแแแแแ.
แฐแแ แตแแแแ HTTP แฅแ แแธแแซ แ แซแซแแ แแปแ แตแแแแแแ NGINX แแแแ แแแญ แฅแแฒแซแฐแญแแแ แฅแแฐแญแแแแข แฅแแณแจแธแ แฅแซแ แแ แญแข url/fetchแฅแแ แฅแฑแก-

แแแ แฅแแฐแญแแแ proxy_pass, แแธแแซ แจแต แฅแแณแ, แฅแแดแต แแตแจแ แฅแแณแแฅแ แฅแแ แแแแ, แฅแ แแแ แแแญ แแฅแ แญแฐแซแ.
แแ แญแ แ แ แ แญแฐแแ, แ แแแ แแจแแแ แแฐแ แแแ แแตแ แต แ แแฅแ. แ แฃแ แแแ แแณแฅ แแแแ แแแญ แ JSON แแตแฅ แฃ แ แแแ แฃ แ แแแต แแตแแฎแฝ แแตแฅ แแฐแญแฐแญ แแแข แจแญแแต แ แญแแต แฅแแฐแฃแแ JSON แฅแแฐแฃแแแข
แแ แ แแต แฝแแญ แ แแก แฐแ แแแ JSON แแแ แฅ แ แญแแแแแข แจแแต-แแจแจแป แแแขแแฝแ แแณแฅ แ แแฅแแข แ แแณแแต แแ แแแแชแซ แแญ แญแ แ แแตแจแ แ แแแแแแข แฅแ แจ SEO แตแแปแแตแถแฝ แตแแแฝแ แจแแแแแ แจแแ แแฅแแฑ แแแ แแแฅ แจแแแ แญแแ. แฅแ แ แแณแแต แญแแถแฝแ แจแฐแ แแธแ แจแแแ แแฎแแซแแปแฝแ แแแ แแแญ แ แญแ แแแ แญแแ.
แตแ แฅแฑ แแ แแตแจแ แ แแ แต? แ แฅแญแแฅ แแฐแ แแแ HTML แฅแแฐแ แแแแข แ แฅแ
แแแแจแต comme il faut แ แญแฐแแแฃ แตแแแ
แ แฅแแถแฝแ แแ แแ แฅแแแแแแแข แแแ
แคแฐ-แแฝแแแต แ แ lua-resty-template.

แฆแตแฑแ แ แตแแช แแฐแแต แฆแแคแ แ แญแฐแ
แญแแแแข OpenResty แจแซแฑ แจแฅแ
แ แ แแแฃแช แแญ แ แฅแฎ แญแแฃแแฃแ แแ
แ แฅแ แจแฐแแซแฉ แแแแฝแ แ แฐแแญแแฃ lua-resty-template. แญแ
แจแแแ แ แฅแแถแฝ แแญ แฐแแณแณแญ แจแแ แแแ แจแ แฅแแต แแฐแญ แแแข แฅแแซ แฎแต แแปแ แฅแ แฐแแแแญ แแตแญ แแจแแแ แญแฝแแ.
แ แแคแฑแ, แแแ แแแญ แฅแแฐแแ แซแ แแแญ แญแแตแแ.

แแแกแ แแตแฐแ แ แฅแแฑแ แฅแแฐแแ แ แแแต แแตแแฎแฝ แ แฐแจแแ. แฐแ แแแ แฐแตแฐแ แแ, แตแแถแฝแ แฐแแฅแแ. แฅแซแแแ แตแแฐแแ แแตแแถแฝ แจแแแ แจแแแญ แแ
แฐแ แฐแแ แแข แ แญแซแฝ แ แณแแแแฃ แแแแฃแต แฅแฑ แ แตแญแญแ แญแ
แแ แฅแจแแแ แแแ แญแฝแแแฃ แแแญ แแ แฅแซแแแ แ แตแญแญแ แแแแแต แ แแปแแแข
แแแ แแแญ แ แชแ แแแฃ แแ แฅแ แ แแแแฃแต แแญ แแ แฅแ แแฐแ แแแแฝ แฅแตแซแแ แแณแจแต แ แแแแแแข แแแฑแ แฅแแตแญแแข แญแ แแ แแแตแจแแฃ NGINX แฅแซแแแ แ OpenResty แแแฝ แฅแแดแต แฅแแฐแแญแ แฅแแแแจแตแก-
- แจแแแแชแซ แฐแจแ - แแณแจแป, แฐแ แแแ แแญ แฅแแฐแฐแจแฐ, แฅแ แ แ แญแฅแตแถแฝ, แ แ แญแ แ แตแซแป แฅแ แ แแ แแแฅ แฐแแแจแตแแ. แซแแแฐแตแ แแฒแซแแ แแแแญแ แ แฅแแฝแแแ. แญแ แแแแต แแซแแแแ แญแฝแแแฃ แแญแ แฅแ แฅแซแแแฝแ แจแฐแแ แแแฃ แ แแ แฐแจแ แ แแแ แแแจแฅ แฅแแฝแแแแข
- แฅแแฐแแ แปแ. แ แแณแแต แจแฅแซแ แแแฅแ แฅแแฐแแ แฅแแฝแแแแข
- แญแแต. แญแแฑแ แแฐแ แแแ แฅแแฐแญแณแแแข
- แซแตแแแฝ แแฃแชแซ. แจแแแฝ แซแตแแแฝแ แฅแแฐแซแแ. แจแฐแ แแแ
proxy_passแแฐแ แแแ แจแแตแ แณแฝแ แ แแต แ แแณแแต แซแตแแแฝแ แฅแแฐแแ แแแ แฅแแฝแแแแข - แจแฐแแแต แแฃแชแซ. แฐแแแณแฝแแ แแแแฅ แฅแแฝแแแ.
- แแแแฅ - แแแแฅ แแตแณแแป. แซแ แฐแจแแช แแฅแญแฅแญ แ elasticsearch แแตแฅ แแแแฅ แแตแณแแปแแฝแ แแปแ แญแฝแแแข
แจแฅแ แแแต แฅแแฐแแ แซแ แแแญ แญแแตแแแข

แญแ
แแ แแฐแแซ แฅแแจแแซแแ location, แแฐแ แฅแแ แจแแแ
แแแ แฅแ แจแแจแฐแแแ แฎแต แฅแแซ แแญ แ แตแแแ แ.

แจแฉแช แถแจแ แฅแแณแแ แแแจแต แฅแแแญแซแแแข แซแแแแฃ แแแต แฅแแ แญแแแแข แฐแ แแแแฝ แฐแแฎแแ แแธแ แฅแ แจแฉแช แแตแแฐแซ แแแแแต แฅแแฐแแซแตแแแแธแ แแแแต แญแฝแแแข แตแแแ
แ แฌแฒแต แแตแฅแ แฅแแตแแแ แแแแก-

แจRedis แแญ แแแตแซแต แฎแต แ แฃแ แแแ แฅแ แจแแแฝ แแแแแฝ แจแฐแแจ แ แญแฐแแแข แ แฐแแณแณแญ แแ, แแแ แแฅแ แต / แแ
แแต, แฅแแ
แฅแ แฅแแซ, แ แญแณแแตแ. แจแฐแแณแฐแ แฎแต แจแปแแฃ แ แแญแแณแฐแ แแแฉ แญแฐแซแแข แจแแ แแฐแ gevent แฅแแฐ, แแแญ แแ แ แฐแแฅ แฐแจแแแแ.

แแแณแแ แฅแซแฑ แฅแแตแญแแก-

แจแฅแซแแแ แ แซแ แแแ แฅ แ แแฅแ แฅแแแแแข แจPOST แญแญแญแฎแฝแ แฅแแแ แแแ แฅแ แจแแแขแซ แฅแ แจแญแแ แแ แตแญแญแ แแแแธแแ แฅแแแตแปแแแข แตแญแญแ แซแแแแฃ แแแต แฅแแฒแฐแกแ แฅแแแแแแณแแแข แฅแ แตแญแญแ แจแแ แแแญแฑแ แ แฌแฒแต แแตแฅ แญแแแก-

แฉแชแแ แแแแแตแแ แ แญแญแฑ, แญแ
แฅแแฒแ แ แแแต แแตแแฎแฝ แญแจแแแแ.

แแณแแ แแแ แฅแ แแแณแ แแ. แ แฅแญแแฅ แแฐแแฝ แตแแถแฝแ แจแแซแณแญ แ แแแแแต แ แแฐแซแ. แแ แแ แซแแแแข แตแแแ
แ แแญแต แแตแฅ แแ แแฐแจแ แฅแแฐแแฝแ แฅแแแแจแต.
- แ แแตแฐแ แแญแฃ. แ แแณแแต แแ แตแแฝ แณแณ แแฐ แแญแฃ แแแฃแต แ แแฅแแก แจแแ แฆแณ แแ แแตแแฃแต แ แแฅแแฃ แจแแ แฆแณ แแญแแญ แแณแจแต แ แแฅแแฃ แ แแ แ แฃแขแซแ แแญ แแ แซแ แ แฐแ แแแแฝ แฅแแณแ แญแแแฉแฃ แแฃแช แแญแ แตแณแฒแตแฒแญแต แซแซแญแแข แ แฃแ แตแแฝ แจแแ แแแญ. แ แแณแแต แ แแตแฐแ แแญแฅแซแฎแฝ แ แฃแ แ แแแ แแ แฉ แญแฝแแ. แญแ แแฃแ, แแแ แฅแ แณแแ แซแฐแญแแแ.
- แจแแแฅ แ แตแ แแฐแต. แ แแณแแต แแ แแตแณแแแซแแฝแ แแฐ แแปแฝแ แแญแฐแต แฅแแแแแแแฃ แฅแ แญแ แ แแตแณแแแซ แจแแแแ แแ แจแคแแ แญ แฅแซแแแฝแ แ แแ แแ แแแข แฅแแ แแตแจแ แ แฃแ แแแ แแ. แแตแแแแ แฐแแแฆ แ แแญแฎ แจแแฐแซแแ แจแแแ แญแแ แ แแซแแแข แฅแแ แแแฐแต แฅแ แแฐแฅแฐแฅ แญแฝแแ. แ แแณแแต JS แ แแต แแญ แฅแแฐแ แตแฃแแ แแญแ แ แฐแแซแแ แแแณแต แฅแ แจแแ แแแญ แแฐแ แแแ แจแแตแ แณแฝแ แ แแต แแตแแ แแแฐแซแ แฅแแฝแแแแข
- แแแญแญแฎ แ แแแแแต แจแแต แแฝแณ. แญแ
แฐแแ แ แฃแ แฅแฉ แแณแญ แแ, แฅแ แฐแแฃแซแ แ แตแญแแแแ. แจแแซ แ แแตแฃ แจแคแแญแตแฎแแซแ แชแแญแต แ แแซแจแฅแ แ แแแแจแต แฅแ แ แ แแชแฑ แแตแฅ แซแแต แ
แแ แ แซแแต แแแฝ แซแ
แ แชแแญแต แ แแซแแญแฅ แดแแแญ แฉแฃแแซ แแตแฅ แ แญแปแแแข แ แแต แ แแแแแต แแ แญแ แฃ แฅแ แแแฎแฝ แฅแแซแ แฐแแณแณแญ แแด แ แแ แแ แฐแฐแญแแแ-แแแแแญ แฃ แแแต แฅแ แแแฝแแข
OpenResty แแแญแญแฎ แฐแญแชแตแ แฅแแฐ แแซ แแ แแซแแแแ แญแฝแแแฃ แญแ แ แแแแ แแแญ แ แแต แแณแจแป แฅแ แ แแต แ แญแแแฝ แแแข แแญแญแฎ แฐแญแชแต แ แแ แแแแต แแปแ แตแแแฝแ Node.js แฅแแ แฃ แแคแฝแ แฅแแ แฃ แแญแแ แฅแแ แฃ แ แแณแแต แจแคแญแแแ แแแญ แฅแแ แ แแฃ แฅแ แ แแแ แฆแณ แฐแแณแณแญ แฎแต แแแ แฅแแฐแแแแแ แฅแแจแณแแแข แตแแแ , OpenResty แจแแต แแแต แแฐแซ แญแฝแแ. - แตแณแฒแตแฒแญแต แฅแ แตแแณแ. แฅแแแ แแ NGINX แ แแแขแซแ แแญ แแ, แฅแ แแแ แฅแซแแแฝ แ แฅแฑ แแตแฅ แซแแแ. แแแฐแฅแฐแฅ แ แฃแ แ แแบ แจแแแ แ แแ แฆแณ แแ. แ แแต แแแญ แแฒแซแแ แแตแแต แฅแ แจแแ แฆแณ แแตแแ แญแฝแแแฃ แแแณแแฃ Elasticsearchแฃ Logstashแฃ แแญแ แ แแแ แแฐ แแแแฅ แแตแณแแปแ แญแแ แฅแ แจแแซ แจแแ แฆแณ แญแแฉแตแข
- แฃแแฅแ แฐแ แแ แตแญแแถแฝ. แแแณแ แจแแตแแญ แแญ แจแแณแแฝแ แแแตแซแต แ แฃแ แฅแฉ แแธแแข แแฌ แ แฌแ แณแแ แ แแญแณแแฐแญ แแแฒแฝ OpenRestyแ แ แแ แแ แจแฃแแฅแ แฐแซแแฝ แจแแณแ แฅแแดแต แ แแฅแแต แแฐแจแฅ แฅแแฐแแปแ แญแแแซแแข
- แแฃแชแซ แญแ แญแ (WAF). แ แ แแ แแ แแแแ แ แญแแต แจแแฅ แ แแแฌแฝแ แแจแญแแ แแตแซแต แแฝแ แแแก แจแแฐแกแแธแแ แฅแ แ แแแแแถแฝ แ แแข OpenRestyแ แ แแ แแแฃ แฅแแฐแแแแตแ แฅแซแแแฝแ แ แแแ แฅแ แ แแแ แจแแซแฃแซ แฅแซแตแ แจแตแญ แแฐแแ แชแซ แแจแญแแ แแตแจแ แญแฝแแแข แแญแแ แซแแ แแคแฝแ แ แฅแญแแ แแแต แแฐ แ แแฐ แแตแฅ แฅแแฐแแญแแฃ แฐแจแตแฐแแแฃ แ แฅแญแแฅ แจแฎแแถแ แแตแฅ แจแตแแแ แฆแณ แแญ แซแแแ แญแจแ แ แตแฐแแญแข MySQL แฅแ Python แฅแแณแแ แณแแแแ แข แแแแฃแตแฃ แ แแต แแญแแต แจแแแซ แแปแแชแซ แแแตแจแ แฅแ แจแแ แแแญ แแฐ แณแณแคแ แแตแฅ แแแตแแฃแต แแแญแฉ แญแฝแแแข แตแแแ แฃ แฅแแแณ แจแแ แแ แญแแฝแ แ แแฅแแต แฅแ แ แญแซแฝ แแต แแแต แแฃแซแต แญแฝแแแข
- แแ
แ แจแฐแฅ. OpenResty แ NGINX แแญ แตแแฐแแแฃแฃ แแญแป แ แแ - แญแ
NGINX แแ
แ แจแฐแฅ. แฅแฑ แ แฃแ แตแแ
แแแฃ แฅแ แแแแชแซ แแญ แจแแแฏแธแ แฅแซแแแฝ แแตแฅ แฅแฉ แญแแ แ แตแแตแ แ NGINX แแ
แ แจแฐแฅ แฐแแตแทแแข
Lua แแแขแแฝ. แตแแแต แแฐ HighLoad++ แจแฅแแ แ แแ แจแแกแต แฐแแฝ แแญ แฐแแแแญแฉ แฅแ แณแซแแถแ แ แแ แฅแป แฅแแฐแฐแปแ แฐแแแข แญแ แฅแแแต แ แญแฐแแแฃ แฅแ แแแฎแฝ แ แแ แฐแฝแแแแข แแณแแแฝแก OpenRestyแฃ Prosody XMPP แ แแแแญแฃ Love2D แจแแณ แแฐแญแฃ แแ แ แแญแญแซแแต แฅแ แ แแแฝ แฆแณแแฝ แจแฐแแแข แฅแ แจแแ แแแขแแฝ แ แแฃ แตแแ แฅแ แแแฝ แฐแช แแ แ แจแฐแฅ แ แแธแแข แแแ แจแแ แฅแซแแแผ แ แฅแแต แฐแแณแต แแตแฅ แฐแแตแฐแแแข แแฐ แจแฐแฅแณแค แแแชแซ แแญแแญ แฒแฝแแฃ แ แฅแฌแ แ แฅแแต แฐแแแแฝ แแตแฅ แแ แฅแ แฅแแดแตแฃ แแ แฅแแฐแแ แจแแแแน แฅแ แแแพแฝ แ แแข แ แฃแ แแญแฅ. แฅแแฐ แ แแแณแฐแ แแ แฅแแฒแ แแญแแฑ แฐแ แแแแณแ แแ แ แจแฐแฅ แ แแแ แฆแณ แ แญแแแแข
แจแแ แแแญ แจแฐแฐแ แจ แฝแแญ แจแแจแแฑแ แต GitHub แOpenResty แ แแข แ แแแ แกแตแแฝ แแญ แจแฐแฅแณแค แแแชแซ แแญแแญ แ แแฃ แ แ แแแญ แแณแฎแฝแ แจแแตแแซแญแ แตแฃ แ แปแญแแ แจแฐแฅแณแค แแแชแซ แแญแแญ แ แ - แ แญแซแฝ แ แณแแ แแฃ แแแแฃแต แฅแแแแแ แ แตแแแญแแฃ แแ แปแญแแ แณแแแแ แข
แแคแถแฝ
- OpenResty แแตแญ แจแฐแ แ แ แฃแ แแน แแแแ แแแแ แแแตแฐแแแ แฅแแฐแปแแฉ แฐแตแ แ แฐแญแแแแข
- แฎแฑ แจแแแฝแแ แแญ แฐแแณแณแญ แตแแแ แจแแแฃแต แฅแแ แแต แ แแตแฐแ แแแฃ แแแแ แ แฃแ แแแ แฅแ แแ แฐแ แแแข
- แซแแฐแแณแฐแ I/O แซแ แแแถ แฅแช แซแแญแฃแแฃ แ แแณแแต แแ แ NodeJS แแตแฅ แฅแแฐแแแฝแแ แแแ แ แญแแต แแตแ แ แญแแจแแแข
- แ แตแแแแ แแแ แฅแ แจแฅแ แฎแต แซแแ NGINX แฅแป แตแแแซแตแแแแ แแแ แแฐแแซแต แ แแ, แฅแ แแแ แแแญ แแฒแซแแ แญแฐแซแ.
- แตแแ แฅแ แแแฝ แฐแช แแ แ แจแฐแฅแข
แแแแแญ แฅแแดแต แฅแแฐแแฐแจแ แ แแญแแญ แ แแแแฝแฉแ แฃ แ แฃแ แจแ แ แณแชแญ แแ แฐแแแข
แแแซแฐแญแแต แฅแจแต แฅแแแฐแแแแ!

แแแญ: hab.com
