Fastly

Overview

Fastly operates as an edge cloud platform, integrating a content delivery network (CDN) with edge computing capabilities. Its architecture is designed to reduce latency by bringing content and application logic closer to end-users at the network's edge. This approach is beneficial for applications that require fast response times, such as real-time streaming, e-commerce, and API services. Fastly's CDN is built on a network of Points of Presence (PoPs) globally, designed to cache and serve content efficiently. The platform emphasizes real-time control, allowing users to make configuration changes that propagate across the network within seconds.

Fastly's edge computing offering, Compute@Edge, allows developers to deploy serverless functions directly at the edge of the network. This enables custom logic to be executed closer to the user, potentially reducing origin server load and improving application performance. Supported languages for Compute@Edge include Rust, AssemblyScript, Go, and JavaScript, providing flexibility for developers to build and deploy custom code. This capability extends beyond traditional content caching, enabling use cases like dynamic content generation, API gateway logic, and data transformation at the edge.

In addition to performance and programmability, Fastly provides a suite of security products. These include a Next-Generation Web Application Firewall (WAF), Bot Management, and DDoS Mitigation services. The WAF is designed to protect against common web vulnerabilities, while Bot Management helps identify and mitigate malicious bot traffic. DDoS Mitigation works to absorb and filter out distributed denial-of-service attacks, maintaining service availability. Fastly's focus on these areas aims to provide a comprehensive platform for deploying and securing online applications at scale. For organizations evaluating CDN providers, factors beyond raw throughput, such as cache programmability and edge logic capabilities, often influence selection, as discussed in cloud service comparisons like Cloudflare's CDN explanation.

The platform's developer experience is noted for its powerful API, which allows for programmatic control over configuration and integration into CI/CD pipelines. While the Varnish Configuration Language (VCL) used for configuring Fastly's CDN can present a learning curve, it offers a high degree of control over caching behavior and request routing. This level of granular control is often sought by developers building complex, high-performance web applications and APIs. Fastly's services are utilized across various industries, from media and entertainment to financial services, where performance, security, and real-time operations are critical requirements.

Key features

• Content Delivery Network (CDN): Global network for high-performance content caching and delivery, designed for real-time invalidation and configuration changes.
• Compute@Edge: Serverless computing platform allowing execution of custom code in languages like Rust, Go, JavaScript, and AssemblyScript directly at the network edge.
• Image Optimizer: Automates image manipulation, compression, and delivery from the edge, adapting images for different devices and network conditions.
• Load Balancer: Distributes incoming network traffic across multiple origin servers, enhancing availability and performance of applications.
• Next-Gen WAF: Web Application Firewall providing protection against common web vulnerabilities and threats, configurable at the edge.
• Bot Management: Identifies and mitigates malicious bot traffic, protecting applications from automated attacks and abuse.
• DDoS Mitigation: Defends against Distributed Denial of Service attacks by absorbing and filtering malicious traffic to maintain service continuity.
• Observability: Provides real-time and historical logging, metrics, and analytics to monitor performance and troubleshoot issues across the platform.
• API and Developer Tools: Comprehensive API for programmatic control and integration with CI/CD workflows, supporting automation of configuration and deployment.

Pricing

Fastly's pricing model is primarily usage-based, with costs determined by bandwidth consumption, request volume, and the use of specific add-on features. The platform offers a starting credit for new users. Custom enterprise pricing is available for higher volume or specific contractual needs. As of June 2026, details are available on the Fastly pricing page.

Common integrations

• Terraform: Infrastructure as Code for managing Fastly configurations. The Fastly Terraform provider allows declarative provisioning.
• Datadog: For real-time monitoring and alerting on Fastly performance and usage metrics. Fastly offers integration guides for Datadog.
• New Relic: Observability platform for performance monitoring and analytics. Can integrate with Fastly's logging for deeper insights.
• Splunk: For centralized log management and security information and event management (SIEM). Fastly supports sending logs to Splunk via various methods.
• AWS S3: Common origin for static content or as a log storage destination. Fastly CDN can be configured to pull content from S3 buckets.
• Google Cloud Storage: Similar to S3, used as an origin or log storage. Fastly provides options for Google Cloud Storage logging.

Alternatives

• Cloudflare: Offers a wide range of CDN, security, and edge services, including WAF, DDoS protection, and serverless functions (Workers).
• Akamai: Provides enterprise-grade CDN, security, and edge computing solutions with a focus on large-scale content delivery and web performance.
• Amazon CloudFront: AWS's native CDN service, tightly integrated with other AWS services like S3 and EC2, supporting global content delivery.
• Netlify: Primarily focused on static site hosting and JAMstack architecture, including serverless functions and a global CDN.
• Vercel: A platform for frontend developers, offering CDN, serverless functions, and Git integration for deploying web applications.

Getting started

To begin using Fastly's Compute@Edge, you can deploy a simple "Hello, World!" application using Rust. This example demonstrates creating a basic HTTP handler that responds with a greeting. First, ensure you have the Fastly CLI installed and configured. You'll also need Rust and wasm-pack.

// main.rs
use fastly::http::{Request, Response};
use fastly::{Error, handle_request};

#[handle_request]
fn main(mut req: Request) -> Result<Response, Error> {
    // Log the request method and URL to stdout.
    // In production, consider logging to a remote endpoint.
    println!("Request: {} {}", req.method(), req.uri().path());

    // Send a greeting to the client.
    Ok(Response::builder()
        .status(200)
        .body("Hello from Fastly's Compute@Edge!")?)
}

To deploy this application:

1. Initialize a new Fastly Compute@Edge project:
   fastly compute init
   Follow the prompts, selecting Rust as your language. This will create a project structure including fastly.toml and src/main.rs.
2. Replace src/main.rs with the code above.
3. Build your project:
   fastly compute build
   This compiles your Rust code into WebAssembly.
4. Deploy your service:
   fastly compute deploy
   This command uploads your WebAssembly module to Fastly's edge network and activates a new service version. It will provide you with a service URL.
5. Test your deployment:
   curl <YOUR_SERVICE_URL>
   You should receive the "Hello from Fastly's Compute@Edge!" response.

For more detailed instructions and advanced configurations, refer to the Fastly Compute@Edge Rust documentation.