Backend struct | backend | Fastly Compute Rust SDK

Structin backendfastly 0.13.1View source

pub struct Backend { /* private fields */ }

A named backend.

This represents a backend associated with a service that we can send requests to, potentially caching the responses received.

Backends come in one of two flavors:

Static Backends: These backends are created using the Fastly UI or API, and are predefined by the user. Static backends have short names (see the precise naming rules in Backend::from_name) that are usable across every session of a service.
Dynamic Backends: These backends are created programmatically using the Backend::builder API. They are defined at runtime, and may or may not be shared across sessions depending on how they are configured.

To use a backend, pass it to the crate::Request::send method. Alternatively, the following values can be automatically coerced into a backend for you, without the need to explicitly create a Backend object, although they may all induce panics:

Any string type (&str, String, or &String) will be automatically turned into the static backend of the same name.

Using Static Backends

As stated at the top level, the following snippet is a minimal program that resends a request to a static backend named "example_backend":

use fastly::{Error, Request, Response};

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    Ok(ds_req.send("example_backend")?)
}

A safer alternative to this example would be the following:

use fastly::{Backend, Error, Request, Response};

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    match Backend::from_name("example_backend") {
       Ok(backend) => Ok(ds_req.send(backend)?),
       Err(_) => {
            // custom backend failure response
            unimplemented!()
       }
    }
}

as this version allows you to handle backend errors more cleanly.

Validating Support for Dynamic Backends

Since dynamic backends are only enabled for some services, it may be particularly useful to ensure that dynamic backends are supported in your Compute service. The easiest way to do so is to try to create a dynamic backend, and then explicitly check for the crate::backend::BackendCreationError::Disallowed code, as follows:

use fastly::{Backend, Error, Request, Response};
use fastly::backend::BackendCreationError;

#[fastly::main]
fn main(ds_req: Request) -> Result<Response, Error> {
    match Backend::builder("custom_backend", "example.org:993").finish() {
        Ok(backend) => Ok(ds_req.send(backend)?),
        Err(BackendCreationError::Disallowed) => {
           // custom code ofr handling when dynamic backends aren't supported
           unimplemented!()
        }
        Err(err) => {
           // more specific logging/handling for backend misconfigurations
           unimplemented!()
        }
    }
}

Network services

Security

Compute

Quick start

Building blocks

Integrations

Tutorials

Demos

Use Cases

Code Examples

Starter Kits

Backend

Using Static Backends

Validating Support for Dynamic Backends

Methods

builder

exists

from_name

get_between_bytes_timeout

Panics

get_connect_timeout

Panics

get_first_byte_timeout

Panics

get_host

Panics

get_host_override

Panics

get_http_keepalive_time

Panics

get_port

Panics

get_ssl_max_version

Panics

get_ssl_min_version

Panics

get_tcp_keepalive_enable

Panics

get_tcp_keepalive_interval

Panics

get_tcp_keepalive_probes

Panics

get_tcp_keepalive_time

Panics

healthcheck_builder

into_string

is_dynamic

Panics

is_ssl

Panics

name

Trait implementations

impl BackendExt for Backend

is_healthy

impl Clone for Backend

clone

impl Debug for Backend

fmt

impl Display for Backend

fmt

impl FromStr for Backend

from_str

impl Hash for Backend

hash

impl Ord for Backend

cmp

impl PartialEq for Backend

eq

impl PartialOrd for Backend

partial_cmp

Auto trait implementations

Blanket implementations