content

• Failover Setup – Adding redundancy
• Configuring a Reverse Proxy
• Using Varnish Proxy
• Writing basic VCL for failover
• Where to go from here

• Official Varnish website
• Official Development website

###############################################################################
# EXAMPLE VARNISH CONFIGURATION
#
# sections you should customize to match your configuration
# are marked with the word "CUSTOMIZE"
# define the available back-ends.
# CUSTOMIZE this section to point to your packagers.
#
# in this example, we have 2 packagers hosted at packager1.example.com
# and packager2.example.com
#

backend b1 {
.host = packager1.example.com;
.probe = {
.url = "/";
.timeout = 150 ms;
.interval = 10s;
.window = 6;
.threshold = 5;
}
}

backend b2 {
.host = packager2.example.com;
.probe = {
.url = "/";
.timeout = 150 ms;
.interval = 10s;
.window = 6;
.threshold = 5;
}
}

# define the hash director that is used for m3u8 (HLS) requests.
# CUSTOMIZE this section if you have additional packagers

director hls hash {
{.backend = b1; .weight = 1;}
{.backend = b2; .weight = 1;}
}


# define the round_robin director that is used for HDS requests.
# CUSTOMIZE this section if you have additional packagers
director hds round-robin {
{.backend = b1;}
{.backend = b2;}}

## Called when a client request is received
sub vcl_recv {
set req.backend = hds;
}


## Use URL hashing direction scheme for .m3u8s in order to mitigate liveness issues on packager failure and restart

if (req.request == "GET" && req.url ~ "\.m3u8$" && req.url ~ "hls-live") {
set req.backend = hls;
if(req.restarts > 0){
set req.url = req.url + "?restart=" + req.restarts;
}
}

## Add a unique header containing the client address for the purposes of logging

if (req.restarts == 0) {
if (req.http.x-forwarded-for) {
set req.http.X-Forwarded-For =
req.http.X-Forwarded-For + ", " + client.ip;
} else {
set req.http.X-Forwarded-For = client.ip;
}
}

# grace settings, note this is also set in vcl_fetch,
set req.grace = 80s;

• A request is already pending for some specific content (deliver old content as long as fetching new content is in progress).
• No healthy back-end is available.

## always cache bootstraps:
if (req.request == "GET" && req.url ~ "\.(bootstrap)") {
return(lookup);
}

## always cache fragments:
if (req.request == "GET" && req.url ~ "(\wSeg[0-9]*-Frag[0-9]*)") {
return(lookup);
}

## do not cache these rules:
if (req.request != "GET" && req.request != "HEAD") {
return(pipe);
}

# Handle compression correctly. Different browsers send different
# "Accept-Encoding" headers, even though they mostly all support the same
# compression mechanisms. By consolidating these compression headers into
# a consistent format, we can reduce the size of the cache and get more
# hits.

if (req.http.Accept-Encoding) {
if (req.url ~ "\.(ts|bootstrap)$" ||
req.url ~ "(\wSeg[0-9]*-Frag[0-9]*)"){
# No point in compressing these
remove req.http.Accept-Encoding;

} elsif (req.http.Accept-Encoding ~ "gzip") {
set req.http.Accept-Encoding = "gzip";

} elsif (req.http.Accept-Encoding ~ "deflate" &&
req.http.user-agent !~ "MSIE") {
set req.http.Accept-Encoding = "deflate";

} else {
# unkown algorithm
remove req.http.Accept-Encoding;
}
}


## if it passes all these tests, do a lookup anyway;
return(lookup);


## Called when the requested object has been retrieved from the backend, or the request to the backend has failed
sub vcl_fetch {
# fail-over to the next server when we receive a 503.
# CUSTOMIZE the value of "503" for your deployment.
# It should be the same as the unavailable Response code
# set in httpd.conf at the server
if (beresp.status == 503) {
# CUSTOMIZE the value "1" for your deployment.
# It should be the number of packagers - 1.
if(req.restarts < 1) {
return (restart);
} else {
# all servers failed, generate a cache-able 404 error.
# NOTE: we have chosen not to use the varnish
# "error " mechanism to generate our
# error since those errors are not cached by varnish.
# instead, we will transform our 503 error into a 404 error.

set beresp.status = 404;
set beresp.response = "Not found.";

# CUSTOMIZE ttl to be 1/2 a fragment interval.
set beresp.ttl = 2s;


# CUSTOMIZE Cache-Control to be 1/2 a fragment interval.
set beresp.http.Cache-Control = "maxage=2";

unset beresp.http.expires;
}
}
# If the backend is unreachable, hold content for 10 mins
set beresp.grace = 600s;

if (req.backend.healthy) {
# Blanket cache everything for 1 fragment interval.
# CUSTOMIZE the value "4" for your deployment as the configured
# fragment duration.
set beresp.ttl = 4s;
} else {
# The backend is sick set ttl to 10 mins to serve stale content
set beresp.ttl = 600s;
}

## Do not cache 50x errors
if (beresp.status >= 500) {
set beresp.ttl = 0s;
}

set beresp.http.X-Cacheable = "YES";

return(deliver);
}

1. When the proxy receives a 503 HTTP error response from a back-end, we return restart form vcl_fetch. In this way the proxy will attempt the request with the next back-end in the pool.
2. As soon as any back-end returns a valid response, the proxy will send that fragment back to the player.
3. The restart counter increments every time a back-end fails to serve the request (returns a 503 response). We check on the restart counter and if all the back-ends fail to serve the request, the proxy returns a cacheable error (such as a 404). We also set the max-age of this error to a short value (e.g. half a fragment interval) to prevent unnecessary load on the backends.

## If no packager contains
sub vcl_error {
# Add your logic here
}

## Called when an object is in the cache, its a hit.
sub vcl_hit {
if (obj.ttl == 0s) {
return(pass);
}

return(deliver);
}

## Called when the requested object was not found in the cache
sub vcl_miss {
# Add your logic here
}

## Called before a cached object is delivered to the client
sub vcl_deliver {
set resp.http.X-Served-By = server.hostname;
if (obj.hits > 0) {
set resp.http.X-Cache = "HIT";
set resp.http.X-Cache-Hits = obj.hits;
} else {
set resp.http.X-Cache = "MISS";
}
return(deliver);
}

• See what’s new in Adobe Media Server
• Stream video over HTTP to iOS devices
• HTTP Dynamic Streaming