自动摘要
正在生成中……
Cloudflare Developer Documentation
Easily build and deploy full-stack applications everywhere,
thanks to integrated compute, storage, and networking.
[!TIP]
An archive of Markdown files is available at https://developers.cloudflare.com/markdown.zip
Agents
AI Gateway
AutoRAG
Browser Rendering
Cloudflare for Platforms
Constellation
D1
Developer Spotlight
Durable Objects
Email Routing
Hyperdrive
Cloudflare Images
-
Demos and architectures
-
Getting started
-
Images API Reference
-
Cloudflare Images: Streamline your image infrastructure with Cloudflare Images. Store, transform, and deliver images efficiently using Cloudflare's global network.
-
Pricing
-
Examples
-
Transcode images: Transcode an image from Workers AI before uploading to R2
-
Watermarks: Draw a watermark from KV on an image from R2
-
Apply blur
-
Browser TTL
-
Configure webhooks
-
Create variants
-
Delete images
-
Delete variants
-
Edit images
-
Enable flexible variants
-
Manage uploaded images
-
Export images
-
Changelog
-
Platform
-
Activate Polish
-
Cf-Polished statuses: Learn about Cf-Polished statuses in Cloudflare Images. Understand how to handle missing headers, optimize image formats, and troubleshoot common issues.
-
Polish compression: Learn about Cloudflare's Polish compression options, including Lossless, Lossy, and WebP, to optimize image file sizes while managing metadata effectively.
-
WebP may be skipped
-
Cloudflare Polish
-
Reference
-
Security
-
Troubleshooting
-
Tutorials
-
Transform user-uploaded images before uploading to R2: Set up bindings to connect Images, R2, and Assets to your Worker
-
Bind to Workers API
-
Control origin access
-
Draw overlays and watermarks
-
Integrate with frameworks
-
Transform images
-
Make responsive images: Learn how to serve responsive images using HTML srcset and width=auto for optimal display on various devices. Ideal for high-DPI and fluid layouts.
-
Serve images from custom paths
-
Define source origin
-
Preserve Content Credentials
-
Transform via URL
-
Transform via Workers
-
Accept user-uploaded images
-
Upload via batch API
-
Upload images
-
Upload via URL
-
Upload via custom path
-
Upload via dashboard
-
Upload via a Worker: Learn how to upload images to Cloudflare using Workers. This guide provides code examples for uploading both standard and AI-generated images efficiently.
-
Serve images
-
Serve images from custom domains
-
Serve private images
-
Credentials
-
Serve uploaded images
-
Edit sources
-
Enable Sourcing Kit
-
Upload via Sourcing Kit
KV
Pages
Pipelines
Privacy Gateway
Pub/Sub
Queues
R2
Realtime
Stream
Vectorize
Workers AI
Workflows
Workers
-
AI Assistant
-
Demos and architectures
-
Glossary
-
Cloudflare Workers
-
Playground
-
CI/CD: Set up continuous integration and continuous deployment for your Workers.
-
Analytics Engine: Use Workers to receive performance analytics about your applications, products and projects.
-
Connect to databases: Learn about the different kinds of database integrations Cloudflare supports.
-
Cloudflare D1: Cloudflare’s native serverless database.
-
Hyperdrive: Use Workers to accelerate queries you make to existing databases.
-
Vectorize (vector database): A globally distributed vector database that enables you to build full-stack, AI-powered applications with Cloudflare Workers.
-
Databases
-
Compatibility dates: Opt into a specific version of the Workers runtime for your Workers project.
-
Bindings: The various bindings that are available to Cloudflare Workers.
-
Compatibility flags: Opt into a specific features of the Workers runtime for your Workers project.
-
Cron Triggers: Enable your Worker to be executed on a schedule.
-
Environment variables: You can add environment variables, which are a type of binding, to attach text strings or JSON values to your Worker.
-
Configuration
-
Multipart upload metadata
-
Secrets: Store sensitive information, like API keys and auth tokens, in your Worker.
-
Preview URLs: Preview URLs allow you to preview new versions of your project without deploying it to production.
-
Smart Placement: Speed up your Worker application by automatically placing your workloads in an optimal location that minimizes latency.
-
Page Rules: Review the interaction between various Page Rules and Workers.
-
Supported bindings per development mode: Supported bindings per development mode
-
Environment variables and secrets: Configuring environment variables and secrets for local development
-
Development & testing: Develop and test your Workers locally.
-
Adding local data: Populating local resources with data
-
Testing
-
Vite Plugin
-
Choosing between Wrangler & Vite: Choosing between Wrangler and Vite for local development
-
Dashboard
-
CLI
-
Getting started
-
Prompting
-
Templates: GitHub repositories that are designed to be a starting point for building a new Cloudflare Workers project.
-
Framework guides: Create full-stack applications deployed to Cloudflare Workers.
-
103 Early Hints: Allow a client to request static assets while waiting for the HTML response.
-
A/B testing with same-URL direct access: Set up an A/B test by controlling what response is served based on cookies. This version supports passing the request through to test and control on the origin, bypassing random assignment.
-
Accessing the Cloudflare Object: Access custom Cloudflare properties and control how Cloudflare features are applied to every request.
-
Aggregate requests: Send two GET request to two urls and aggregates the responses into one response.
-
Alter headers: Example of how to add, change, or delete headers sent in a request or returned in a response.
-
Auth with headers: Allow or deny a request based on a known pre-shared key in a header. This is not meant to replace the WebCrypto API.
-
HTTP Basic Authentication: Shows how to restrict access using the HTTP Basic schema.
-
Block on TLS: Inspects the incoming request's TLS version and blocks if under TLSv1.2.
-
Bulk origin override: Resolve requests to your domain to a set of proxy third-party origin URLs.
-
Bulk redirects: Redirect requests to certain URLs based on a mapped object to the request's URL.
-
Using the Cache API: Use the Cache API to store responses in Cloudflare's cache.
-
Cache POST requests: Cache POST requests using the Cache API.
-
Cache Tags using Workers: Send Additional Cache Tags using Workers
-
Conditional response: Return a response based on the incoming request's URL, HTTP method, User Agent, IP address, ASN or device type.
-
CORS header proxy: Add the necessary CORS headers to a third party API response.
-
Cache using fetch: Determine how to cache a resource by setting TTLs, custom cache keys, and cache headers in a fetch request.
-
Country code redirect: Redirect a response based on the country code in the header of a visitor.
-
Setting Cron Triggers: Set a Cron Trigger for your Worker.
-
Data loss prevention: Protect sensitive data to prevent data loss, and send alerts to a webhooks server in the event of a data breach.
-
Debugging logs: Send debugging information in an errored response to a logging service.
-
Cookie parsing: Given the cookie name, get the value of a cookie. You can also use cookies for A/B testing.
-
Fetch HTML: Send a request to a remote server, read HTML from the response, and serve that HTML.
-
Fetch JSON: Send a GET request and read in JSON from the response. Use to fetch external data.
-
Geolocation: Weather application: Fetch weather data from an API using the user's geolocation data.
-
Geolocation: Custom Styling: Personalize website styling based on localized user time.
-
Geolocation: Hello World: Get all geolocation data fields and display them in HTML.
-
Hot-link protection: Block other websites from linking to your content. This is useful for protecting images.
-
Custom Domain with Images: Set up custom domain for Images using a Worker or serve images using a prefix path and Cloudflare registered domain.
-
Examples
-
Logging headers to console: Examine the contents of a Headers object by logging to console with a Map.
-
Modify request property: Create a modified request with edited properties based off of an incoming request.
-
Modify response: Fetch and modify response properties which are immutable by creating a copy first.
-
Multiple Cron Triggers: Set multiple Cron Triggers on three different schedules.
-
Using timingSafeEqual: Protect against timing attacks by safely comparing values using
timingSafeEqual.
-
Stream OpenAI API Responses: Use the OpenAI v4 SDK to stream responses from OpenAI.
-
Post JSON: Send a POST request with JSON data. Use to share data with external servers.
-
Read POST: Serve an HTML form, then read POST requests. Use also to read JSON or POST data from an incoming request.
-
Redirect: Redirect requests from one URL to another or from one set of URLs to another set.
-
Respond with another site: Respond to the Worker request with the response from another website (example.com in this example).
-
Return small HTML page: Deliver an HTML page from an HTML string directly inside the Worker script.
-
Return JSON: Return JSON directly from a Worker script, useful for building APIs and middleware.
-
Rewrite links: Rewrite URL links in HTML using the HTMLRewriter. This is useful for JAMstack websites.
-
Set security headers: Set common security headers (X-XSS-Protection, X-Frame-Options, X-Content-Type-Options, Permissions-Policy, Referrer-Policy, Strict-Transport-Security, Content-Security-Policy).
-
Sign requests: Verify a signed request using the HMAC and SHA-256 algorithms or return a 403.
-
Turnstile with Workers: Inject Turnstile implicitly into HTML elements using the HTMLRewriter runtime API.
-
Using the WebSockets API: Use the WebSockets API to communicate in real time with your Cloudflare Workers.
-
Errors and exceptions: Review Workers errors and exceptions.
-
Languages: Languages supported on Workers, a polyglot platform.
-
Observability
-
Metrics and analytics: Diagnose issues with Workers metrics, and review request data for a zone with Workers analytics.
-
Query Builder: Write structured queries to investigate and visualize your telemetry data.
-
Source maps and stack traces: Adding source maps and generating stack traces for Workers.
-
How the Cache works: How Workers interacts with the Cloudflare cache.
-
Reference
-
How Workers works: The difference between the Workers runtime versus traditional browsers and Node.js.
-
Migrate from Service Workers to ES Modules: Write your Worker code in ES modules syntax for an optimized experience.
-
Protocols: Supported protocols on the Workers platform.
-
Security model
-
Betas: Cloudflare developer platform and Workers features beta status.
-
Deploy to Cloudflare buttons: Set up a Deploy to Cloudflare button
-
Platform
-
Infrastructure as Code (IaC)
-
Known issues: Known issues and bugs to be aware of when using Workers.
-
Limits: Cloudflare Workers plan and platform limits.
-
Pricing: Workers plans and pricing information.
-
Choose a data or storage product: Storage and database options available on Cloudflare's developer platform.
-
Workers for Platforms: Deploy custom code on behalf of your users or let your users directly deploy their own code to your platform, managing infrastructure.
-
Testing
-
Wrangler's unstable_startWorker(): Write integration tests using Wrangler's
unstable_startWorker() API
-
Billing and Limitations: Billing, troubleshooting, and limitations for Static assets on Workers
-
Configuration and Bindings: Details on how to configure Workers static assets and its binding.
-
Direct Uploads: Upload assets through the Workers API.
-
Get Started: Run front-end websites — static or dynamic — directly on Cloudflare's global network.
-
Headers
-
Static Assets: Create full-stack applications deployed to Cloudflare Workers.
-
Redirects
-
Console: Supported methods of the
console API in Cloudflare Workers
-
Context (ctx): The Context API in Cloudflare Workers, including waitUntil and passThroughOnException.
-
Cache: Control reading and writing from the Cloudflare global network cache.
-
Encoding: Takes a stream of code points as input and emits a stream of bytes.
-
EventSource: EventSource is a server-sent event API that allows a server to push events to a client.
-
Headers: Access HTTP request and response headers.
-
Fetch: An interface for asynchronously fetching resources via HTTP requests inside of a Worker.
-
HTMLRewriter: Build comprehensive and expressive HTML parsers inside of a Worker application.
-
Runtime APIs
-
Performance and timers: Measure timing, performance, and timing of subrequests and other operations.
-
Request: Interface that represents an HTTP request.
-
Response: Interface that represents an HTTP response.
-
TCP sockets: Use the
connect() API to create outbound TCP connections from Workers.
-
Web Crypto: A set of low-level functions for common cryptographic tasks.
-
Web standards: Standardized APIs for use by Workers running on Cloudflare's global network.
-
WebSockets: Communicate in real time with your Cloudflare Workers.
-
Get started: Get started with the Vite plugin
-
Vite plugin: A full-featured integration between Vite and the Workers runtime
-
Tutorial - React SPA with an API: Create a React SPA with an API Worker using the Vite plugin
-
Tutorials
-
API: A set of programmatic APIs that can be integrated with local Cloudflare Workers-related workflows.
-
Bundling: Review Wrangler's default bundling.
-
Commands: Create, develop, and deploy your Cloudflare Workers with Wrangler commands.
-
Configuration: Use a configuration file to customize the development and deployment setup for your Worker project and other Developer Platform products.
-
Custom builds: Customize how your code is compiled, before being processed by Wrangler.
-
Deprecations: The differences between Wrangler versions, specifically deprecations and breaking changes.
-
Environments: Use environments to create different configurations for the same Worker application.
-
Install/Update Wrangler: Get started by installing Wrangler, and update to newer versions by following this guide.
-
Wrangler
-
System environment variables: Local environment variables that can change Wrangler's behavior.
-
Advanced setups: Learn how to use Workers Builds with more advanced setups
-
Build branches: Configure which git branches should trigger a Workers Build
-
Build caching: Improve build times by caching build outputs and dependencies
-
Build image: Understand the build image used in Workers Builds.
-
Build watch paths: Reduce compute for your monorepo by specifying paths for Workers Builds to skip
-
Configuration: Understand the different settings associated with your build.
-
Builds: Use Workers Builds to integrate with Git and automatically build and deploy your Worker when pushing a change
-
Limits & pricing: Limits & pricing for Workers Builds
-
Troubleshooting builds: Learn how to troubleshoot common and known issues in Workers Builds.
-
GitHub Actions: Integrate Workers development into your existing GitHub Actions workflows.
-
GitLab CI/CD: Integrate Workers development into your existing GitLab Pipelines workflows.
-
External CI/CD: Integrate Workers development into your existing continuous integration and continuous development workflows, such as GitHub Actions or GitLab Pipelines.
-
3rd Party Integrations: Connect to third-party databases such as Supabase, Turso and PlanetScale)
-
Neon
-
PlanetScale
-
Supabase
-
Turso
-
APIs
-
Upstash
-
Xata
-
External Services
-
Integrations: Integrate with third-party services and products.
-
Momento
-
Custom Domains
-
Routes and domains: Connect your Worker to an external endpoint (via Routes, Custom Domains or a
workers.dev subdomain) such that it can be accessed by the Internet.
-
Routes
-
workers.dev
-
Workers Sites: Use Workers Static Assets to host full-stack applications instead of Workers Sites. Do not use Workers Sites for new projects.
-
Workers Sites configuration
-
Start from existing
-
Start from scratch
-
Start from Worker
-
Gradual deployments: Incrementally deploy code changes to your Workers with gradual deployments.
-
Versions & Deployments: Upload versions of Workers and create deployments to release new versions.
-
Rollbacks: Revert to an older version of your Worker.
-
Agents SDK
-
AI & agents
-
LangChain
-
Mobile applications
-
Expo
-
FastAPI
-
Hono
-
APIs
-
Examples
-
JavaScript
-
Astro: Create an Astro application and deploy it to Cloudflare Workers with Workers Assets.
-
Web applications
-
React Router (formerly Remix): Create a React Router application and deploy it to Cloudflare Workers
-
Next.js: Create an Next.js application and deploy it to Cloudflare Workers with Workers Assets.
-
React + Vite: Create a React application and deploy it to Cloudflare Workers with Workers Assets.
-
RedwoodSDK: Create an RedwoodSDK application and deploy it to Cloudflare Workers with Workers Assets.
-
Svelte: Create a Svelte application and deploy it to Cloudflare Workers with Workers Assets.
-
TanStack: Create a TanStack Router application and deploy it to Cloudflare Workers with Workers Assets.
-
Vue: Create a Vue application and deploy it to Cloudflare Workers with Workers Assets.
-
Examples
-
How Python Workers Work
-
Foreign Function Interface (FFI)
-
Python: Write Workers in 100% Python
-
Standard Library
-
Supported crates
-
Rust: Write Workers in 100% Rust using the
workers-rs crate
-
Examples
-
TypeScript
-
Breakpoints: Debug your local and deployed Workers using breakpoints.
-
Profiling CPU usage: Learn how to profile CPU usage and ensure CPU-time per request stays under Workers limits
-
DevTools
-
Profiling Memory
-
Integrations
-
Sentry: Connect to a Sentry project from your Worker to automatically send errors and uncaught exceptions to Sentry.
-
Logs
-
Workers Logpush: Send Workers Trace Event Logs to a supported third party, such as a storage or logging provider.
-
Real-time logs: Debug your Worker application by accessing logs and exceptions through the Cloudflare dashboard or
wrangler tail.
-
Tail Workers: Track and log Workers on invocation by assigning a Tail Worker to your projects.
-
Workers Logs: Store, filter, and analyze log data emitted from Cloudflare Workers.
-
Workers (Historic): Review pre-2023 changes to Cloudflare Workers.
-
Changelog: Review recent changes to Cloudflare Workers.
-
Changelog: Review recent changes to the Cloudflare Developer Platform.
-
Wrangler
-
Get Started
-
Miniflare
-
Writing tests: Write integration tests against Workers using Miniflare.
-
Migration Guides: Learn how to migrate your applications to Cloudflare Workers.
-
Migrate from Pages to Workers: A guide for migrating from Cloudflare Pages to Cloudflare Workers. Includes a compatibility matrix for comparing the features of Cloudflare Workers and Pages.
-
Migrate from Netlify to Workers
-
Migrate from Vercel to Workers
-
Configuration: Vitest configuration specific to the Workers integration.
-
Debugging: Debug your Workers tests with Vitest.
-
Isolation and concurrency: Review how the Workers Vitest integration runs your tests, how it isolates tests from each other, and how it imports modules.
-
Vitest integration
-
Known issues: Explore the known issues associated with the Workers Vitest integration.
-
Recipes and examples: Examples that demonstrate how to write unit and integration tests with the Workers Vitest integration.
-
Test APIs: Runtime helpers for writing tests, exported from the
cloudflare:test module.
-
Write your first test: Write tests against Workers using Vitest
-
Full-stack application: How to configure and use a full-stack application with Workers.
-
Routing
-
Single Page Application (SPA): How to configure and use a Single Page Application (SPA) with Workers.
-
Static Site Generation (SSG) and custom 404 pages: How to configure a Static Site Generation (SSG) application and custom 404 pages with Workers.
-
Worker script: How the presence of a Worker script influences static asset routing and the related configuration options.
-
R2: APIs available in Cloudflare Workers to read from and write to R2 buckets. R2 is S3-compatible, zero egress-fee, globally distributed object storage.
-
D1: APIs available in Cloudflare Workers to interact with D1. D1 is Cloudflare's native serverless database.
-
AI: Run generative AI inference and machine learning models on GPUs, without managing servers or infrastructure.
-
Analytics Engine: Write high-cardinality data and metrics at scale, directly from Workers.
-
Assets: APIs available in Cloudflare Workers to interact with a collection of static assets. Static assets can be uploaded as part of your Worker.
-
Browser Rendering: Programmatically control and interact with a headless browser instance.
-
Dispatcher (Workers for Platforms): Let your customers deploy their own code to your platform, and dynamically dispatch requests from your Worker to their Worker.
-
Durable Objects: A globally distributed coordination API with strongly consistent storage.
-
Environment Variables: Add string and JSON values to your Worker.
-
Hyperdrive: Connect to your existing database from Workers, turning your existing regional database into a globally distributed database.
-
Images: Store, transform, optimize, and deliver images at scale.
-
Bindings (env): Worker Bindings that allow for interaction with other Cloudflare Resources.
-
KV: Global, low-latency, key-value data storage.
-
mTLS: Configure your Worker to present a client certificate to services that enforce an mTLS connection.
-
Queues: Send and receive messages with guaranteed delivery.
-
Rate Limiting: Define rate limits and interact with them directly from your Cloudflare Worker
-
Secrets Store: Account-level secrets that can be added to Workers applications as a binding.
-
Secrets: Add encrypted secrets to your Worker.
-
Tail Workers: Receive and transform logs, exceptions, and other metadata. Then forward them to observability tools for alerting, debugging, and analytics purposes.
-
Vectorize: APIs available in Cloudflare Workers to interact with Vectorize. Vectorize is Cloudflare's globally distributed vector database.
-
Version metadata: Exposes Worker version metadata (
versionID and versionTag). These fields can be added to events emitted from the Worker to send to downstream observability systems.
-
Workflows: APIs available in Cloudflare Workers to interact with Workflows. Workflows allow you to build durable, multi-step applications using Workers.
-
Alarm Handler
-
Email Handler
-
Fetch Handler
-
Handlers: Methods, such as
fetch(), on Workers that can receive and process external inputs.
-
Queue Handler
-
Scheduled Handler
-
Tail Handler
-
Error handling: How exceptions, stack traces, and logging works with the Workers RPC system.
-
Remote-procedure call (RPC): The built-in, JavaScript-native RPC system built into Workers and Durable Objects.
-
Lifecycle: Memory management, resource management, and the lifecycle of RPC stubs.
-
Reserved Methods: Reserved methods with special behavior that are treated differently.
-
TypeScript: How TypeScript types for your Worker or Durable Object's RPC methods are generated and exposed to clients
-
Visibility and Security Model: Which properties are and are not exposed to clients that communicate with your Worker or Durable Object via RPC
-
EventEmitter
-
assert
-
AsyncLocalStorage
-
Buffer
-
crypto
-
Diagnostics Channel
-
dns
-
Node.js compatibility: Node.js APIs available in Cloudflare Workers
-
net
-
path
-
process
-
Streams
-
StringDecoder
-
test
-
timers
-
tls
-
url
-
util
-
zlib
-
Streams: A web standard API that allows JavaScript to programmatically access and process streams of data.
-
ReadableStream
-
ReadableStream BYOBReader
-
ReadableStream DefaultReader
-
TransformStream
-
WritableStream
-
WritableStream DefaultWriter
-
WebAssembly (Wasm): Execute code written in a language other than JavaScript or write an entire Cloudflare Worker in Rust.
-
Wasm in JavaScript
-
Automate analytics reporting with Cloudflare Workers and email routing
-
API: Vite plugin API
-
Cloudflare Environments: Using Cloudflare environments with the Vite plugin
-
Debugging: Debugging with the Vite plugin
-
Reference
-
Migrating from wrangler dev: Migrating from wrangler dev to the Vite plugin
-
Secrets: Using secrets with the Vite plugin
-
Static Assets: Static assets and the Vite plugin
-
Vite Environments: Vite environments and the Vite plugin
-
Build a todo list Jamstack application
-
Build a QR code generator
-
Build a Slackbot
-
Connect to and query your Turso database using Workers
-
Deploy a real-time chat application
-
Create a fine-tuned OpenAI model with R2
-
Generate YouTube thumbnails with Workers and Cloudflare Image Resizing
-
GitHub SMS notifications using Twilio
-
Handle form submissions with Airtable
-
Build Live Cursors with Next.js, RPC and Durable Objects
-
Connect to a MySQL database with Cloudflare Workers
-
Connect to a PostgreSQL database with Cloudflare Workers
-
OpenAI GPT function calling with JavaScript and Cloudflare Workers
-
Send Emails With Postmark
-
Send Emails With Resend
-
Securely access and upload assets with Cloudflare R2
-
Use Workers KV directly from Rust
-
Migrations: Review migration guides for specific versions of Wrangler.
-
Set up and use a Prisma Postgres database
-
Migrate from Wrangler v2 to v3
-
Migrate from Wrangler v3 to v4
-
GitHub integration: Learn how to manage your GitHub integration for Workers Builds
-
GitLab integration: Learn how to manage your GitLab integration for Workers Builds
-
Git integration: Learn how to add and manage your Git integration for Workers Builds
-
Angular: Create an Angular application and deploy it to Cloudflare Workers with Workers Assets.
-
Docusaurus: Create a Docusaurus application and deploy it to Cloudflare Workers with Workers Assets.
-
Gatsby: Create a Gatsby application and deploy it to Cloudflare Workers with Workers Assets.
-
Hono: Create a Hono application and deploy it to Cloudflare Workers with Workers Assets.
-
More guides...
-
Nuxt: Create a Nuxt application and deploy it to Cloudflare Workers with Workers Assets.
-
Qwik: Create a Qwik application and deploy it to Cloudflare Workers with Workers Assets.
-
Solid: Create a Solid application and deploy it to Cloudflare Workers with Workers Assets.
-
FastAPI
-
Packages
-
Langchain
-
Developing
-
📅 Compatibility Dates
-
📨 Fetch Events
-
🛠Attaching a Debugger
-
âš¡ï¸ Live Reload
-
Core
-
📚 Modules
-
🕸 Web Standards
-
🔌 Multiple Workers
-
🚥 Queues
-
â° Scheduled Events
-
âœ‰ï¸ WebSockets
-
🔑 Variables and Secrets
-
â¬†ï¸ Migrating from Version 2
-
Migrations: Review migration guides for specific versions of Miniflare.
-
✨ Cache
-
💾 D1
-
Storage
-
📦 KV
-
🪣 R2
-
📌 Durable Objects
-
Migration guides: Migrate to using the Workers Vitest integration.
-
Migrate from Miniflare 2's test environments: Migrate from Miniflare 2 to the Workers Vitest integration.
-
Migrate from unstable_dev: Migrate from the
unstable_dev API to writing tests with the Workers Vitest integration.
-
HTML handling: How to configure a HTML handling and trailing slashes for the static assets of your Worker.
-
Advanced
-
Serving a subdirectory: How to configure a Worker with static assets on a subpath.
-
HTTP: Facilitate Worker-to-Worker communication by forwarding Request objects.
-
Service bindings: Facilitate Worker-to-Worker communication.
-
RPC (WorkerEntrypoint): Facilitate Worker-to-Worker communication via RPC.
-
1. Migrate webpack projects
-
Migrate from Wrangler v1 to v2
-
2. Update to Wrangler v2
-
Authentication
-
Commands
-
Wrangler v1 (legacy)
-
Install / Update
-
Configuration: Learn how to configure your Cloudflare Worker using Wrangler v1. This guide covers top-level and environment-specific settings, key types, and deployment options.
-
Webpack: Learn how to migrate from Wrangler v1 to v2 using webpack. This guide covers configuration, custom builds, and compatibility for Cloudflare Workers.
Zaraz
Workers Analytics Engine
R2 Data Catalog