slashdot网站架构：硬件和软件 zz

港控/mmm° 2022-09-20 12:57 133阅读 0赞

http://slash.solidot.org/article.pl?sid=07/10/27/1244202&from=rss

Solidot网站经常不时出现小毛小病，比如最近留言计数器严重滞后。同样采用 [slashcode][]的slashdot是如何运行的，值得我们参考。它的Alexa排名在800左右（digg现在是100左右，差距越来越大了），每天的流量很惊人。在建站10周年之际，Slashdot的工程师介绍了网站整体架构，分为 [硬件][Link 1]和 [软件][Link 2]两部分。  
硬件：slashdot现在属于SourceForge公司，硬件基本结构与SourceForge旗下其它网站如SourceForge.net，Thinkgeek.com, Freshmeat.net，Linux.com等相同。 *一个数据中心，[活动地板][Link 3]、发电机、UPS、24x7小时安全防护等等之类，和一般的数据中心一样。  
带宽和网络：一对Cisco 7301s路由器，一对Foundry BigIron 8000s交换机，一对Rackable Systems 1Us作负载平衡防火墙：配置P4 Xeon 2.66Gz，2G RAM，2x80GB IDE，运行CentOS和LVS。  
16个web服务器，都运行Red Hat 9。2个用于统计内容：脚本，图像，非注册用户看到的首页；4个用于注册用户看到的首页内容；其余10个处理评论页。服务器型号为Rackable 1U：2 Xeon 2.66Ghz处理器，2GB of RAM，2x80GB IDE硬盘...*

7个数据库服务器，都运行CentOS 4，配置是2 Dual Opteron 270，16GB RAM，4x36GB 15K RPM SCSI Drives。一个是只写数据库，其余则是读写数据库，它们互相之间可以随时可以动态交换。  
  
软件： HTTP请求需经过 [pound][] servers，pound是一种代理服务器，它会选择一个web server来响应请求。slashdot一共有6个pound，一个是HTTPS加密访问模式（提供给订阅用户），5个都是标准的HTTP。web server使用Apache，数据库是MySQL。Slash 1.0是在2000年初完成的目前的最新版本是2.2.6。  
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_  
http://meta.slashdot.org/article.pl?sid=07/10/22/145209

Today we have Part 2 in our exciting 2 part series about the infrastructure that powers Slashdot. Last week Uriah told us [all about the hardware][Link 1] powering the system. This week, Jamie McCarthy picks up the story and tells us about the software... from pound to memcached to mysql and more. Hit that link and read on.

The software side of Slashdot takes over at the point where our load balancers -- described in [Friday's hardware story][Link 1] \-- hand off your incoming HTTP request to our [pound][] servers.

Pound is a reverse proxy, which means it doesn't service the request itself, it just chooses which web server to hand it off to. We run 6 pounds, one for HTTPS traffic and the other 5 for regular HTTP. (Didn't know we support HTTPS, did ya? It's one of the perks for [subscribers][]: you get to read Slashdot on the same webhead that admins use, which is always going to be responsive even during a crush of traffic -- because if it isn't, Rob's going to breathe down our necks!)

The pounds send traffic to one of the 16 [apaches][] on our 16 webheads -- 15 regular, and the 1 HTTPS. Now, pound itself is so undemanding that we run it side-by-side with the apaches. The HTTPS pound handles SSL itself, handing off a plaintext HTTP request to its machine's apache, so the apache it redirects traffic to doesn't need mod\_ssl compiled in. One less headache! Of our other 15 webheads, 5 also run a pound, not to distribute load but just for redundancy.

(Trivia: pound normally adds an X-Forwarded-For header, which [Slash::Apache][Slash_Apache] substitutes for the (internal) IP of pound itself. But sometimes if you use a proxy on the internet to do something bad, it will send us an X-Forwarded-For header too, which we [use][] to try to track abuse. So we patched pound to insert a special X-Forward-Pound header, so it doesn't overwrite what may come from an abuser's proxy.)

The other 15 webheads are segregated by type. This segregation is mostly what pound is for. We have 2 webheads for static (.shtml) requests, 4 for the dynamic homepage, 6 for dynamic comment-delivery pages (comments, article, pollBooth.pl), and 3 for all other dynamic scripts (ajax, tags, bookmarks, firehose). We segregate partly so that if there's a performance problem or a DDoS on a specific page, the rest of the site will remain functional. We're constantly changing the code and this sets up "performance firewalls" for when us silly coders decide to write infinite loops.

But we also segregate for efficiency reasons like httpd-level caching, and MaxClients tuning. Our webhead bottleneck is CPU, not RAM. We run MaxClients that might seem absurdly low (5-15 for dynamic webheads, 25 for static) but our philosophy is if we're not turning over requests quickly anyway, something's wrong, and stacking up more requests won't help the CPU chew through them any faster.

All the webheads run the same software, which they mount from a /usr/local exported by a read-only NFS machine. Everyone I've ever met outside of this company gives an involuntary shudder when NFS is mentioned, and yet we haven't had any problems since shortly after it was set up (2002-ish). I attribute this to a combination of our brilliant sysadmins and the fact that we only export read-only. The backend task that writes to /usr/local (to update index.shtml every minute, for example) runs on the NFS server itself.

The apaches are versions 1.3, because there's never been a reason for us to switch to 2.0. We compile in mod\_perl, and [lingerd][] to free up RAM during delivery, but the only other nonstandard module we use is mod\_auth\_useragent to keep unfriendly bots away. Slash does make extensive use of each [phase][] of the request loop (largely so we can send our 403's to out-of-control bots using a minimum of resources, and so your page is fully on its way while we write to the logging DB).

[Slash][slashcode], of course, is the open-source perl code that runs Slashdot. If you're thinking of playing around with it, grab a recent copy from [CVS][]: it's been years since we got around to a tarball release. The various scripts that handle web requests access the database through Slash's [SQL API][], implemented on top of [DBD::mysql][DBD_mysql] (now maintained, incidentally, by one of the original Slash 1.0 coders) and of course [DBI.pm][]. The most interesting parts of this layer might be:

(a) We don't use [Apache::DBI][Apache_DBI]. We use [connect\_cached][connect_cached], but actually our main connection cache is the global objects that hold the connections. Some small chunks of data are so frequently used that we keep them around in those objects.

(b) We almost never use statement handles. We have eleven ways of doing a SELECT and the differences are mostly how we massage the results into the perl data structure they return.

(c) We don't use [placeholders][]. Originally because DBD::mysql didn't take advantage of them, and now because we think any speed increase in a reasonably-optimized web app should be a trivial payoff for non-self-documenting argument order. Discuss!

(d) We built in [replication][] support. A database object requested as a reader picks a random slave to read from for the duration of your HTTP request (or the backend task). We can weight them manually, and we have a task that reweights them automatically. (If we do something stupid and wedge a slave's replication thread, every Slash process, across 17 machines, starts throttling back its connections to that machine within 10 seconds. This was originally written to handle slave DBs getting bogged down by load, but with our new faster DBs, that just never happens, so if a slave falls behind, one of us probably typed something dumb at the mysql> prompt.)

(e) We bolted on [memcached][] support. Why bolted-on? Because back when we first tried memcached, we got a huge performance boost by caching our three big data types (users, stories, comment text) and we're pretty sure additional caching would provide minimal benefit at this point. Memcached's main use is to get and set data objects, and Slash doesn't really bottleneck that way.

Slash 1.0 was written way back in early 2000 with decent support for get and set methods to abstract objects out of a database ([getDescriptions][], subclassed [\_wheresql][wheresql]) -- but over the years we've only used them a few times. Most data types that are candidates to be objectified either are processed in large numbers (like tags and comments), in ways that would be difficult to do efficiently by subclassing, or have complicated table structures and pre- and post-processing (like users) that would make any generic objectification code pretty complicated. So most data access is done through get and set methods written custom for each data type, or, just as often, through methods that perform one specific update or select.

Overall, we're pretty happy with the database side of things. Most tables are fairly well normalized, not fully but mostly, and we've found this improves performance in most cases. Even on a fairly large site like Slashdot, with modern hardware and a little thinking ahead, we're able to push code and schema changes live quickly. Thanks to running [multiple-master][Link 1] replication, we can keep the site fully [live][] even during blocking queries like ALTER TABLE. After changes go live, we can find performance problem spots and optimize (which usually means caching, caching, caching, and occasionally [multi-pass log processing][] for things like detecting abuse and picking users out of a hat who get mod points).

In fact, I'll go further than "pretty happy." Writing a database-backed web site has changed dramatically over the past seven years. The database used to be the bottleneck: centralized, hard to expand, slow. Now even a cheap DB server can run a pretty big site if you code defensively, and thanks to Moore's Law, memcached, and improvements in open-source database software, that part of the scaling issue isn't really a problem until you're practically the size of eBay. It's an exciting time to be coding web applications

[slashcode]: http://slashcode.com/
[Link 1]: http://meta.slashdot.org/article.pl?sid=07/10/18/1641203&tid=124
[Link 2]: http://meta.slashdot.org/article.pl?sid=07/10/22/145209
[Link 3]: http://en.wikipedia.org/wiki/Raised_floor
[pound]: http://www.apsis.ch/pound/
[subscribers]: http://meta.slashdot.org/subscribe.pl
[apaches]: http://httpd.apache.org/
[Slash_Apache]: http://slashcode.cvs.sourceforge.net/slashcode/slash/Slash/Apache/Apache.pm?revision=1.72&view=markup#l_244
[use]: http://slashcode.cvs.sourceforge.net/slashcode/slash/themes/slashcode/htdocs/users.pl?revision=1.339&view=markup#l_738
[lingerd]: http://www.iagora.com/about/software/lingerd/
[phase]: http://slashcode.cvs.sourceforge.net/slashcode/slash/bin/install-slashsite?revision=1.49&view=markup#l_554
[CVS]: http://slashcode.cvs.sourceforge.net/slashcode/slash/
[SQL API]: http://slashcode.cvs.sourceforge.net/slashcode/slash/Slash/DB/Utility/Utility.pm?view=markup
[DBD_mysql]: http://search.cpan.org/dist/DBD-mysql/
[DBI.pm]: http://dbi.perl.org/
[Apache_DBI]: http://search.cpan.org/dist/Apache-DBI/
[connect_cached]: http://search.cpan.org/%7Etimb/DBI/DBI.pm#connect_cached
[placeholders]: http://search.cpan.org/%7Etimb/DBI/DBI.pm#Placeholders_and_Bind_Values
[replication]: http://dev.mysql.com/doc/refman/5.0/en/replication.html
[memcached]: http://danga.com/memcached/
[getDescriptions]: http://slashcode.cvs.sourceforge.net/slashcode/slash/Slash/DB/MySQL/MySQL.pm?revision=1.987&view=markup#l_1473
[wheresql]: http://slashcode.cvs.sourceforge.net/slashcode/slash/Slash/DB/Utility/Utility.pm?revision=1.73&view=markup#l_26
[live]: http://meta.slashdot.org/article.pl?sid=06/11/09/1534204&tid=124
[multi-pass log processing]: https://slashdot.org/%7Ejamie/journal/93006