Fastly

Overview

Fastly operates an edge cloud platform that combines Content Delivery Network (CDN) services with serverless compute and security features. Established in 2011, Fastly differentiates itself by offering developers fine-grained control over content delivery and edge logic through its Varnish Configuration Language (VCL) and its Compute@Edge platform. The platform is designed for applications that require high performance and low latency, such as media streaming, e-commerce, and real-time data processing. By deploying logic and content closer to the end-user, Fastly aims to reduce network latency and improve application responsiveness.

Fastly's core offering includes a CDN that uses a global network of Points of Presence (PoPs) to cache and deliver content. This network is optimized for dynamic content and API acceleration, alongside static asset delivery. A key component of Fastly's edge capabilities is Compute@Edge, which allows developers to deploy custom application logic written in languages like Rust, Go, or JavaScript compiled to WebAssembly (Wasm). This enables advanced use cases such as personalized content delivery, A/B testing at the edge, and API gateway functionality without originating requests to a central server.

For security, Fastly provides a Web Application Firewall (WAF), DDoS protection, and bot mitigation services that operate at the edge. These security features are designed to protect applications from common web vulnerabilities and malicious traffic before it reaches origin infrastructure. Real-time observability and logging are integrated across the platform, offering immediate insights into traffic patterns, cache performance, and security events. This combination of content delivery, programmable edge compute, and security makes Fastly suitable for organizations seeking to optimize the performance, scalability, and security of their web and mobile applications.

Fastly's approach contrasts with some traditional CDNs by emphasizing developer control and real-time configuration. For instance, Cloudflare also offers edge compute capabilities, but its Workers platform utilizes JavaScript, whereas Fastly's Compute@Edge supports multiple languages compiled to WebAssembly, providing broader language choice for developers, as detailed on the WebAssembly overview on web.dev. This flexibility can be beneficial for teams already proficient in languages like Rust or Go, allowing them to extend their existing skill sets to the edge environment.

Key features

• Content Delivery Network (CDN): Global network for caching and delivering static and dynamic content, reducing latency and origin load.
• Edge Compute (Compute@Edge): Serverless platform for executing custom logic at the edge using WebAssembly, supporting languages like Rust, Go, and JavaScript.
• Image Optimization: On-the-fly image manipulation and optimization to deliver appropriately sized and formatted images to various devices.
• Load Balancing: Distributes incoming traffic across multiple origin servers, enhancing reliability and performance.
• Web Application Firewall (WAF): Protects web applications from common attacks such as SQL injection, cross-site scripting, and other OWASP Top 10 vulnerabilities.
• Bot Protection: Identifies and mitigates malicious bot traffic while allowing legitimate bots to access resources.
• DDoS Protection: Defends against Distributed Denial of Service attacks at the network edge to maintain application availability.
• Real-time Observability: Provides instant visibility into traffic, performance metrics, and security events through customizable dashboards and logging.
• Varnish Configuration Language (VCL): Allows fine-grained control over caching, routing, and request/response manipulation at the edge.

Pricing

Fastly offers usage-based pricing, primarily billed on egress bandwidth and requests. A base monthly charge applies, with initial usage covered. Enterprise pricing is available for high-volume customers requiring custom agreements.

Detailed pricing and a usage calculator are available on the Fastly pricing page.

Common integrations

• Logging Endpoints: Integrates with various logging providers such as Splunk, Datadog, Sumo Logic, and Amazon S3 for real-time log streaming from the edge. Refer to the Fastly streaming logs guide.
• Cloud Providers: Can be deployed in front of origin servers hosted on AWS, Google Cloud, Azure, and other cloud infrastructure.
• CI/CD Pipelines: Integrates with CI/CD tools like GitHub Actions or GitLab CI for automated deployments of VCL configurations and Compute@Edge services using the Fastly API.
• Observability Tools: Exports metrics to monitoring and analytics platforms for comprehensive performance analysis.
• Image Management Systems: Works with various content management systems and digital asset management platforms by providing image optimization at the edge.

Alternatives

• Cloudflare: Offers CDN, WAF, DDoS protection, and an edge computing platform (Workers) with a large global network.
• Akamai: A large, established CDN and cybersecurity provider offering a broad suite of edge services for performance and security.
• Amazon CloudFront: Amazon's scalable CDN service integrated with other AWS services, offering edge delivery and lambda@edge for custom logic.

Getting started

To get started with Fastly's Compute@Edge using Rust, you would typically use the Fastly CLI to create a new project. This example demonstrates a basic Rust program that responds with a "Hello, Fastly!" message.

// main.rs
use fastly::Response;
use fastly::Request;

#[fastly::main]
fn main(req: Request) -> Result<Response, fastly::Error> {
    // Log details about the incoming request.
    println!("Host: {:?}", req.get_header_str("Host"));
    println!("User-Agent: {:?}", req.get_header_str("User-Agent"));

    // Construct a simple response.
    Ok(Response::from_bytes(b"Hello, Fastly!")
        .with_status(200)
        .with_header("Content-Type", "text/plain"))
}

To compile and deploy this, you would use the Fastly CLI:

1. Install the Fastly CLI: Follow the instructions on the Fastly CLI documentation.
2. Log in to Fastly: fastly configure
3. Create a new project: fastly compute init --language=rust (follow prompts)
4. Replace src/main.rs with the code above.
5. Deploy your service: fastly compute publish

This will compile your Rust code to WebAssembly and deploy it to the Fastly edge network, making it accessible via your Fastly service domain.