Contact   •   Products   •   Search

Rick Strahl's Web Log

Wind, waves, code and everything in between...
ASP.NET • C# • HTML5 • JavaScript • AngularJs

Built-in GZip/Deflate Compression on IIS 7.x


IIS 7 improves internal compression functionality dramatically making it much easier than previous versions to take advantage of compression that’s built-in to the Web server. IIS 7 also supports dynamic compression which allows automatic compression of content created in your own applications (ASP.NET or otherwise!). The scheme is based on content-type sniffing and so it works with any kind of Web application framework.

While static compression on IIS 7 is super easy to set up and turned on by default for most text content (text/*, which includes HTML and CSS, as well as for JavaScript, Atom, XAML, XML), setting up dynamic compression is a bit more involved, mostly because the various default compression settings are set in multiple places down the IIS –> ASP.NET hierarchy.

Let’s take a look at each of the two approaches available:

  • Static Compression
    Compresses static content from the hard disk. IIS can cache this content by compressing the file once and storing the compressed file on disk and serving the compressed alias whenever static content is requested and it hasn’t changed. The overhead for this is minimal and should be aggressively enabled.
  • Dynamic Compression
    Works against application generated output from applications like your ASP.NET apps. Unlike static content, dynamic content must be compressed every time a page that requests it regenerates its content. As such dynamic compression has a much bigger impact than static caching.

How Compression is configured

Compression in IIS 7.x  is configured with two .config file elements in the <system.WebServer> space. The elements can be set anywhere in the IIS/ASP.NET configuration pipeline all the way from ApplicationHost.config down to the local web.config file. The following is from the the default setting in ApplicationHost.config (in the %windir%\System32\inetsrv\config forlder) on IIS 7.5 with a couple of small adjustments (added json output and enabled dynamic compression):

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <system.webServer>
    
    <httpCompression directory="%SystemDrive%\inetpub\temp\IIS Temporary Compressed Files">
      <scheme name="gzip" dll="%Windir%\system32\inetsrv\gzip.dll" staticCompressionLevel="9" />
      <dynamicTypes>
        <add mimeType="text/*" enabled="true" />
        <add mimeType="message/*" enabled="true" />
        <add mimeType="application/x-javascript" enabled="true" />
        <add mimeType="application/json" enabled="true" />
        <add mimeType="*/*" enabled="false" />
      </dynamicTypes>
      <staticTypes>
        <add mimeType="text/*" enabled="true" />
        <add mimeType="message/*" enabled="true" />
        <add mimeType="application/x-javascript" enabled="true" />
        <add mimeType="application/atom+xml" enabled="true" />
        <add mimeType="application/xaml+xml" enabled="true" />
        <add mimeType="*/*" enabled="false" />
      </staticTypes>
    </httpCompression>
    
    <urlCompression doStaticCompression="true" doDynamicCompression="true" />
    
  </system.webServer>
</configuration>

You can find documentation on the httpCompression and urlCompression keys here respectively:

http://msdn.microsoft.com/en-us/library/ms690689%28v=vs.90%29.aspx

http://msdn.microsoft.com/en-us/library/aa347437%28v=vs.90%29.aspx

The httpCompression Element – What and How to compress

Basically httpCompression configures what types to compress and how to compress them. It specifies the DLL that handles gzip encoding and the types of documents that are to be compressed. Types are set up based on mime-types which looks at returned Content-Type headers in HTTP responses. For example, I added the application/json to mime type to my dynamic compression types above to allow that content to be compressed as well since I have quite a bit of AJAX content that gets sent to the client.

The UrlCompression Element – Enables and Disables Compression

The urlCompression element is a quick way to turn compression on and off. By default static compression is enabled server wide, and dynamic compression is disabled server wide. This might be a bit confusing because the httpCompression element also has a doDynamicCompression attribute which is set to true by default, but the urlCompression attribute by the same name actually overrides it.

The urlCompression element only has three attributes: doStaticCompression, doDynamicCompression and dynamicCompressionBeforeCache. The doCompression attributes are the final determining factor whether compression is enabled, so it’s a good idea to be explcit! The default for doDynamicCompression='false”, but doStaticCompression="true"!

Static Compression is enabled by Default, Dynamic Compression is not

Because static compression is very efficient in IIS 7 it’s enabled by default server wide and there probably is no reason to ever change that setting. Dynamic compression however, since it’s more resource intensive, is turned off by default. If you want to enable dynamic compression there are a few quirks you have to deal with, namely that enabling it in ApplicationHost.config doesn’t work. Setting:

<urlCompression doDynamicCompression="true" />

in applicationhost.config appears to have no effect and I had to move this element into my local web.config to make dynamic compression work. This is actually a smart choice because you’re not likely to want dynamic compression in every application on a server. Rather dynamic compression should be applied selectively where it makes sense. However, nowhere is it documented that the setting in applicationhost.config doesn’t work (or more likely is overridden somewhere and disabled lower in the configuration hierarchy).

So: remember to set doDynamicCompression=”true” in web.config!!!

How Static Compression works

Static compression works against static content loaded from files on disk. Because this content is static and not bound to change frequently – such as .js, .css and static HTML content – it’s fairly easy for IIS to compress and then cache the compressed content. The way this works is that IIS compresses the files into a special folder on the server’s hard disk and then reads the content from this location if already compressed content is requested and the underlying file resource has not changed. The semantics of serving an already compressed file are very efficient – IIS still checks for file changes, but otherwise just serves the already compressed file from the compression folder.

The compression folder is located at:

%windir%\inetpub\temp\IIS Temporary Compressed Files\ApplicationPool\

If you look into the subfolders you’ll find compressed files:

CompressedFileFolder

These files are pre-compressed and IIS serves them directly to the client until the underlying files are changed.

As I mentioned before – static compression is on by default and there’s very little reason to turn that functionality off as it is efficient and just works out of the box. The one tweak you might want to do is to set the compression level to maximum. Since IIS only compresses content very infrequently it would make sense to apply maximum compression. You can do this with the staticCompressionLevel setting on the scheme element:

<scheme name="gzip" dll="%Windir%\system32\inetsrv\gzip.dll" staticCompressionLevel="9" />

Other than that the default settings are probably just fine.

Dynamic Compression – not so fast!

By default dynamic compression is disabled and that’s actually quite sensible – you should use dynamic compression very carefully and think about what content you want to compress. In most applications it wouldn’t make sense to compress *all* generated content as it would generate a significant amount of overhead. Scott Fortsyth has a great post that details some of the performance numbers and how much impact dynamic compression has. Depending on how busy your server is you can play around with compression and see what impact it has on your server’s performance.

There are also a few settings you can tweak to minimize the overhead of dynamic compression. Specifically the httpCompression key has a couple of CPU related keys that can help minimize the impact of Dynamic Compression on a busy server:

  • dynamicCompressionDisableCpuUsage
  • dynamicCompressionEnableCpuUsage

By default these are set to 90 and 50 which means that when the CPU hits 90% compression will be disabled until CPU utilization drops back down to 50%. Again this is actually quite sensible as it utilizes CPU power from compression when available and falling off when the threshold has been hit. It’s a good way some of that extra CPU power on your big servers to use when utilization is low. Again these settings are something you likely have to play with. I would probably set the upper limit a little lower than 90% maybe around 70% to make this a feature that kicks in only if there’s lots of power to spare. I’m not really sure how accurate these CPU readings that IIS uses are as Cpu usage on Web Servers can spike drastically even during low loads. Don’t trust settings – do some load testing or monitor your server in a live environment to see what values make sense for your environment.

Finally for dynamic compression I tend to add one Mime type for JSON data, since a lot of my applications send large chunks of JSON data over the wire. You can do that with the application/json content type:

<add mimeType="application/json" enabled="true" />

What about Deflate Compression?

The default compression is GZip. The documentation hints that you can use a different compression scheme and mentions Deflate compression. And sure enough you can change the compression settings to:

<scheme name="deflate" dll="%Windir%\system32\inetsrv\gzip.dll" staticCompressionLevel="9" />

to get deflate style compression. The deflate algorithm produces slightly more compact output so I tend to prefer it over GZip but more HTTP clients (other than browsers) support GZip than Deflate so be careful with this option if you build Web APIs.

I also had some issues with the above value actually being applied right away. Changing the scheme in applicationhost.config didn’t show up on the site  right away. It required me to do a full IISReset to get that change to show up before I saw the change over to deflate compressed content. Content was slightly more compressed with deflate – not sure if it’s worth the slightly less common compression type, but the option at least is available.

IIS 7 finally makes GZip Easy

In summary IIS 7 makes GZip easy finally, even if the configuration settings are a bit obtuse and the documentation is seriously lacking. But once you know the basic settings I’ve described here and the fact that you can override all of this in your local web.config it’s pretty straight forward to configure GZip support and tweak it exactly to your needs.

Static compression is a total no brainer as it adds very little overhead compared to direct static file serving and provides solid compression. Dynamic Compression is a little more tricky as it does add some overhead to servers, so it probably will require some tweaking to get the right balance of CPU load vs. compression ratios. Looking at large sites like Amazon, Yahoo, NewEgg etc. – they all use

Related Content

Make Donation
Posted in IIS7   ASP.NET  


Feedback for this Post

 
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Cesar May 05, 2011 @ 2:19am
Great article.

We've been using this option, however we've encountered a problem with clients using a version of IE6 that has problems understanding compressed js - versions on Win 2000 for example.

What I know is that the IIS configuration does not allow selective compression according to a custom predicate (in this case the browser's version) which makes this non-usable for dynamic javascript in case you want your site to support IE6 as well.

We had to disable compression for javascript through IIS and keep doing it programmatically
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Rick Strahl May 05, 2011 @ 2:37am
@Cesar - that seems odd. Browsers/clients should request whether they support gzip/deflate via the Accept header, which as far as I know IIS does do (it has to). Are you saying that weird version of IE is not sending the right accept header then?
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Wayne Ye May 05, 2011 @ 2:50am
@Cesar, gzip on IE6 should be a "known issue", please refer: http://stackoverflow.com/questions/1456112/known-issues-with-gzip-and-ie6

@Rick, I am your blog reader since 6 months ago, very pleased to see this blog talking about gzip compression, casually I wrote a blog entry last year also tried to describe gzip in IIS/ASP.NET (links below), could you kindly take a look at it and raise your precious suggestion:)
http://www.codeproject.com/Articles/186233/Utilize-gzip-compression-in-IIS.aspx
http://wayneye.com/Blog/IIS-Gzip-Compression
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Cesar May 05, 2011 @ 3:01am
@Rick - Yes, that's exactly what I am saying. The following code is taken from the ToolkitScriptManager of the AjaxControlToolkit which is aimed at this problem

if (!request.Browser.IsBrowser("IE") || (6 < request.Browser.MajorVersion))
{
foreach (string acceptEncoding in (request.Headers["Accept-Encoding"] ?? "").ToUpperInvariant().Split(','))
{
if ("GZIP" == acceptEncoding)
{
// Browser wants GZIP; wrap the output stream with a GZipStream
response.AddHeader("Content-encoding", "gzip");
outputStream = new GZipStream(outputStream, CompressionMode.Compress);
break;
}
else if ("DEFLATE" == acceptEncoding)
{
// Browser wants Deflate; wrap the output stream with a DeflateStream
response.AddHeader("Content-encoding", "deflate");
outputStream = new DeflateStream(outputStream, CompressionMode.Compress);
break;
}
}
}

The code indicates that some versions of IE6 (older ones) send an incorrect header (or have a bug with compressed javascript - either way :) ) and therefore the AjaxControlToolkit for example does not compress javascript for IE6 at all since it can't know the exact version and can't be sure whether the client can handle it
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Cesar May 05, 2011 @ 3:03am
@Wayne - thanks, I'll check it out
# re: Built-in GZip/Deflate Compression on IIS 7.x
by vivitron May 05, 2011 @ 3:15am
Good article... I tried to use dynamic compression in my latest web app, but I finally implemented it programmatically because it seemed unreliable in regards to when it would compress. Using IIS 7.0 - have not tried IIS 7.5.

The other nice thing about doing it in the app is that you can flip a switch to turn it all off without console access.
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Carlos May 05, 2011 @ 5:06am
@Cesar, one thing I think you could do is use URL Rewrite and use a condition that matches User Agent for IE6 and the requests in question and rewrite the Accept header to blank so that it does not do compression.
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Cory July 07, 2011 @ 1:22pm
Cannot seem to get it to work for JSON, returned from a JsonResult in MVC 3.0. Everything else is compressing nicely though.
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Xuanyi August 26, 2011 @ 12:58am
For those running iis on 64bit version. The applicationHost.config file is located under %WINDIR%\SysWOW64\inetsrv\Config. See http://xuanyili.com/2011/08/26/configure-gzip-http-compression-on-iis-7/
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Bill Hebb September 23, 2011 @ 5:10pm
Rick:
AFAIK IIS 7.5 sets a threshold of the number of hits within a period of time before any compression regardless of the web.config settings, occurs. That threshold (frequentHitThreshold) has to be set to something reasonable before any benefits can be seen, and most shared servers won't allow the default to be overridden. See http://www.iis.net/ConfigReference/system.webServer/serverRuntime

Furthermore, the old technique of deflatestream compressing in the global asax won't work on the IIS 7.5 newer integrated app pool.

Thoughts?

Best,
Bill
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Cesar May 14, 2012 @ 3:46am
# re: Built-in GZip/Deflate Compression on IIS 7.x
by Thomas December 09, 2012 @ 7:19pm
"The elements can be set anywhere in the IIS/ASP.NET configuration pipeline all the way from ApplicationHost.config down to the local web.config file."

This seems to not be the case with IIS8. Applicationhost.config includes this:

<section name="httpCompression" allowDefinition="AppHostOnly" overrideModeDefault="Deny" />

Which means that web.config cannot override the compression settings (eg. turn on dynamic gzip).
 


West Wind  © Rick Strahl, West Wind Technologies, 2005 - 2014