Skip to main content

Configure Gzip and Brotli compression

Orange's CDN supports Gzip and Brotli edge compression. When Fetch Compressed does not apply to the request, the CDN requests uncompressed content from the origin, compresses it at the edge, and caches the compressed response. Browsers that support compression receive that response even when the origin does not compress it.

JPEG, PNG, video formats, and PDF are already compressed. These formats provide little or no size reduction from Gzip or Brotli and may increase file size.

Gzip and Brotli can be enabled together. When both are available, Brotli takes precedence for a client that sends Accept-Encoding: br. If the client does not support Brotli, CDN uses Gzip. A request without Accept-Encoding, or without gzip or br in that header, is delivered uncompressed.

Brotli requires Origin Shielding. Enable Origin Shielding for the CDN resource before enabling Brotli. Without it, the Brotli option has no effect. The smallest file Brotli compresses is 128 bytes.

Gzip and Brotli cannot be enabled together with Fetch Compressed or large files optimization in the same scope, whether that scope is the resource settings or one rule.

Gzip and Brotli in the resource settings can be combined with Fetch Compressed in a rule. Edge nodes then compress all requests, and the origin compresses the requests that match the rule.

The reverse combination is not supported. When Fetch Compressed is enabled in the resource settings, Gzip and Brotli cannot be enabled in a rule.

Configure Gzip and Brotli

1. Navigate to the CDN resources list and click the CDN resource to configure.

CDN resources list with a CDN resource row selected

2. In the sidebar, under the Content section, click GZip compression. Brotli compression is on the same page.

Compression settings with the Enable GZip compression and Enable Brotli compression toggles on one page

3. Turn on the toggle for Enable GZip compression to enable the option.

4. Turn on the toggle for Enable Brotli compression to enable the option. In the Content types area, select the MIME types to compress. text/html stays selected.

  • application/javascript. Selected by default.
  • application/json. Selected by default.
  • application/x-javascript. Selected by default.
  • application/xml. Selected by default.
  • application/xml+rss. Selected by default.
  • text/css. Selected by default.
  • text/html. Selected by default. Cannot be deselected.
  • text/javascript. Selected by default.
  • text/plain. Selected by default.
  • text/xml. Selected by default.
  • application/vnd.ms-fontobject. Not added by default.
  • application/x-font-ttf. Not added by default.
  • image/x-icon. Not added by default.
  • image/svg+xml. Not added by default.
  • application/wasm. Not added by default.

5. Click Save changes.

6. Purge the CDN resource cache. Content cached before compression was enabled is not recompressed automatically.

7. Request a file with Accept-Encoding and read Content-Encoding in the response.

curl -I -H "Accept-Encoding: br, gzip" https://cdn.example.com/file.css

Enable Gzip or Brotli compression for a CDN resource. Gzip is a boolean. Brotli takes the MIME types to compress, and that list must include text/html. Brotli compression requires origin shielding.

An API token is required. The CDN resource ID is visible under CDN → CDN Resources, or from the resources list call.

A resource update sets options.gzipOn, options.brotli_compression, or both in one request. Do not enable either option in the same scope as fetch_compressed or large files optimization. That scope is the resource settings or one rule. Enabling either option while fetch_compressed is enabled in that scope returns HTTP 400. Gzip and Brotli on the resource can be combined with Fetch Compressed in a rule. When fetch_compressed is enabled on the resource, Gzip and Brotli cannot be enabled in a rule.

Open a terminal and export the required variables:

export GCORE_API_KEY="{YOUR_API_KEY}"
export CDN_RESOURCE_ID="{YOUR_CDN_RESOURCE_ID}"

Enable Gzip

Set gzipOn.enabled and gzipOn.value to true.

import os

from gcore import CDB

client = CDB()
resource_id = int(os.environ["CDN_RESOURCE_ID"])

updated = client.cdn.cdn_resources.update(
    resource_id,
    options={"gzipOn": {"enabled": True, "value": True}},
)
gzip = updated.options.gzip_on
print(gzip.enabled, gzip.value)

package main

import (
    "context"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cdn"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()
    resourceID, err := strconv.ParseInt(os.Getenv("CDN_RESOURCE_ID"), 10, 64)
    if err != nil {
        panic(err)
    }

    updated, err := client.CDN.CDNResources.Update(ctx, resourceID, cdn.CDNResourceUpdateParams{
        Options: cdn.CDNResourceUpdateParamsOptions{
            GzipOn: cdn.CDNResourceUpdateParamsOptionsGzipOn{
                Enabled: true,
                Value:   true,
            },
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(updated.Options.GzipOn.Enabled, updated.Options.GzipOn.Value)
}

curl -X PATCH "https://api.cdb-staging.cdn.orange.com/cdn/resources/$CDN_RESOURCE_ID" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "options": {
      "gzipOn": {
        "enabled": true,
        "value": true
      }
    }
  }'

The API returns HTTP 200. The saved option is:

{
  "enabled": true,
  "value": true
}

Enable Brotli

Set brotli_compression.value to the MIME types to compress. text/html is required. A list without it returns HTTP 400. The saved list can come back in a different order.

import os

from gcore import CDB

client = CDB()
resource_id = int(os.environ["CDN_RESOURCE_ID"])

updated = client.cdn.cdn_resources.update(
    resource_id,
    options={
        "brotli_compression": {
            "enabled": True,
            "value": ["text/html", "text/css"],
        }
    },
)
brotli = updated.options.brotli_compression
print(brotli.enabled, brotli.value)

package main

import (
    "context"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cdn"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()
    resourceID, err := strconv.ParseInt(os.Getenv("CDN_RESOURCE_ID"), 10, 64)
    if err != nil {
        panic(err)
    }

    updated, err := client.CDN.CDNResources.Update(ctx, resourceID, cdn.CDNResourceUpdateParams{
        Options: cdn.CDNResourceUpdateParamsOptions{
            BrotliCompression: cdn.CDNResourceUpdateParamsOptionsBrotliCompression{
                Enabled: true,
                Value:   []string{"text/html", "text/css"},
            },
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(updated.Options.BrotliCompression.Enabled, updated.Options.BrotliCompression.Value)
}

curl -X PATCH "https://api.cdb-staging.cdn.orange.com/cdn/resources/$CDN_RESOURCE_ID" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "options": {
      "brotli_compression": {
        "enabled": true,
        "value": ["text/html", "text/css"]
      }
    }
  }'

The API returns HTTP 200. The saved option is:

{
  "enabled": true,
  "value": ["text/css", "text/html"]
}

Turn Gzip off

Set gzipOn.enabled and gzipOn.value to false. The Go SDK omits a false boolean, so that call sends the JSON object explicitly.

import os

from gcore import CDB

client = CDB()
resource_id = int(os.environ["CDN_RESOURCE_ID"])

updated = client.cdn.cdn_resources.update(
    resource_id,
    options={"gzipOn": {"enabled": False, "value": False}},
)
gzip = updated.options.gzip_on
print(gzip.enabled, gzip.value)

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    "strconv"

    gcore "github.com/G-Core/gcore-go"
    "github.com/G-Core/gcore-go/cdn"
    "github.com/G-Core/gcore-go/packages/param"
)

func main() {
    client := gcore.NewClient()
    ctx := context.Background()
    resourceID, err := strconv.ParseInt(os.Getenv("CDN_RESOURCE_ID"), 10, 64)
    if err != nil {
        panic(err)
    }

    updated, err := client.CDN.CDNResources.Update(ctx, resourceID, cdn.CDNResourceUpdateParams{
        Options: cdn.CDNResourceUpdateParamsOptions{
            GzipOn: param.Override[cdn.CDNResourceUpdateParamsOptionsGzipOn](
                json.RawMessage(`{"enabled":false,"value":false}`),
            ),
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(updated.Options.GzipOn.Enabled, updated.Options.GzipOn.Value)
}

curl -X PATCH "https://api.cdb-staging.cdn.orange.com/cdn/resources/$CDN_RESOURCE_ID" \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "options": {
      "gzipOn": {
        "enabled": false,
        "value": false
      }
    }
  }'

The API returns HTTP 200. The saved option is:

{
  "enabled": false,
  "value": false
}

Content cached before compression was enabled is not recompressed. Purge the cache after the update.

Request a file with Accept-Encoding and read Content-Encoding in the response.

curl -I -H "Accept-Encoding: br, gzip" https://cdn.example.com/file.css

Set gzip_on and brotli_compression so the CDN compresses a response at the edge, using the Terraform provider v2. A client that sends Accept-Encoding: br receives Brotli. A client that supports only Gzip receives Gzip. A request without gzip or br in Accept-Encoding is delivered uncompressed.

Brotli requires origin shielding. brotli_compression.value must include text/html. A list without text/html returns HTTP 400. The saved list can come back in a different order. Do not set gzip_on or brotli_compression in the same scope as fetch_compressed or large files optimization. That scope is the resource settings or one rule. Those options on the resource can be combined with Fetch Compressed in a rule. When fetch_compressed is enabled on the resource, do not enable Gzip or Brotli in a rule. Run terraform apply after editing options. Content cached before compression was enabled is not recompressed. Purge the cache after the update.

Enable Gzip

Set enabled and value to true. When Fetch Compressed does not apply to the request, the CDN requests uncompressed content from the origin and serves a Gzip response when the client accepts gzip.

resource "gcore_cdn_origin_group" "example" {
  name = "my-origin-group"

  sources = [
    {
      source  = "example.com"
      enabled = true
    }
  ]
}

resource "gcore_cdn_resource" "example" {
  cname           = "cdn.example.com"
  origin_group    = gcore_cdn_origin_group.example.id
  origin_protocol = "HTTPS"

  options = {
    gzip_on = {
      enabled = true
      value   = true
    }
  }
}

Enable Brotli

Keep gzip_on enabled and set brotli_compression to the MIME types to compress. With text/html and text/css, a client that sends Accept-Encoding: br receives Brotli for those types.

resource "gcore_cdn_origin_group" "example" {
  name = "my-origin-group"

  sources = [
    {
      source  = "example.com"
      enabled = true
    }
  ]
}

resource "gcore_cdn_resource" "example" {
  cname           = "cdn.example.com"
  origin_group    = gcore_cdn_origin_group.example.id
  origin_protocol = "HTTPS"

  options = {
    gzip_on = {
      enabled = true
      value   = true
    }

    brotli_compression = {
      enabled = true
      value   = ["text/html", "text/css"]
    }
  }
}

Turn Gzip off

Set gzip_on.enabled and gzip_on.value to false. Leave brotli_compression enabled, so a client that sends Accept-Encoding: br still receives Brotli.

resource "gcore_cdn_origin_group" "example" {
  name = "my-origin-group"

  sources = [
    {
      source  = "example.com"
      enabled = true
    }
  ]
}

resource "gcore_cdn_resource" "example" {
  cname           = "cdn.example.com"
  origin_group    = gcore_cdn_origin_group.example.id
  origin_protocol = "HTTPS"

  options = {
    gzip_on = {
      enabled = false
      value   = false
    }

    brotli_compression = {
      enabled = true
      value   = ["text/html", "text/css"]
    }
  }
}

Request a file with Accept-Encoding and read Content-Encoding in the response.

curl -I -H "Accept-Encoding: br, gzip" https://cdn.example.com/file.css