Varnish Cache

https://www.varnish.org/docs/
Admin
Varnish Cache is a high-performance open-source web application accelerator and HTTP reverse proxy...
Tokens:498,204
Snippets:4,310
Trust Score:7.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example: varnishd with Unix domain socket

Source: https://www.varnish.org/docs/whats-new/upgrading-6.0

Example command that starts Varnish with a Unix domain socket listener, using PROXY protocol and setting user, group, and mode permissions. The socket file is created at startup, and any existing file at that path is unlinked first.

```bash
varnishd -a /path/to/listen.sock,PROXY,user=vcache,group=varnish,mode=660

```

--------------------------------

### xblob.get() method example

Source: https://www.varnish.org/docs/reference/vmod_blob

Example of using the get() method to retrieve the BLOB and then encode it with blob.encode().

```vcl
set resp.http.The-Blob1 =
    blob.encode(blob=theblob1.get());

set resp.http.The-Blob2 =
    blob.encode(blob=theblob2.get());

set resp.http.The-Stringblob =
    blob.encode(blob=stringblob.get());
 
```

--------------------------------

### Startup CLI command file for varnishd -I

Source: https://www.varnish.org/docs/whats-new/changes-5.1

Example CLI commands for the new '-I cli_file' option. These commands are executed before the worker process starts, allowing VCL labels to be set up. Prefixing a command with '-' prevents failure from aborting startup.

```varnish-cli
vcl.load panic /etc/varnish_panic.vcl
vcl.load siteA0 /etc/varnish_siteA.vcl
vcl.load siteB0 /etc/varnish_siteB.vcl
vcl.load siteC0 /etc/varnish_siteC.vcl
vcl.label siteA siteA0
vcl.label siteB siteB0
vcl.label siteC siteC0
vcl.load main /etc/varnish_main.vcl
vcl.use main

```

--------------------------------

### start

Source: https://www.varnish.org/docs/reference/varnish-cli

Start the Varnish cache process.

```APIDOC
## start

### Description
Start the Varnish cache process.

### Method
CLI

### Endpoint
start
```

--------------------------------

### Start and wait for Varnish instance

Source: https://www.varnish.org/docs/reference/vtc

Starts the Varnish instance and/or waits for events. After successful start, macros like ${vNAME_addr}, ${vNAME_port}, and ${vNAME_sock} become available.

```text
varnish vNAME [-start] [-wait] [-wait-running] [-wait-stopped]

```

--------------------------------

### Enable and start varnish.service with systemctl enable --now

Source: https://www.varnish.org/docs/tutorials/configuring-varnish-systemd-services

Enable and start the varnish.service in one operation using the `--now` option. This enables and starts the Varnish service right away.

```bash
sudo systemctl enable varnish --now

```

--------------------------------

### Example output of systemctl status for running varnish.service

Source: https://www.varnish.org/docs/tutorials/configuring-varnish-systemd-services

Example output from `sudo systemctl status varnish` when the service is properly installed and running. The output varies between systemd and Varnish package versions.

```text
● varnish.service - Varnish Cache, a high-performance HTTP accelerator
     Loaded: loaded (/usr/lib/systemd/system/varnish.service; enabled; preset: enabled)
     Active: active (running) since Wed 2026-04-15 18:23:32 UTC; 8s ago
    Process: 2547 ExecStart=/usr/sbin/varnishd -a :80 -a localhost:8443,PROXY -f /etc/varnish/default.vcl -P /run/varnish/varnishd.pid -p feature=+http2 -s>
   Main PID: 2548 (varnishd)
      Tasks: 219
     Memory: 93.8M (peak: 94.2M)
        CPU: 514ms
     CGroup: /system.slice/varnish.service
             ├─2548 /usr/sbin/varnishd -a :80 -a localhost:8443,PROXY -f /etc/varnish/default.vcl -P /run/varnish/varnishd.pid -p feature=+http2 -s malloc,>
             └─2562 /usr/sbin/varnishd -a :80 -a localhost:8443,PROXY -f /etc/varnish/default.vcl -P /run/varnish/varnishd.pid -p feature=+http2 -s malloc,>

Apr 15 18:23:32 ip-172-31-40-94 systemd[1]: Starting varnish.service - Varnish Cache, a high-performance HTTP accelerator...
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Info: Working directory not mounted on tmpfs partition
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Working directory not mounted on tmpfs partition
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Version: varnish-9.0.1 revision e8e39111b9d37f0e90130e8c66c53acc9be1d3f4
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Platform: Linux,6.17.0-1007-aws,x86_64,-jlinux,-smalloc,-sdefault,-hcritbit
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Child (2562) Started
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Child launched OK
Apr 15 18:23:32 ip-172-31-40-94 varnishd[2548]: Child (2562) said Child starts
Apr 15 18:23:32 ip-172-31-40-94 systemd[1]: Started varnish.service - Varnish Cache, a high-performance HTTP accelerator.

```

--------------------------------

### vcl.state example

Source: https://www.varnish.org/docs/whats-new/changes-4.1

Example of changing a VCL to cold state and verifying with vcl.list.

```text
varnish> vcl.state 62f5275f-a937-4df9-9fbb-c12336bdfdb8 cold
200

varnish> vcl.list
200
available  auto/warm       0 boot
available  auto/cold       0 62f5275f-a937-4df9-9fbb-c12336bdfdb8

```

--------------------------------

### Start Docker Compose stack

Source: https://www.varnish.org/docs/install-guide/install-docker

Start the Varnish and Apache stack using Docker Compose. Reads the compose.yml file in the current directory and starts the containers.

```bash
docker compose up

```

--------------------------------

### std.fnmatch examples

Source: https://www.varnish.org/docs/reference/vmod_std

Pattern matching examples demonstrating wildcards, character classes, and options.

```vcl
# Matches URLs such as /foo/bar and /foo/baz
if (std.fnmatch("/foo/\*", req.url)) { ... }
```

```vcl
# Matches URLs such as /foo/bar/baz and /foo/baz/quux
if (std.fnmatch("/foo/\*/\*", bereq.url)) { ... }
```

```vcl
# Matches /foo/bar/quux, but not /foo/bar/baz/quux
if (std.fnmatch("/foo/\*/quux", req.url)) { ... }
```

```vcl
# Matches /foo/bar/quux and /foo/bar/baz/quux
if (std.fnmatch("/foo/\*/quux", req.url, pathname=false)) { ... }
```

```vcl
# Matches /foo/bar, /foo/car and /foo/far
if (std.fnmatch("/foo/?ar", req.url)) { ... }
```

```vcl
# Matches /foo/ followed by a non-digit
if (std.fnmatch("/foo/[!0-9]", req.url)) { ... }
```

--------------------------------

### Install Varnish with dnf

Source: https://www.varnish.org/docs/install-guide/install-rhel-compatible

Installs Varnish Cache after the repository is registered.

```bash
sudo dnf install varnish
```

--------------------------------

### Define and start a varnishtest server agent

Source: https://www.varnish.org/docs/tutorials/hands-on-varnishtest

Defines a varnishtest scenario with a server agent that receives a request and sends a response, then starts and waits for the server. The server name must start with 's'. The server is not started until the -start command is issued, and -wait blocks until the specification completes.

```vtc
varnishtest "our first agent and specification block"

server s1 {
	# receive request
	rxreq
	# transmit response
	txresp -status 200 -hdr "connection: close" -hdr "beep: boop" -body "Father\n"
}

# note that this above doesn't actually start the server, it mereley defines it
# we can start the server like this
server s1 -start

# then, we can ask s1 to wait, and the call will only return once the spec is
# executed
server s1 -wait

```

--------------------------------

### Enable and start varnishncsa service

Source: https://www.varnish.org/docs/tutorials/varnish-access-logs-varnishncsa

Commands to enable and start the varnishncsa.service systemd service. Enabling ensures it starts after reboot.

```bash
sudo systemctl enable varnishncsa
sudo systemctl start varnishncsa

```

--------------------------------

### Automated test with shell and curl

Source: https://www.varnish.org/docs/tutorials/hands-on-varnishtest

Example of a varnishtest test that starts a server and uses a shell block to run curl with a command substitution to get the listening port.

```vtc
varnishtest "our first agent and specification block"
server s1 {
	rxreq
	txresp
} -start
shell {
	curl -v $(ss -plunt | awk '/varnishtest/ {print $5; exit}')
}

```

--------------------------------

### HTTP GET request example

Source: https://www.varnish.org/docs/tutorials/http-caching-basics

Shows a simple HTTP GET request to /about. The URI and Host header are used to identify the cached object.

```http
GET /about HTTP/1.1

```

--------------------------------

### varnishlog -x tag exclusion example

Source: https://www.varnish.org/docs/tutorials/varnishlog

Use the -x parameter to exclude tags from the output. This example includes all tags starting with Req but excludes ReqHeader and ReqUnset, showing the resulting output.

```bash
varnishlog -i "Req*" -x ReqHeader,ReqUnset

```

```text
-   ReqStart       172.28.0.1 52280 http
-   ReqMethod      GET
-   ReqURL         /
-   ReqProtocol    HTTP/1.1
-   ReqAcct        140 0 140 294 608 902

```

--------------------------------

### CLI command file for startup VCL loading

Source: https://www.varnish.org/docs/reference/varnishd

CLI command file example to load VCL configurations, apply labels, and activate the main VCL at startup. Every line must end with a newline; last line must be terminated. A failed command prefixed with '-' does not abort startup.

```varnish
vcl.load panic /etc/varnish_panic.vcl
vcl.load siteA0 /etc/varnish_siteA.vcl
vcl.load siteB0 /etc/varnish_siteB.vcl
vcl.load siteC0 /etc/varnish_siteC.vcl
vcl.label siteA siteA0
vcl.label siteB siteB0
vcl.label siteC siteC0
vcl.load main /etc/varnish_main.vcl
vcl.use main
```

--------------------------------

### Example output of systemctl status for disabled varnish.service

Source: https://www.varnish.org/docs/tutorials/configuring-varnish-systemd-services

Example output from `systemctl status` when the varnish.service is not enabled. The `varnish.service; disabled` part indicates the service is not enabled and will not start automatically on system startup.

```text
○ varnish.service - Varnish Cache, a high-performance HTTP accelerator
     Loaded: loaded (/usr/lib/systemd/system/varnish.service; disabled; preset: enabled)
     Active: inactive (dead)

```

--------------------------------

### Activate VCL with vcl.use

Source: https://www.varnish.org/docs/users-guide/run_cli

Make a loaded VCL program the active VCL. New requests will start using it immediately.

```bash
varnish> vcl.use some_name

```

--------------------------------

### Tunnel specification example

Source: https://www.varnish.org/docs/reference/vtc

Example of a tunnel specification that combines barriers, pause, delay, send, and resume commands. The tunnel is started in the background with the -start argument. If one end of the tunnel closes before the specification ends, the test case fails.

```text
tunnel t1 {
    barrier b1 sync
    pause
    delay 1
    send 42
    barrier b2 sync
    resume
} -start
 
```

--------------------------------

### Import Varnish repository signing keys

Source: https://www.varnish.org/docs/install-guide/install-debian-ubuntu

Creates the keyring directory and imports the Varnish signing key into /etc/apt/keyrings/varnish.gpg.

```bash
sudo mkdir -p /etc/apt/keyrings/
curl -Ls https://packages.varnish-software.com/varnish/varnish.pub.asc | gpg --dearmor | sudo tee /etc/apt/keyrings/varnish.gpg > /dev/null

```

--------------------------------

### Configure backend in /etc/varnish/default.vcl

Source: https://www.varnish.org/docs/tutorials/starting-varnish

The first block shows the default backend configuration in /etc/varnish/default.vcl, pointing to 127.0.0.1:8080. The second block shows the edited version that points to example.com:80, which is the host and port of the origin server.

```vcl
vcl 4.1;

backend default {
    .host = "127.0.0.1";
    .port = "8080";
}
 
```

```vcl
vcl 4.1;

backend default {
    .host = "example.com";
    .port = "80";
}
 
```

--------------------------------

### VCL vcl_recv backend_hint routing example

Source: https://www.varnish.org/docs/tutorials/introduction

Routes requests whose URL starts with /images/ to the image_server backend and all others to application_server using req.backend_hint in vcl_recv.

```vcl
sub vcl_recv {
   if (req.url ~ "^/images/") {
       set req.backend_hint = image_server;
   } else {
       set req.backend_hint = application_server;
   }
}
 
```

--------------------------------

### Example varnishncsa log line

Source: https://www.varnish.org/docs/tutorials/varnish-access-logs-varnishncsa

A sample log line generated by varnishncsa in the NCSA combined log format, showing a GET request from a curl client.

```plaintext
172.17.0.1 - - [18/May/2022:11:57:56 +0000] "GET / HTTP/1.1" 200 45 "-" "curl"

```

--------------------------------

### vcl.use

Source: https://www.varnish.org/docs/reference/varnish-cli

Switch to the named configuration immediately.

```APIDOC
## vcl.use <configname|label>

### Description
Switch to the named configuration immediately.

### Method
CLI

### Endpoint
vcl.use

### Parameters
#### Arguments
- **configname|label** (string) - Required - The name of the configuration or label to switch to.
```

--------------------------------

### varnishlog -i with wildcard tag inclusion

Source: https://www.varnish.org/docs/tutorials/varnishlog

Wildcards are supported in tag inclusion. This rewrites the previous example to include all tags starting with VCL_ along with ReqUrl, grouped by session.

```bash
varnishlog -i "ReqUrl,VCL_*" -g session

```

--------------------------------

### VCL vcl_backend_response cache policy example

Source: https://www.varnish.org/docs/tutorials/introduction

Sets beresp.ttl to 1 year for image responses (Content-Type starting with image/) and 1 hour for other responses unless a Cache-Control max-age header is present.

```vcl
sub vcl_backend_response {
    if(beresp.http.content-type ~ "^image/") {
        set beresp.ttl = 1y;
    } elseif(beresp.http.cache-control !~ "(s-)?max-?age=[0-9]+") {
        set beresp.ttl = 1h;
    }
 }
 
```

--------------------------------

### varnishlog -i Begin output showing transaction hierarchy

Source: https://www.varnish.org/docs/tutorials/varnishlog

Example output from running `varnishlog -i Begin`. Shows the Begin tag for each transaction, with VXID references indicating parent transactions (e.g., bereq 2 fetch, req 2 esi, sess 0 HTTP/1).

```plaintext
*   << BeReq    >> 3
-   Begin          bereq 2 fetch

*   << BeReq    >> 5
-   Begin          bereq 4 fetch

*   << Request  >> 4
-   Begin          req 2 esi

*   << Request  >> 2
-   Begin          req 1 rxreq

*   << Session  >> 1
-   Begin          sess 0 HTTP/1

```

--------------------------------

### vmod-var: Variable support in VCL

Source: https://www.varnish.org/docs/extra-features

Example VCL using the var VMOD to set and get variables of various types, clear local variables, and use global variables as state flags.

```vcl
vcl 4.1;
import var;

sub vcl_recv {
    # Set and get some values.
    var.set("foo", "bar");
    set req.http.x-foo = var.get("foo");

    var.set_int("ten", 10);
    var.set_int("five", 5);
    set req.http.twenty = var.get_int("ten") + var.get_int("five") + 5;

    # VCL will use the first token to decide on the final data type.
    # set req.http.X-lifetime = var.get_int("ten") + " seconds"; #  Won't work.
    set req.http.X-lifetime = "" + var.get_int("ten") + " seconds";  # Works!

    var.set_duration("timedelta", 1m);  # 60s
    set req.http.d1 = var.get_duration("timedelta");

    var.set_ip("endpoint", client.ip);
    set req.http.x-client = var.get_ip("endpoint");

    # Unset all non-global variables.
    var.clear();

    # Demonstrate use of global variables as state flags.
    if (req.url ~ "/close$") {
        var.global_set("open", "no");
    }
    else if (req.url ~ "/open$") {
        var.global_set("open", "yes");
    }

    if (var.global_get("open") != "yes") {
        return (synth(200, "We are currently closed, sorry!"));
    }
}
 
```

--------------------------------

### Enable varnish.service with systemctl enable

Source: https://www.varnish.org/docs/tutorials/configuring-varnish-systemd-services

Enable the varnish.service to ensure automatic startup. This sets up the required symlinks and reloads systemd configuration, but does not start the service.

```bash
sudo systemctl enable varnish

```

--------------------------------

### varnishtest log output for failing expect

Source: https://www.varnish.org/docs/tutorials/hands-on-varnishtest

Example varnishtest log output showing a passing expect (resp.http.x <= 17.5) and a failing one (resp.body == "tadaaa"). Lines starting with --- indicate failures.

```shell
**   c1    === expect resp.http.x <= 17.5
**** c1    EXPECT resp.http.x (17.4) <= "17.5" match
**   c1    === expect resp.body == "tadaaa"
---- c1    EXPECT resp.body (tadbbb) == "tadaaa" failed

```

--------------------------------

### Install prerequisites for repository registration

Source: https://www.varnish.org/docs/install-guide/install-debian-ubuntu

Run this command to install apt-transport-https, curl, and gpg, which are needed to add the Varnish repository.

```bash
sudo apt-get install -y apt-transport-https curl gpg

```

--------------------------------

### VSL output for request with Cookie header causing pass

Source: https://www.varnish.org/docs/tutorials/troubleshooting-varnish

Example VSL output showing a GET request with a Cookie header (lang=en) that results in a pass. The built-in VCL for vcl_recv bypasses the cache when a Cookie header is present.

```bash
$ sudo varnishlog -i ReqUrl -i ReqMethod -i ReqProtocol -I ReqHeader:Host \
    -I ReqHeader:Cookie -I ReqHeader:Authorization \
    -i VCL_call -i VCL_return \
    -q "VCL_call eq 'PASS'"
*   << Request  >> 3
-   ReqMethod      GET
-   ReqURL         /
-   ReqProtocol    HTTP/1.1
-   ReqHeader      Host: localhost
-   ReqHeader      Cookie: lang=en
-   VCL_call       RECV
-   VCL_return     pass
-   VCL_call       HASH
-   VCL_return     lookup
-   VCL_call       PASS
-   VCL_return     fetch
-   VCL_call       DELIVER
-   VCL_return     deliver

```

--------------------------------

### Set up PATH and vmod_path for testing a VMOD

Source: https://www.varnish.org/docs/reference/varnishtest

Builds a PATH and vmod_path from pkg-config variables to test a VMOD against a Varnish build tree. The VMOD must be installed first, for example in a temp directory. The resulting vmod_path is passed to varnishtest with -p vmod_path=...

```shell
export PKG_CONFIG_PATH=/path/to/install/lib/pkgconfig

BINDIR="$(pkg-config --variable=bindir varnishapi)"
SBINDIR="$(pkg-config --variable=sbindir varnishapi)"
PATH="SBINDIR:BINDIR:$PATH"

VMODDIR="$(pkg-config --variable=vmoddir varnishapi)"
VMOD_PATH="/path/to/your/vmod/build/dir:$VMODDIR"

varnishtest -p vmod_path="$VMOD_PATH" ...
```

--------------------------------

### Configure probe window, threshold, and initial

Source: https://www.varnish.org/docs/reference/vcl-probe

Configures a probe with a 1-second interval, a window of 60, threshold of 45, and initial happy entries of 43. This backend becomes healthy as soon as two good probes have happened after VCL load.

```vcl
.interval = 1s;
.window = 60;
.threshold = 45;
.initial = 43;

```

--------------------------------

### Run a varnishtest script with server, varnish, and client

Source: https://www.varnish.org/docs/reference/varnishtest

A complete varnishtest script that starts a mock server, a varnish instance with a VCL that enables ESI and sets TTLs, and a client that sends two requests. The client expects a gzip-compressed response for /bar and an uncompressed ESI-processed response for /foo. Run it with varnishtest to verify the described behavior.

```vtc
varnishtest "#1029"

server s1 {
        rxreq
        expect req.url == "/bar"
        txresp -gzipbody {[bar]}

        rxreq
        expect req.url == "/foo"
        txresp -body {<h1>FOO<esi:include src="/bar"/>BARF</h1>}

} -start

varnish v1 -vcl+backend {
        sub vcl_backend_response {
                set beresp.do_esi = true;
                if (bereq.url == "/foo") {
                        set beresp.ttl = 0s;
                } else {
                        set beresp.ttl = 10m;
                }
        }
} -start

client c1 {
        txreq -url "/bar" -hdr "Accept-Encoding: gzip"
        rxresp
        gunzip
        expect resp.bodylen == 5

        txreq -url "/foo" -hdr "Accept-Encoding: gzip"
        rxresp
        expect resp.bodylen == 21
} -run
```

--------------------------------

### VSL output for POST request causing pass

Source: https://www.varnish.org/docs/tutorials/troubleshooting-varnish

Example VSL output showing a POST request that results in a pass. The ReqMethod is POST, and the VCL_call sequence shows RECV returning pass, leading to a fetch and deliver. Only GET and HEAD requests are cacheable.

```bash
$ sudo varnishlog -i ReqUrl -i ReqMethod -i ReqProtocol -I ReqHeader:Host \
    -I ReqHeader:Cookie -I ReqHeader:Authorization \
    -i VCL_call -i VCL_return \
    -q "VCL_call eq 'PASS'"
*   << Request  >> 2
-   ReqMethod      POST
-   ReqURL         /
-   ReqProtocol    HTTP/1.1
-   ReqHeader      Host: localhost
-   VCL_call       RECV
-   VCL_return     pass
-   VCL_call       HASH
-   VCL_return     lookup
-   VCL_call       PASS
-   VCL_return     fetch
-   VCL_call       DELIVER
-   VCL_return     deliver

```

--------------------------------

### varnishlog -X tag exclusion by regular expression

Source: https://www.varnish.org/docs/tutorials/varnishlog

Use the -X uppercase parameter to exclude tags based on a regular expression. This example includes ReqUrl and RespHeader but excludes response headers starting with X or x, removing headers like X-Varnish from the output.

```bash
varnishlog -g request -i ReqUrl -i RespHeader -X "RespHeader:(X|x)-"

```

```text
*   << Request  >> 5
-   ReqURL         /
-   RespHeader     Content-Type: application/json; charset=utf-8
-   RespHeader     Content-Length: 539
-   RespHeader     ETag: W/"21b-faj3J9Bg0wmX965fRcvtQFqPZr4"
-   RespHeader     Date: Fri, 27 Nov 2020 09:19:48 GMT
-   RespHeader     Age: 99
-   RespHeader     Accept-Ranges: bytes
-   RespHeader     Connection: keep-alive

```

--------------------------------

### Varnish ExecStart with TLS on port 443

Source: https://www.varnish.org/docs/tutorials/putting-varnish-on-ports-80-and-443

ExecStart configuration for Varnish 9 with native TLS, listening on ports 80 and 443.

```systemd
ExecStart=/usr/sbin/varnishd \
	  -a :80,http \
	  -a :443,https \
	  -a localhost:8443,PROXY \
	  -f /etc/varnish/default.vcl \
	  -P %t/%N/varnishd.pid \
	  -p feature=+http2 \
	  -s malloc,256m
 
```

--------------------------------

### Run varnishadm help

Source: https://www.varnish.org/docs/users-guide/run_cli

Run varnishadm help to list available CLI commands. This is the basic way to control varnishd from the command line.

```bash
varnishadm help

```

--------------------------------

### Pass vmod_path to varnishtest with -p

Source: https://www.varnish.org/docs/reference/varnishtest

Passes a vmod_path parameter to all varnishd instances started by the test script, allowing the same test cases to run against both installed and built VMODs. The -p option can pass any parameter, enabling a build matrix without changing the test suite.

```shell
varnishtest -p vmod_path=... /path/to/*.vtc
```

--------------------------------

### Use a VMOD in a varnishtest script

Source: https://www.varnish.org/docs/reference/varnishtest

Shows the structure of a varnishtest script that uses a VMOD imported in the VCL. The varnish instance is started with -vcl+backend and the VMOD is imported inside the VCL block. This pattern works with both installed and built VMODs when varnishtest is run with -p vmod_path=...

```vtc
server s1 {...} -start

varnish v1 -vcl+backend {
    import wossname;

    ...
} -start

...
```

--------------------------------

### blob.blob() constructor examples

Source: https://www.varnish.org/docs/reference/vmod_blob

Examples of creating blob objects with different decoding schemes, including named arguments and default decoding.

```vcl
new theblob1 = blob.blob(BASE64, encoded="YmxvYg==");

# same with named arguments
new theblob2 = blob.blob(encoded="YmxvYg==", decoding=BASE64);

# string as a blob
new stringblob = blob.blob(encoded="bazz");
 
```
Tokens:
Raw