令人惊讶的是：Cloudflare每天分析超过1000亿个请求，以理解超过20%的网络的声誉、模式和异常。

```toml type = "webpack" webpack_config = "webpack.config.js"

these will be used in production

vars = { WORKER_ENV = "production", SENTRY_ENABLED = true }

[env.local]

these will be used only when --env=local

vars = { WORKER_ENV = "local", SENTRY_ENABLED = false } ```

wrangler dev --env=local

```js // Auth Worker

export default { async fetch(request, env) { // Read x-custom-token header and make sure it matches SECRET_TOKEN if (request.headers.get('x-custom-token') === env.SECRET_TOKEN) { return new Response('Request allowed', { status: 200 }); } else { return new Response('x-custom-token does not match, request not allowed', { status: 403 }); } }, }; ```

```js // Gateway Worker

export default { async fetch(request, env) { // Fetch AUTH service and pass request const authResponse = await env.auth.fetch(request.clone());

// Return response from the AUTH service if the response status is not 200
// It would return 403 'x-custom-token does not match, request not allowed' response in such case
if (authResponse.status !== 200) {
  return authResponse;
}

// Request allowed
// You can write application logic here
// In this case we delegate the logic to an `application` Worker
return await env.application.fetch(request)

}, }; ```

js export default { async tail(events) { fetch("https://example.com/endpoint", { method: "POST", body: JSON.stringify(events), }) } }

bash curl --request PUT \ --url https://api.cloudflare.com/client/v4/accounts/account_identifier/workers/scripts/script_name/schedules \ --header 'Content-Type: application/json' \ --header 'X-Auth-Email: ' \ --data '[{'\''cron'\'': '\''*/30 * * * *'\''}]'

``` wrangler dev --test-scheduled

$ curl "http://localhost:8787/__scheduled?cron=++++*" ```

js export default { async scheduled(event, env, ctx) { ctx.waitUntil(doSomeTaskOnASchedule()); }, };

This is a good critique of Cloudflare CAPTCHAs. They are especially annoying when using a VPN (I use Mullvad) or unusual browser configurations. I wrote about how the Wayback Machine provides a good end-around the CAPTCHA deluge for pages which have been captured.

https://thenewleafjournal.com/using-web-archives-to-get-around-captchas/

js const headers = { 'Cache-Control': 'public, max-age=604800' }; const request = new Request('https://foobar.com/') const cacheResponse = new Response('bar',{ headers }) const cache = caches.default await cache.put(request, cacheResponse) const response = await cache.match(request);

🥳

```js import { connect } from 'cloudflare:sockets';

export default { async fetch(req: Request) { const gopherAddr = "gopher.floodgap.com:70"; const url = new URL(req.url);

try {
  const socket = connect(gopherAddr);

  const writer = socket.writable.getWriter()
  const encoder = new TextEncoder();
  const encoded = encoder.encode(url.pathname + "\r\n");
  await writer.write(encoded);

  return new Response(socket.readable, { headers: { "Content-Type": "text/plain" } });
} catch (error) {
  return new Response("Socket connection failed: " + error, { status: 500 });
}

} }; ts connect(address: SocketAddress | string, options?: SocketOptions): Socket

declare interface Socket { get readable(): ReadableStream; get writable(): WritableStream; get closed(): Promise<void>; close(): Promise<void>; startTls(): Socket; }

declare interface SocketOptions { secureTransport?: string; allowHalfOpen: boolean; }

declare interface SocketAddress { hostname: string; port: number; } ```

js function handleRequest(event: FetchEvent) { return new HTMLResponse(pageLayout('Hello World!', html` <h1>Hello World!</h1> ${async () => { const timeStamp = new Date( await fetch('https://time.api/now').then(r => r.text()) ); return html`<p>The current time is ${timeEl(timeStamp)}.</p>` }} `)); }

```js import type { EntryContext } from "@remix-run/cloudflare"; import { RemixServer } from "@remix-run/react"; import isbot from "isbot"; import { renderToReadableStream } from "react-dom/server";

const ABORT_DELAY = 5000;

const handleRequest = async ( request: Request, responseStatusCode: number, responseHeaders: Headers, remixContext: EntryContext ) => { let didError = false;

const stream = await renderToReadableStream( <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />, { onError: (error: unknown) => { didError = true; console.error(error);

    // You can also log crash/error report
  },
  signal: AbortSignal.timeout(ABORT_DELAY),
}

);

if (isbot(request.headers.get("user-agent"))) { await stream.allReady; }

responseHeaders.set("Content-Type", "text/html"); return new Response(stream, { headers: responseHeaders, status: didError ? 500 : responseStatusCode, }); };

export default handleRequest; ```