Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

nginx/1.28.0

System:

Linux 6.8.0-90-generic

PHP Version:

8.4.15

User:

alqudsvolunteers

Directory:

/home/alqudsvolunteers/rootlink/proc/thread-self/root/usr/share/doc/varnish/html/users-guide

Free Space:

79.89 GB

🔧 Quick Actions

✏️ Editing: vcl-backends.html

<!DOCTYPE html>

<title>Backend servers &#8212; Varnish version 7.5.0 documentation</title>
 <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=fa44fd50" />
 <link rel="stylesheet" type="text/css" href="../_static/classic.css?v=e2714048" />
 
 <script src="../_static/documentation_options.js?v=8214db13"></script>
 <script src="../_static/doctools.js?v=888ff710"></script>
 <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
 
 <link rel="index" title="Index" href="../genindex.html" />
 <link rel="search" title="Search" href="../search.html" />
 <link rel="next" title="Hashing" href="vcl-hashing.html" />
 <link rel="prev" title="Request and response VCL objects" href="vcl-variables.html" /> 
 </head><body>
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 accesskey="I">index</a></li>
 <li class="right" >
 <a href="vcl-hashing.html" title="Hashing"
 accesskey="N">next</a> |</li>
 <li class="right" >
 <a href="vcl-variables.html" title="Request and response VCL objects"
 accesskey="P">previous</a> |</li>
 <li class="nav-item nav-item-0"><a href="../index.html">Varnish version 7.5.0 documentation</a> &#187;</li>
 <li class="nav-item nav-item-1"><a href="index.html" >The Varnish Users Guide</a> &#187;</li>
 <li class="nav-item nav-item-2"><a href="vcl.html" accesskey="U">VCL - Varnish Configuration Language</a> &#187;</li>
 <li class="nav-item nav-item-this"><a href="">Backend servers</a></li> 
 </ul>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body" role="main">
 
 <section id="backend-servers">
<h1>Backend servers<a class="headerlink" href="#backend-servers" title="Link to this heading">¶</a></h1>
Varnish has a concept of “backend” or “origin” servers. A backend
server is the server providing the content Varnish will accelerate.
Our first task is to tell Varnish where it can find its backends. Start
your favorite text editor and open the relevant VCL file.
Somewhere in the top there will be a section that looks a bit like this.:
<div class="highlight-default notranslate"><div class="highlight"><pre># backend default {
# .host = &quot;127.0.0.1&quot;;
# .port = &quot;8080&quot;;
# }
</pre></div>
</div>
We remove the comment markings in this text stanza making the it look like.:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend default {
 .host = &quot;127.0.0.1&quot;;
 .port = &quot;8080&quot;;
}
</pre></div>
</div>
Now, this piece of configuration defines a backend in Varnish called
default. When Varnish needs to get content from this backend it will
connect to port 8080 on localhost (127.0.0.1).
Varnish can have several backends defined you can even join
several backends together into clusters of backends for load balancing
purposes.
</section>
<section id="the-none-backend">
<h1>The “none” backend<a class="headerlink" href="#the-none-backend" title="Link to this heading">¶</a></h1>
Backends can also be declared as <code class="docutils literal notranslate">none</code> with the following syntax::
<div class="highlight-default notranslate"><div class="highlight"><pre>backend default none;
</pre></div>
</div>
<code class="docutils literal notranslate">none</code> backends are special:
<ul>
<li>All backends declared <code class="docutils literal notranslate">none</code> compare equal:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend a none;
backend b none;

sub vcl_recv {
 set req.backend_hint = a;
 if (req.backend_hint == b) {
 return (synth(200, &quot;this is true&quot;));
 }
}
</pre></div>
</div>
</li>
<li>The <code class="docutils literal notranslate">none</code> backend evaluates to <code class="docutils literal notranslate">false</code> when used in a boolean
context:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend nil none;

sub vcl_recv {
 set req.backend_hint = nil;
 if (! req.backend_hint) {
 return (synth(200, &quot;We get here&quot;));
 }
}
</pre></div>
</div>
</li>
<li>When directors find no healthy backend, they typically return the
<code class="docutils literal notranslate">none</code> backend</li>
</ul>
</section>
<section id="multiple-backends">
<h1>Multiple backends<a class="headerlink" href="#multiple-backends" title="Link to this heading">¶</a></h1>
At some point you might need Varnish to cache content from several
servers. You might want Varnish to map all the URL into one single
host or not. There are lot of options.
Lets say we need to introduce a Java application into out PHP web
site. Lets say our Java application should handle URL beginning with
<cite>/java/</cite>.
We manage to get the thing up and running on port 8000. Now, lets have
a look at the <cite>default.vcl</cite>.:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend default {
 .host = &quot;127.0.0.1&quot;;
 .port = &quot;8080&quot;;
}
</pre></div>
</div>
We add a new backend.:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend java {
 .host = &quot;127.0.0.1&quot;;
 .port = &quot;8000&quot;;
}
</pre></div>
</div>
Now we need tell Varnish where to send the difference URL. Lets look at <cite>vcl_recv</cite>.:
<div class="highlight-default notranslate"><div class="highlight"><pre>sub vcl_recv {
 if (req.url ~ &quot;^/java/&quot;) {
 set req.backend_hint = java;
 } else {
 set req.backend_hint = default;
 }
}
</pre></div>
</div>
It’s quite simple, really. Lets stop and think about this for a
moment. As you can see you can define how you choose backends based on
really arbitrary data. You want to send mobile devices to a different
backend? No problem. <code class="docutils literal notranslate">if (req.http.User-agent ~ /mobile/) ..</code> should do the
trick.
Without an explicit backend selection, Varnish will continue using
the <cite>default</cite> backend. If there is no backend named <cite>default</cite>, the
first backend found in the vcl will be used as the default backend.
</section>
<section id="backends-and-virtual-hosts-in-varnish">
<h1>Backends and virtual hosts in Varnish<a class="headerlink" href="#backends-and-virtual-hosts-in-varnish" title="Link to this heading">¶</a></h1>
Varnish fully supports virtual hosts. They might however work in a somewhat
counter-intuitive fashion since they are never declared
explicitly. You set up the routing of incoming HTTP requests in
<cite>vcl_recv</cite>. If you want this routing to be done on the basis of virtual
hosts you just need to inspect <cite>req.http.host</cite>.
You can have something like this:
<div class="highlight-default notranslate"><div class="highlight"><pre>sub vcl_recv {
 if (req.http.host ~ &quot;foo.com&quot;) {
 set req.backend_hint = foo;
 } elsif (req.http.host ~ &quot;bar.com&quot;) {
 set req.backend_hint = bar;
 }
}
</pre></div>
</div>
Note that the first regular expressions will match “foo.com”,
“www.foo.com”, “zoop.foo.com” and any other host ending in “foo.com”. In
this example this is intentional but you might want it to be a bit
more tight, maybe relying on the <code class="docutils literal notranslate">==</code> operator in stead, like this:
<div class="highlight-default notranslate"><div class="highlight"><pre>sub vcl_recv {
 if (req.http.host == &quot;foo.com&quot; || req.http.host == &quot;www.foo.com&quot;) {
 set req.backend_hint = foo;
 }
}
</pre></div>
</div>
</section>
<section id="connecting-through-a-proxy">
<h1>Connecting Through a Proxy<a class="headerlink" href="#connecting-through-a-proxy" title="Link to this heading">¶</a></h1>
As of this release, Varnish can connect to an actual destination
through a proxy using the <a class="reference external" href="https://raw.githubusercontent.com/haproxy/haproxy/master/doc/proxy-protocol.txt">PROXY2</a> protocol. Other protocols may be
added.
For now, a typical use case of this feature is to make TLS-encrypted
connections through a TLS onloader. The onloader needs to support
dynamic connections with the destination address information taken
from a <a class="reference external" href="https://raw.githubusercontent.com/haproxy/haproxy/master/doc/proxy-protocol.txt">PROXY2</a> preamble. For example with <a class="reference external" href="http://www.haproxy.org/">haproxy</a> Version 2.2 or
higher, this snippet can be used as a basis for configuring an
onloader:
<div class="highlight-default notranslate"><div class="highlight"><pre># to review and adjust:
# - maxconn
# - bind ... mode ...
# - ca-file ...
#
listen sslon
 mode tcp
 maxconn 1000
 bind /path/to/sslon accept-proxy mode 777
 stick-table type ip size 100
 stick on dst
 server s00 0.0.0.0:0 ssl ca-file /etc/ssl/certs/ca-bundle.crt alpn http/1.1 sni fc_pp_authority
 server s01 0.0.0.0:0 ssl ca-file /etc/ssl/certs/ca-bundle.crt alpn http/1.1 sni fc_pp_authority
 server s02 0.0.0.0:0 ssl ca-file /etc/ssl/certs/ca-bundle.crt alpn http/1.1 sni fc_pp_authority
 # ...
 # A higher number of servers improves TLS session caching
</pre></div>
</div>
Varnish running on the same server/namespace can then use the
onloader with the <code class="docutils literal notranslate">.via</code> feature (see <a class="reference internal" href="../reference/vcl-backend.html#backend-definition-via">Attribute .via</a>):
<div class="highlight-default notranslate"><div class="highlight"><pre>backend sslon {
 .path = &quot;/path/to/sslon&quot;;
}

backend destination {
 .host = &quot;my.https.service&quot;;
 .port = &quot;443&quot;;
 .via = sslon;
}
</pre></div>
</div>
The <code class="docutils literal notranslate">.authority</code> attribute can be used to specify the <a class="reference external" href="https://en.wikipedia.org/wiki/Server_Name_Indication">SNI</a> for the
connection if it differs from <code class="docutils literal notranslate">.host</code>.
</section>
<section id="directors">
<h1>Directors<a class="headerlink" href="#directors" title="Link to this heading">¶</a></h1>
You can also group several backend into a group of backends. These
groups are called directors. This will give you increased performance
and resilience.
You can define several backends and group them together in a
director. This requires you to load a VMOD, a Varnish module, and then to
call certain actions in <cite>vcl_init</cite>.:
<div class="highlight-default notranslate"><div class="highlight"><pre>import directors; # load the directors

backend server1 {
 .host = &quot;192.168.0.10&quot;;
}
backend server2 {
 .host = &quot;192.168.0.11&quot;;
}

sub vcl_init {
 new bar = directors.round_robin();
 bar.add_backend(server1);
 bar.add_backend(server2);
}

sub vcl_recv {
 # send all traffic to the bar director:
 set req.backend_hint = bar.backend();
}
</pre></div>
</div>
This director is a round-robin director. This means the director will
distribute the incoming requests on a round-robin basis. There is
also a random director which distributes requests in a, you guessed it,
random fashion. If that is not enough, you can also write your own director
(see <a class="reference internal" href="../reference/directors.html#ref-writing-a-director">Writing a Director</a>).
But what if one of your servers goes down? Can Varnish direct all the
requests to the healthy server? Sure it can. This is where the Health
Checks come into play.
</section>
<section id="health-checks">
<h1>Health checks<a class="headerlink" href="#health-checks" title="Link to this heading">¶</a></h1>
Lets set up a director with two backends and health checks. First let
us define the backends:
<div class="highlight-default notranslate"><div class="highlight"><pre>backend server1 {
 .host = &quot;server1.example.com&quot;;
 .probe = {
 .url = &quot;/&quot;;
 .timeout = 1s;
 .interval = 5s;
 .window = 5;
 .threshold = 3;
 }
}

backend server2 {
 .host = &quot;server2.example.com&quot;;
 .probe = {
 .url = &quot;/&quot;;
 .timeout = 1s;
 .interval = 5s;
 .window = 5;
 .threshold = 3;
 }
}
</pre></div>
</div>
What is new here is the <code class="docutils literal notranslate">probe</code>. In this example Varnish will check the
health of each backend every 5 seconds, timing out after 1 second. Each
poll will send a GET request to /. If 3 out of the last 5 polls succeeded
the backend is considered healthy, otherwise it will be marked as sick.
Refer to the <a class="reference internal" href="../reference/vcl-probe.html#reference-vcl-probes">Backend health probes</a> section in the
<a class="reference internal" href="../reference/vcl.html#vcl-7">VCL</a> documentation for more information.
Now we define the ‘director’:
<div class="highlight-default notranslate"><div class="highlight"><pre>import directors;

sub vcl_init {
 new vdir = directors.round_robin();
 vdir.add_backend(server1);
 vdir.add_backend(server2);
}
</pre></div>
</div>
You use this <cite>vdir</cite> director as a backend_hint for requests, just like
you would with a simple backend. Varnish will not send traffic to hosts
that are marked as unhealthy.
Varnish can also serve stale content if all the backends are down. See
<a class="reference internal" href="vcl-grace.html#users-guide-handling-misbehaving-servers">Grace mode and keep</a> for more information on
how to enable this.
Please note that Varnish will keep health probes running for all loaded
VCLs. Varnish will coalesce probes that seem identical - so be careful
not to change the probe config if you do a lot of VCL loading. Unloading
the VCL will discard the probes. For more information on how to do this
please see ref:<cite>reference-vcl-director</cite>.
</section>
<section id="layering">
<h1>Layering<a class="headerlink" href="#layering" title="Link to this heading">¶</a></h1>
By default, most directors’ <code class="docutils literal notranslate">.backend()</code> methods return a reference
to the director itself. This allows for layering, like in this
example:
<div class="highlight-default notranslate"><div class="highlight"><pre>import directors;

sub vcl_init {
 new dc1 = directors.round_robin();
 dc1.add_backend(server1A);
 dc1.add_backend(server1B);

new dc2 = directors.round_robin();
 dc2.add_backend(server2A);
 dc2.add_backend(server2B);

new dcprio = directors.fallback();
 dcprio.add_backend(dc1);
 dcprio.add_backend(dc2);
}
</pre></div>
</div>
With this initialization, <code class="docutils literal notranslate">dcprio.backend()</code> will resolve to either
<code class="docutils literal notranslate">server1A</code> or <code class="docutils literal notranslate">server1B</code> if both are healthy or one of them if
only one is healthy. Only if both are sick will a healthy server from
<code class="docutils literal notranslate">dc2</code> be returned, if any.
</section>
<section id="director-resolution">
<h1>Director Resolution<a class="headerlink" href="#director-resolution" title="Link to this heading">¶</a></h1>
The actual resolution happens when the backend connection is prepared
after a return from <code class="docutils literal notranslate">vcl_backend_fetch {}</code> or <code class="docutils literal notranslate">vcl_pipe {}</code>.
In some cases like server sharding the resolution outcome is required
already in VCL. For such cases, the <code class="docutils literal notranslate">.resolve()</code> method can be used,
like in this example:
<div class="highlight-default notranslate"><div class="highlight"><pre>set req.backend_hint = dcprio.backend().resolve();
</pre></div>
</div>
When using this statement with the previous example code,
<code class="docutils literal notranslate">req.backend_hint</code> will be set to one of the <code class="docutils literal notranslate">server*</code> backends or
the <code class="docutils literal notranslate">none</code> backend if they were all sick.
<code class="docutils literal notranslate">.resolve()</code> works on any object of the <code class="docutils literal notranslate">BACKEND</code> type.
</section>
<section id="connection-pooling">
<h1>Connection Pooling<a class="headerlink" href="#connection-pooling" title="Link to this heading">¶</a></h1>
Opening connections to backends always comes at a cost: Depending on
the type of connection and backend infrastructure, the overhead for
opening a new connection ranges from pretty low for a local Unix
domain socket (see <a class="reference internal" href="../reference/vcl-backend.html#backend-definition">Backend definition</a> <code class="docutils literal notranslate">.path</code> attribute) to
substantial for establishing possibly multiple TCP and/or TLS
connections over possibly multiple hops and long network
paths. However relevant the overhead, it certainly always exists.
So because re-using existing connections can generally be considered
to reduce overhead and latencies, Varnish pools backend connections by
default: Whenever a backend task is finished, the used connection is
not closed but rather added to a pool for later reuse. To avoid a
connection from being reused, the <code class="docutils literal notranslate">Connection: close</code> http header
can be added in <a class="reference internal" href="../reference/vcl-step.html#vcl-backend-fetch">vcl_backend_fetch</a>.
While backends are defined per VCL, connection pooling works across
VCLs and even across backends: By default, the identifier for pooled
connections is constructed from the <code class="docutils literal notranslate">.host</code>/<code class="docutils literal notranslate">.port</code> or
<code class="docutils literal notranslate">.path</code> attributes of the <a class="reference internal" href="../reference/vcl-backend.html#backend-definition">Backend definition</a> (VMODs can make
use of custom identifiers). So whenever two backends share the same
address information, irrespective of which VCLs they are defined in,
their connections are taken from a common pool.
If not actively closed by the backend, pooled connections are kept
open by Varnish until the <a class="reference internal" href="../reference/varnishd.html#ref-param-backend-idle-timeout">backend_idle_timeout</a>
expires.
</section>

<div class="clearer"></div>
 </div>
 </div>
 </div>
 <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
 <div class="sphinxsidebarwrapper">
 <div>
 <h3><a href="../index.html">Table of Contents</a></h3>
 <ul>
<li><a class="reference internal" href="#">Backend servers</a></li>
<li><a class="reference internal" href="#the-none-backend">The “none” backend</a></li>
<li><a class="reference internal" href="#multiple-backends">Multiple backends</a></li>
<li><a class="reference internal" href="#backends-and-virtual-hosts-in-varnish">Backends and virtual hosts in Varnish</a></li>
<li><a class="reference internal" href="#connecting-through-a-proxy">Connecting Through a Proxy</a></li>
<li><a class="reference internal" href="#directors">Directors</a></li>
<li><a class="reference internal" href="#health-checks">Health checks</a></li>
<li><a class="reference internal" href="#layering">Layering</a></li>
<li><a class="reference internal" href="#director-resolution">Director Resolution</a></li>
<li><a class="reference internal" href="#connection-pooling">Connection Pooling</a></li>
</ul>

</div>
 <div>
 <h4>Previous topic</h4>
 <a href="vcl-variables.html"
 title="previous chapter">Request and response VCL objects</a>
 </div>
 <div>
 <h4>Next topic</h4>
 <a href="vcl-hashing.html"
 title="next chapter">Hashing</a>
 </div>
 <div role="note" aria-label="source link">
 <h3>This Page</h3>
 <ul class="this-page-menu">
 <li><a href="../_sources/users-guide/vcl-backends.rst.txt"
 rel="nofollow">Show Source</a></li>
 </ul>
 </div>
<div id="searchbox" style="display: none" role="search">
 <h3 id="searchlabel">Quick search</h3>
 <div class="searchformwrapper">
 <form class="search" action="../search.html" method="get">
 <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
 <input type="submit" value="Go" />
 </form>
 </div>
</div>
<script>document.getElementById('searchbox').style.display = "block"</script>
 </div>
 </div>
 <div class="clearer"></div>
 </div>
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 >index</a></li>
 <li class="right" >
 <a href="vcl-hashing.html" title="Hashing"
 >next</a> |</li>
 <li class="right" >
 <a href="vcl-variables.html" title="Request and response VCL objects"
 >previous</a> |</li>
 <li class="nav-item nav-item-0"><a href="../index.html">Varnish version 7.5.0 documentation</a> &#187;</li>
 <li class="nav-item nav-item-1"><a href="index.html" >The Varnish Users Guide</a> &#187;</li>
 <li class="nav-item nav-item-2"><a href="vcl.html" >VCL - Varnish Configuration Language</a> &#187;</li>
 <li class="nav-item nav-item-this"><a href="">Backend servers</a></li> 
 </ul>
 </div>
 <div class="footer" role="contentinfo">
 &#169; Copyright 2010-2014, Varnish Software AS.
 Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.2.6.
 </div>
 </body>
</html>

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: vcl-backends.html

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation