iis node.js
Some folks on our team have been working on making node.js work awesomely on Windows. There's a few questions you might have.
我们团队中的一些人一直在努力使node.js在Windows上能正常工作。 您可能有几个问题。
首先，什么是node.js？ (First, what's node.js?)
If you're not familiar with node.js, it's a new web programming toolkit that everyone's talking about. It's the one that makes you feel not hip if you don't know what it is. Like Ruby on Rails was a few years back. Folks called it "Node" and it's basically server-side JavaScript. The idea is that if you are doing a bunch of JavaScript on the client and you do JavaScript all day, why not do some JavaScript on the server also. One less thing to learn, I suppose.
如果您不熟悉node.js，那么它是每个人都在谈论的新的Web编程工具包。 如果您不知道它是什么，它会让您感觉不到臀部。 就像Ruby on Rails一样，几年前。 人们称它为“节点”，基本上是服务器端JavaScript。 这个想法是，如果您在客户端上执行大量JavaScript，并且整天都在执行JavaScript，那么为什么不在服务器上也执行一些JavaScript。 我想少学习一点。
If you are an ASP.NET programmer, you can think of node.js as being likean IHttpHandler written in JavaScript. For now, it's pretty low-level. It's NOT an HttpHandler, but I'm using an analogy here, OK? Here's a lovely article by Brett McLaughlin that goes into more detail about Node.js and what it is. His subtitle is "Node isn't always the solution, but it does solve some important problems" and that's just exactly it.
如果你是一个ASP.NET程序员，你能想到的node.js的作为像JavaScript编写的IHttpHandler的。 现在，它是非常低级的。 它不是HttpHandler，但是我在这里使用一个类比，好吗？ 这是Brett McLaughlin的一篇可爱的文章，它详细介绍了Node.js及其含义。 他的副标题是“ Node并不总是解决方案，但是它确实解决了一些重要问题”，事实就是这样。
更新1：为什么node.js很重要？ (UPDATE 1: Why does node.js matter?)
Why bother with node at all? There's a number of interesting aspects to node as it sits. It uses a very fast JavaScript engine called V8, but more importantly its I/O is asynchronous and event-driven which contrasts with typical synchronous code.
为什么要打扰节点呢？ 节点的位置有很多有趣的方面。 它使用称为V8的非常快速JavaScript引擎，但更重要的是，它的I / O是异步的并且是事件驱动的，与典型的同步代码形成对比。
For example, a naive hello world HttpHandler in ASP.NET that "does some work" for a few seconds (gets a file, accesses a service, etc) could look something like this:
例如，ASP.NET中的一个简单的hello世界HttpHandler会“完成一些工作”几秒钟(获取文件，访问服务等)可能看起来像这样：
public class SimpleHandler : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
Thread.Sleep(2000); //Do something that takes a while
context.Response.Write("Hello from SimpleHandler");
}
public bool IsReusable { get { return true; } }
}
And this is usually fine for most stuff. However, when I push this HARD with a load testing tool and a thousand virtual clients, I can barely get 60 requests a second. The request thread is tied up waiting for the "work" to happen and everyone else gets in line. I'm using up ASP.NET pool. It'd be nice if the work would get handled and someone would "call me back" when it's finished. It's like waiting on hold for tech support. You are effectively blocked as you wait for them to pick up their end. Wouldn't it be nice if they just called you back when they were ready?
这通常对大多数东西都很好。 但是，当我使用负载测试工具和1000个虚拟客户端推送此HARD时，我几乎每秒只能收到60个请求。 请求线程被捆绑在一起，等待“工作”发生，其他所有人也都排队。 我用完了ASP.NET池。 如果工作得到处理并且完成后有人“打给我”会很好。 就像等待技术支持一样。 当您等待他们站起来时，您实际上被阻拦了。 如果他们准备好后才回电给您，那会不会很好？
ASP.NET has alwaysbeen able to do things (see this MSDN article from 2003 on Async Handlers) with IHttpAsyncHandler but it's always been a bit hard and almost no oneknows about it. With the Async CTP and the Task libraries built into .NET, you can build a nicer abstraction on top of IHttpAsyncHandler. Ayende has a simple example AbstractAsyncHandler (there's many of these out there, including a few in our own tools, some things in MVC, and some things in SignalR (more on that soon)) that we can use to do similar work. This example could also do other more complex and pertinent things like file IO, db IO or calling a web service. This is a naive example that doesn't map exactly to the node one below, but it makes the point.Plus, it's nice to look at.
ASP.NET一直能够做的事情(见2003年这个MSDN文章上异步处理程序)与IHttpAsyncHandler ，但它始终是一个有点硬，几乎没有人知道这件事。 使用Async CTP和.NET中内置的Task库，您可以在IHttpAsyncHandler之上构建更好的抽象。 Ayende有一个简单的示例AbstractAsyncHandler (其中有很多示例，包括我们自己的工具中的一些，MVC中的一些东西以及SignalR中的一些东西(稍后将进一步介绍))，我们可以使用它来完成类似的工作。 这个例子还可以做其他更复杂和相关的事情，例如文件IO，数据库IO或调用Web服务。 这是一个幼稚的示例，它没有精确地映射到下面的节点，但是很重要。 另外，很高兴看到。
public class SimpleAsyncAyendeHandler : AbstractAsyncHandler
{
protected override async Task ProcessRequestAsync(HttpContext context)
{
await TaskEx.Delay(2000);
await context.Response.Output.WriteAsync("Hello from Ayende and Scott");
}
}
Pointing the same 1000 virtual clients at this handler gives me 500 requests a second, which makes sense as a request takes 2 seconds to finish. If we were doing I/O or other more complex and long running things than waiting, this scales better than the first example. Doing asynchronous code in .NET as well as parallelism is much easier than before, as evidenced by the two lines of code above and the simplicity of Ayende's small example. The fact that this kind of thing is easy and elegant in node is an attractive thing about node.
将相同的1000个虚拟客户端指向此处理程序，可以使我每秒获得500个请求，这很有意义，因为请求需要2秒钟才能完成。 如果我们正在做I / O或其他比等待更复杂，运行时间更长的事情，那么它的扩展性将比第一个示例更好。 如上两行代码以及Ayende小型示例的简单性所证明，在.NET中执行异步代码以及并行处理要比以前容易得多。 这种事情在节点上轻松优雅的事实对节点来说是一个吸引人的事情。
Node loves asynchrony, and uses JavaScript callbacks to provide asynchrony in a pleasant way. You use events and callbacks in JavaScript already on the client, why not use them on the server? Here's an example from Marc Fasel'sblog on the topic.
Node喜欢异步，并且使用JavaScript回调以一种愉快的方式提供异步。 您已经在客户端上JavaScript中使用了事件和回调，为什么不在服务器上使用它们？ 这是Marc Fasel关于该主题的博客中的一个示例。
First, some synchronous file work via Marc:
首先，通过Marc进行一些同步文件工作：
var fs = require('fs'), filenames, i, processId;
filenames = fs.readdirSync(".");
for (i = 0; i < filenames.length; i++) {
console.log(filenames[i]);
}
console.log("Ready.");
processId = process.getuid();
And the same work using an asynchronous pattern that may look familiar!
使用异步模式进行的相同工作可能看起来很熟悉！
var fs = require('fs'), processId;
fs.readdir(".", function (err, filenames) {
var i;
for (i = 0; i < filenames.length; i++) {
console.log(filenames[i]);
}
console.log("Ready.");
});
processId = process.getuid();
The I/O happens and the callback function that's dependant on the result is executed when the I/O is finished. Powerful stuff.
I / O发生，并且在I / O完成时执行依赖于结果的回调函数。 功能强大的东西。
我为什么要让node.js在Windows和IIS上运行？ (Why would I want node.js to run on Windows and IIS?)
Tomasz Janczuk is working on the iisnode project lately. You might think that Windows and node don't belong together. "That's just wrong! What are they thinking? I thought IIS was all about .NET?" Well, you may recall I spoke at CodeMash a few years back on IIS7 and PHP and did a screencast showing how IIS7, PHP and FastCGI could push many thousands of requests a second. The IIS folks, the Windows folks, the Azure folks, want to make sure everythingruns well on Windows. Remember, we sellWindows, so it's good if it does many things well. ;)
Tomasz Janczuk最近正在iisnode项目上工作。 您可能会认为Windows和节点不属于一起。 “那是错误的！他们在想什么？我以为IIS与.NET有关？” 好吧，您可能还记得我几年前在CodeMash上谈到IIS7和PHP时所做的截屏视频，显示了IIS7，PHP和FastCGI如何每秒发送数千个请求。 IIS人员，Windows人员，Azure人员希望确保一切在Windows上都能正常运行。 请记住，我们出售Windows，因此如果做得很好，那就很好。 ;)
Why bother getting node to run on IIS? Tomasz says it best:
为什么要麻烦让节点在IIS上运行？ 托马斯说得最好：
Some of the advantages of hosting node.js applications in IIS using the iisnode module as opposed to self-hosting node.exe processes include:
与使用自托管node.exe进程相反，使用iisnode模块在IIS中托管node.js应用程序的一些优势包括：
Process management.The iisnode module takes care of lifetime management of node.exe processes making it simple to improve overall reliability. You don’t have to implement infrastructure to start, stop, and monitor the processes.
流程管理。 iisnode模块负责对node.exe进程进行生命周期管理，从而可以轻松提高整体可靠性。 您无需实施基础架构即可启动，停止和监视流程。
Scalability on multi-core servers. Since node.exe is a single threaded process, it only scales to one CPU core. The iisnode module allows creation of multiple node.exe processes per application and load balances the HTTP traffic between them, therefore enabling full utilization of a server’s CPU capacity without requiring additional infrastructure code from an application developer.
在多核服务器上的可伸缩性。 由于node.exe是一个单线程进程，因此只能扩展到一个CPU内核。 iisnode模块允许在每个应用程序中创建多个node.exe进程，并在它们之间的HTTP流量进行负载平衡，从而可以充分利用服务器的CPU容量，而无需应用程序开发人员提供其他基础结构代码。
Auto-update. The iisnode module ensures that whenever the node.js application is updated (i.e. the script file has changed), the node.exe processes are recycled. Ongoing requests are allowed to gracefully finish execution using the old version of the application, while all new requests are dispatched to the new version of the app.
自动更新。 iisnode模块可确保每当更新node.js应用程序(即脚本文件已更改)时，都会回收node.exe进程。 允许进行中的请求使用旧版本的应用程序正常完成执行，而所有新请求均分派到新版本的应用程序。
Access to logs over HTTP. The iisnode module provides access the output of the node.exe process (e.g. generated by console.log calls) via HTTP. This facility is key in helping you debug node.js applications deployed to remote servers.
通过HTTP访问日志。 iisnode模块通过HTTP提供对node.exe进程输出(例如，由console.log调用生成)的访问。 此功能是帮助您调试部署到远程服务器的node.js应用程序的关键。
Side by side with other content types. The iisnode module integrates with IIS in a way that allows a single web site to contain a variety of content types. For example, a single site can contain a node.js application, static HTML and JavaScript files, PHP applications, and ASP.NET applications. This enables choosing the best tools for the job at hand as well progressive migration of existing applications.
与其他内容类型并排。 iisnode模块以允许单个网站包含各种内容类型的方式与IIS集成。 例如，一个站点可以包含一个node.js应用程序，静态HTML和JavaScript文件，PHP应用程序以及ASP.NET应用程序。 这样就可以为当前的工作选择最佳工具，并逐步迁移现有应用程序。
Minimal changes to node.js application code. The iisnode module enables hosting of existing HTTP node.js applications with very minimal changes. Typically all that is required is to change the listed address of the HTTP server to one provided by the iisnode module via the process.env.PORT environment variable.
对node.js应用程序代码的最小更改。 通过iisnode模块，只需很小的改动就可以托管现有的HTTP node.js应用程序。 通常，所需要做的就是通过process.env.PORT环境变量将HTTP服务器的列出地址更改为iisnode模块提供的地址。
Integrated management experience. The issnode module is fully integrated with IIS configuration system and uses the same tools and mechanism as other IIS components for configuration and maintenance.
综合管理经验。 issnode模块与IIS配置系统完全集成，并使用与其他IIS组件相同的工具和机制进行配置和维护。
In addition to benefits specific to the iisnode module, hosting node.js applications in IIS allows the developer to benefit from a range of IIS features, among them:
除了iisnode模块特有的好处外，在IIS中托管node.js应用程序还使开发人员可以从一系列IIS功能中受益，其中包括：
port sharing (hosting multiple HTTP applications over port 80)
端口共享(通过端口80托管多个HTTP应用程序)
security (HTTPS, authentication and authorization)
安全性(HTTPS，身份验证和授权)
URL rewriting
URL重写
compression
压缩
caching
快取
logging
测井
These are all compelling, but the most interesting bit here, in my opinion, is integration. The iisnode module is a proper IIS module, just like ASP.NET and PHP. This means you can have a single website that has multiple kinds of content. Restated from above:
这些都是引人注目的，但是在我看来，这里最有趣的一点是集成。 iisnode模块是一个正确的IIS模块，就像ASP.NET和PHP一样。 这意味着您可以拥有一个包含多种内容的网站。 从上方重述：
For example, a single site can contain a node.js application, static HTML and JavaScript files, PHP applications, and ASP.NET applications.
例如，一个站点可以包含一个node.js应用程序，静态HTML和JavaScript文件，PHP应用程序以及ASP.NET应用程序。
Sometimes folks freak out when I say you can have an ASP.NET WebForms app and a ASP.NET MVC app in the same AppPool as a "hybrid." Frankly, Dear Reader, people don't even realize the power and flexibility of IIS. When you plug in something new like node but run it the way you run other things it inherits all the coolness of the outer container, in this case, IIS.
有时，当我说您可以在同一“应用程序池”中将“ ASP.NET WebForms”应用程序和“ ASP.NET MVC”应用程序作为“混合对象”时，人们会感到非常惊讶。 坦白地说，亲爱的读者，人们甚至没有意识到IIS的强大功能和灵活性。 当您插入新的节点之类的节点，但以与其他节点相同的方式运行它时，它将继承外部容器(在本例中为IIS)的所有功能。
很好，您了解我，如何在Windows上运行node.js？ (Fine, you got me, how do I run node.js on Windows?)
I'm assuming you are running IIS7.
我假设您正在运行IIS7。
Go download node.exe, and put it in c:\node
去下载node.exe ，把它放在c：\ node
Unzip iisnode's zip into \inetpub\iisnode
将iisnode的zip解压缩到\ inetpub \ iisnode
(that was my idea, not sure if it's the best place)
(那是我的主意，不确定这是否是最好的地方)
- From an Administrator Command Line, run install.bat.在管理员命令行中，运行install.bat。
The install.bat will:
install.bat将：
- unregister existing "iisnode" global module from your installation of IIS if such registration exists如果存在这样的注册，请从IIS安装中注销现有的“ iisnode”全局模块
- register iisnode as a native module with your installation of IIS在安装IIS时将iisnode注册为本机模块
- install configuration schema for the "iisnode" module为“ iisnode”模块安装配置模式
- remove existing "iisnode" section from system.webServer section group in applicationHost.config从applicationHost.config中的system.webServer部分中删除现有的“ iisnode”部分
- add the "iisnode" section within the system.webServer section group in applicationHost.config在applicationHost.config的system.webServer部分组内添加“ iisnode”部分
- delete the iisnode web application if it exists删除iisnode Web应用程序(如果存在)
- add a new site iisnode to IIS将新站点iisnode添加到IIS
No warranties! Be careful, you're living on the edge. Remember, you're reading this stuff on some random dude's blog.
没有保证！ 请注意，您生活在边缘。 记住，您是在某个随机家伙的博客上阅读这些内容的。
WARNING:I couldn't figure out the right permissions for the AppPool and the File System so I wimped out and gave my local AppPool "SYSTEM" permissions. This is awful and totally my fault. I filed an issue on the iisnode GitHub and I'll fix it and update this post when I hear back.
警告：我无法确定对AppPool和文件系统的正确权限，所以我大胆地给了我本地的AppPool“ SYSTEM”权限。这太糟糕了，完全是我的错。我在iisnode GitHub上提交了一个问题，当我听到回音时，将对其进行修复并更新此帖子。
I made a new AppPool just for node, gave it SYSTEM access, then assigned the Node Site to this new AppPool. Your site should look like:
我为节点创建了一个新的AppPool，为它提供了系统访问权限，然后将节点站点分配给了这个新的AppPool。 您的网站应如下所示：
And if you click on Modules for this Site in IIS7 you should see iisnode as a native module:
并且，如果您在IIS7中单击“此站点的模块”，则应该将iisnode视为本机模块：
At this point, you should be able to hit http://localhost/node/helloworld/hello.js and get back:
此时，您应该可以访问http：//localhost/node/helloworld/hello.js并返回：
Hello, world! [helloworld sample]
The contents of which are simply:
其内容很简单：
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello, world! [helloworld sample]');
}).listen(process.env.PORT);
Lovely.
可爱。
熟悉WCAT(Web容量分析工具)和节点。 (Fooling around with WCAT (Web Capacity Analysis Tool) and node.)
Disclaimer:To be clear, this isso very fooling around.This is just to show that it works and it can do the basics really fast. I'm not doing a benchmark nor am I saying "this works better than this other thing." Remember, they just got started recently porting node itself to Windows, and Tomasz and friends are just beginning their work. So, don't overreach. That said, the preliminary work they are doing is really impressive.
免责声明：需要说明的是，这真是鬼话。 这只是为了表明它有效并且可以非常快速地完成基础操作。 我既没有做基准测试，也没有说“这比另一件事更好。” 记住，他们最近才刚开始将节点本身移植到Windows，Tomasz和朋友们才刚刚开始他们的工作。 因此，请勿超范围。 也就是说，他们正在做的初步工作确实令人印象深刻。
I couldn't help myself. I mean, it's one thing to install a helloworld of some new thing, run it once and go "OK, that runs." It's another to pound it until it says "Uncle." After I got the hello world stuff working, I wanted to do some poor man's stress testing to see what the players involved did.
我无能为力。 我的意思是，安装一个新事物的helloworld，运行一次，然后运行“确定，然后运行”，这是一回事。 这是另一回事，直到它说“叔叔”。 在你好世界工作开始后，我想做一些穷人的压力测试，看看所涉及的球员做了什么。
First, I installed WCAT, a free Web Capacity Analysis Tool from the IIS team.
首先，我安装了WCAT，这是IIS团队提供的免费Web容量分析工具。
Warning. This is a command-line only tool and it's really persnickety when you run it. It's confusing and it took me a minute to setup. Here's the steps I took after installing. This is all from an Administrator Command Prompt.Note also that I'm doing this all on one machine, which is cheesy, but remember, it is a GOM.
警告。 这是仅命令行工具，运行它时确实很固执。 令人困惑，花了我一分钟时间进行设置。 这是我安装后采取的步骤。 全部来自管理员命令提示符。 还要注意，我是在一台机器上完成所有操作，这很俗气，但请记住，这是GOM 。
- cscript //H:Cscriptcscript // H：Cscript
- wcat.wsf –terminate –update –clients localhostwcat.wsf –终止–更新–客户端本地主机
- Then I made a folder I called \nodetests and I put these three files in it:然后，我创建了一个名为\ nodetests的文件夹，并将这三个文件放入其中：
wcat.bat
wcat.bat
pushd C:\Users\Scott\Desktop\nodetests
"c:\program files\wcat\wcat.wsf" -terminate -run -clients localhost -f settings.ubr -t nodescenario.ubr -s localhost -singleip -o C:\Users\Scott\Desktop\nodetests
pause
nodescenario.ubr (or call it whatever you want)
nodescenario.ubr(或随意调用它)
This is so basic. It just beats on the four sample applications for a while.
这很基本。 它只是击败了四个示例应用程序一段时间。
scenario
{
name = "node_fun";
warmup = 30;
duration = 90;
cooldown = 30;
default
{
setheader
{
name = "Connection";
value = "keep-alive";
}
setheader
{
name = "Host";
value = server();
}
version = HTTP11;
statuscode = 200;
close = ka;
}
transaction
{
id = "foo";
weight = 1000;
request
{
url = "/node/logging/hello.js";
}
}
transaction
{
id = "bar";
weight = 2000;
request
{
url = "/node/helloworld/hello.js";
}
}
transaction
{
id = "baz";
weight = 2000;
request
{
url = "/node/defaultdocument/";
}
}
transaction
{
id = "bat";
weight = 2000;
request
{
url = "/node/configuration/hello.js";
}
}
}
settings.ubr
settings.ubr
I just copied in the one from samples and uncommented out and changed (and tweaked during testing) these lines:
我只是从样本中复制了一个，然后注释掉了并更改了(并在测试过程中进行了调整)这些行：
server = "hexpower7";
clients = 1;
virtualclients = 8;
Now, run the Test
现在，运行测试
Next, I ran wcat.bat as an Administrator...you can see all the little node.exe's firing up. I've got a
接下来，我以管理员身份运行wcat.bat ...您可以看到所有小node.exe都启动了。 我有一个
(Remember they are running as SYSTEM because I was unable to figure out the right permissions. That's my bad, no one else's. I'll figure it out one day.)
(请记住，它们以SYSTEM身份运行，因为我无法找出正确的权限。那是我的错，没有别人可以。我有一天会解决。)
Here's the WCAT tool's console output...I'm able to consistently do 10,000 hello worlds a second and ended up with just under a million normal requests and responses in 90 seconds. That's a lot of hello worlds.
这是WCAT工具的控制台输出...我每秒能够持续执行10,000个hello世界，并在90秒内完成了将近一百万次正常请求和响应。 那是很多世界。
Remember Hanselman's Rule of Scale.
记住汉瑟曼的规模规则。
"If you do nothing, you can scale infinitely." - Me
“如果您什么都不做，则可以无限扩展。” - 我
Of course, this is all local on a fast machine. This is just hello world (with some logging) so it's not testing node much, nor IIS much, but rather the collaboration between the whole system, IIS, iisnode, and node itself.
当然，这都是在快速计算机上本地实现的。 这只是一个打招呼的世界(带有一些日志记录)，因此它并没有太多地测试节点，也没有太多地测试IIS，而是整个系统，IIS，iisnode和节点本身之间的协作。
Aside: an ASP.NET IHttpHandler doing the exact same thingon this same machine gets 22,500 requests a second, so node and iisnode has some room to improve, which is great.
另外：在同一台计算机上执行完全相同的操作的ASP.NET IHttpHandler每秒获得22,500个请求，因此node和iisnode有一些改进的空间，这很棒。
Here's the node/iisnode results:
这是节点/ iisnode结果：
There's a lot of things I could configure on both sites, number of clients, virtual clients, as well as iisnode-specific settings (which are, nicely enough, managed in a web.config:
我可以在两个站点上配置很多东西，客户端数量，虚拟客户端，以及iisnode特定的设置(可以很好地在web.config中进行管理：
<configuration>
<system.webServer>
<handlers>
<add name="iisnode" path="hello.js" verb="*" modules="iisnode" />
</handlers>
<iisnode
nodeProcessCommandLine="%systemdrive%\node\node.exe"
maxProcessCountPerApplication="4"
maxConcurrentRequestsPerProcess="1024"
maxPendingRequestsPerApplication="1024"
maxNamedPipeConnectionRetry="3"
namedPipeConnectionRetryDelay="2000"
asyncCompletionThreadCount="4"
initialRequestBufferSize="4096"
maxRequestBufferSize="65536"
uncFileChangesPollingInterval="5000"
gracefulShutdownTimeout="60000"
loggingEnabled="true"
logDirectoryNameSuffix="logs"
maxLogFileSizeInKB="128"
appendToExistingLog="false"
/>
</system.webServer>
</configuration>
This is pretty cool stuff. I like that the team I work with is excited to make things work well on IIS and I'm stoked that I can mess around with node now without firing up VMs. I'll report back as I learn more!
这是很酷的东西。 我喜欢与我一起工作的团队为使IIS上的一切正常工作而感到兴奋，并且我感到很激动，我现在可以在不启动VM的情况下搞乱节点。 我会在我了解更多信息时回报！
相关链接 (Related Links)
iis node.js