← Cloudflare Pages / pages / functions

Bindings

A binding umožňuje vašim Pages Functions pracovat s prostředky na Cloudflare developer platform. Pomocí bindings propojíte své Pages Functions s prostředky Cloudflare, jako je KV, Durable Objects, R2, a D1. Vazby můžete nastavit jak pro produkční, tak pro náhledové prostředí.

Tento průvodce vás naučí, jak nakonfigurovat binding pro vaši Pages Function. Než budete pokračovat, musíte mít již nastavený prostředek Cloudflare Developer Platform.

Workers KV je řešení Cloudflare pro úložiště typu klíč-hodnota.

Chcete-li svázat obor názvů KV s funkcí Pages Function, můžete nakonfigurovat vazbu oboru názvů KV v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu oboru názvů KV přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > KV namespace.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části KV namespace, vyberte požadovaný namespace.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití KV ve vaší Function. V následujícím příkladu se binding KV namespace nazývá TODO_LIST a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequest(context) {
	const task = await context.env.TODO_LIST.get("Task:123");
	return new Response(task);
}

interface Env {
	TODO_LIST: KVNamespace;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	const task = await context.env.TODO_LIST.get("Task:123");
	return new Response(task);
};

S vazbami jmenného prostoru KV můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li lokálně pracovat s vazbou oboru názvů KV předáváním argumentů do Wrangler CLI, přidejte -k <BINDING_NAME> nebo --kv=<BINDING_NAME> do wrangler pages dev příkaz. Pokud je například váš KV namespace navázán na vaši Function prostřednictvím TODO_LIST binding přistoupíte k KV namespace v lokálním vývoji spuštěním:

npx wrangler pages dev <OUTPUT_DIR> --kv=TODO_LIST

Durable Objects (DO) jsou silně konzistentní datové úložiště Cloudflare, které pohání funkce jako připojování WebSocketů nebo správu stavu.

Musíte vytvořit Worker s Durable Object a propojit jej se svým projektem Pages pomocí dashboardu Cloudflare nebo Konfigurační soubor Wrangler. V rámci projektu Pages nelze vytvořit a nasadit Durable Object.

Chcete-li svázat objekt Durable Object s funkcí Pages Function, můžete nakonfigurovat vazbu Durable Object v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu Durable Object přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > Durable Object.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části Durable Object namespace, vyberte požadovaný namespace.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití Durable Objects ve vaší Function. V následujícím příkladu se binding DO nazývá DURABLE_OBJECT a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequestGet(context) {
	const id = context.env.DURABLE_OBJECT.newUniqueId();
	const stub = context.env.DURABLE_OBJECT.get(id);

	// Pass the request down to the durable object
	return stub.fetch(context.request);
}

interface Env {
	DURABLE_OBJECT: DurableObjectNamespace;
}

export const onRequestGet: PagesFunction<Env> = async (context) => {
	const id = context.env.DURABLE_OBJECT.newUniqueId();
	const stub = context.env.DURABLE_OBJECT.get(id);

	// Pass the request down to the durable object
	return stub.fetch(context.request);
};

S vazbami Durable Object můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Pokud chcete při lokálním vývoji pracovat se jmenným prostorem Durable Object, spusťte wrangler dev v adresáři Workeru, který exportuje Durable Object. V jiném terminálu spusťte wrangler pages dev v adresáři svého projektu Pages.

Chcete-li lokálně pracovat s oborem názvů Durable Object přes Wrangler CLI, připojte --do <BINDING_NAME>=<CLASS_NAME>@<SCRIPT_NAME> na wrangler pages dev. CLASS_NAME udává název třídy Durable Object a SCRIPT_NAME název vašeho Workeru.

Pokud se váš Worker například jmenuje do-worker a deklaruje třídu Durable Object s názvem DurableObjectExample, přistupte k tomuto Durable Object spuštěním npx wrangler dev v do-worker adresář. Zároveň spusťte npx wrangler pages dev <OUTPUT_DIR> --do MY_DO=DurableObjectExample@do-worker v adresáři projektu Pages. Pracujte s MY_DO binding v kódu vaší Function pomocí context.env (například context.env.MY_DO).

R2 je řešení Cloudflare pro objektové úložiště, které vývojářům umožňuje ukládat velké objemy nestrukturovaných dat bez poplatků za odchozí přenos dat.

Chcete-li svázat úložiště R2 s funkcí Pages Function, můžete nakonfigurovat vazbu úložiště R2 v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu úložiště R2 přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > R2 bucket.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části R2 bucket, vyberte požadovaný bucket R2.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití R2 bucketů ve vaší Function. V následujícím příkladu se binding R2 bucketu nazývá BUCKET a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequest(context) {
	const obj = await context.env.BUCKET.get("some-key");
	if (obj === null) {
		return new Response("Not found", { status: 404 });
	}
	return new Response(obj.body);
}

interface Env {
	BUCKET: R2Bucket;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	const obj = await context.env.BUCKET.get("some-key");
	if (obj === null) {
		return new Response("Not found", { status: 404 });
	}
	return new Response(obj.body);
};

S vazbami R2 bucketů můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li pracovat s úložištěm R2 lokálně přes Wrangler CLI, přidejte --r2=<BINDING_NAME> do wrangler pages dev příkaz. Pokud je váš R2 bucket navázán na vaši Function pomocí BUCKET binding přistoupíte k tomuto R2 bucket v lokálním vývoji spuštěním:

npx wrangler pages dev <OUTPUT_DIR> --r2=BUCKET

S touto vazbou pracujte pomocí context.env (například context.env.BUCKET.)

D1 je nativní bezserverová databáze od Cloudflare.

Chcete-li svázat databázi D1 s funkcí Pages Function, můžete nakonfigurovat vazbu databáze D1 v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu databáze D1 přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat> Bindings databáze D1.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části databáze D1, vyberte požadovanou databázi D1.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití D1 ve vaší Function. V následujícím příkladu se binding databáze D1 nazývá NORTHWIND_DB a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequest(context) {
	// Create a prepared statement with our query
	const ps = context.env.NORTHWIND_DB.prepare("SELECT * from users");
	const data = await ps.first();

	return Response.json(data);
}

interface Env {
	NORTHWIND_DB: D1Database;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	// Create a prepared statement with our query
	const ps = context.env.NORTHWIND_DB.prepare("SELECT * from users");
	const data = await ps.first();

	return Response.json(data);
};

S vazbami databáze D1 můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li pracovat s databází D1 přes Wrangler CLI, když lokální vývoj, přidejte --d1 <BINDING_NAME>=<DATABASE_ID> do wrangler pages dev příkazu.

Pokud je vaše databáze D1 svázána s Pages Function pomocí NORTHWIND_DB binding a database_id ve vašem souboru Wrangler je xxxx-xxxx-xxxx-xxxx-xxxx, přistupte k této databázi v lokálním vývoji spuštěním:

npx wrangler pages dev <OUTPUT_DIR> --d1 NORTHWIND_DB=xxxx-xxxx-xxxx-xxxx-xxxx

S touto vazbou pracujte pomocí context.env (například context.env.NORTHWIND_DB.)

Viz Dokumentace D1 Workers Binding API pro metody API dostupné ve vaší vazbě D1.

Vectorize je nativní vektorová databáze Cloudflare.

Chcete-li svázat index Vectorize s funkcí Pages Function, můžete nakonfigurovat vazbu indexu Vectorize v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu indexu Vectorize přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte, zda chcete binding nastavit ve svém Produkce nebo Náhled prostředí.

3. Vyberte projekt Pages > Nastavení.

4. Přejděte na Bindings > Přidat > Vectorize index.

5. Pojmenujte svou vazbu v části Název proměnné.

6. V části Vectorize index, vyberte požadovaný index Vectorize.

7. Aby se binding projevil, znovu nasaďte projekt.

Chcete-li ve funkci Pages Function používat index Vectorize, přistupujte k jeho vazbě přímo v kódu funkce Pages Function. V následujícím příkladu se vazba na index Vectorize jmenuje VECTORIZE_INDEX a k vazbě máte přístup v kódu své Pages Function na context.env.

// Sample vectors: 3 dimensions wide.
//
// Vectors from a machine-learning model are typically ~100 to 1536 dimensions
// wide (or wider still).
const sampleVectors = [
	{
		id: "1",
		values: [32.4, 74.1, 3.2],
		metadata: { url: "/products/sku/13913913" },
	},
	{
		id: "2",
		values: [15.1, 19.2, 15.8],
		metadata: { url: "/products/sku/10148191" },
	},
	{
		id: "3",
		values: [0.16, 1.2, 3.8],
		metadata: { url: "/products/sku/97913813" },
	},
	{
		id: "4",
		values: [75.1, 67.1, 29.9],
		metadata: { url: "/products/sku/418313" },
	},
	{
		id: "5",
		values: [58.8, 6.7, 3.4],
		metadata: { url: "/products/sku/55519183" },
	},
];

export async function onRequest(context) {
	let path = new URL(context.request.url).pathname;
	if (path.startsWith("/favicon")) {
		return new Response("", { status: 404 });
	}

	// You only need to insert vectors into your index once
	if (path.startsWith("/insert")) {
		// Insert some sample vectors into your index
		// In a real application, these vectors would be the output of a machine learning (ML) model,
		// such as Workers AI, OpenAI, or Cohere.
		let inserted = await context.env.VECTORIZE_INDEX.insert(sampleVectors);

		// Return the number of IDs we successfully inserted
		return Response.json(inserted);
	}
}

export interface Env {
	// This makes our vector index methods available on context.env.VECTORIZE_INDEX.*
	// For example, context.env.VECTORIZE_INDEX.insert() or query()
	VECTORIZE_INDEX: VectorizeIndex;
}

// Sample vectors: 3 dimensions wide.
//
// Vectors from a machine-learning model are typically ~100 to 1536 dimensions
// wide (or wider still).
const sampleVectors: Array<VectorizeVector> = [
	{
		id: "1",
		values: [32.4, 74.1, 3.2],
		metadata: { url: "/products/sku/13913913" },
	},
	{
		id: "2",
		values: [15.1, 19.2, 15.8],
		metadata: { url: "/products/sku/10148191" },
	},
	{
		id: "3",
		values: [0.16, 1.2, 3.8],
		metadata: { url: "/products/sku/97913813" },
	},
	{
		id: "4",
		values: [75.1, 67.1, 29.9],
		metadata: { url: "/products/sku/418313" },
	},
	{
		id: "5",
		values: [58.8, 6.7, 3.4],
		metadata: { url: "/products/sku/55519183" },
	},
];

export const onRequest: PagesFunction<Env> = async (context) => {
	let path = new URL(context.request.url).pathname;
	if (path.startsWith("/favicon")) {
		return new Response("", { status: 404 });
	}

	// You only need to insert vectors into your index once
	if (path.startsWith("/insert")) {
		// Insert some sample vectors into your index
		// In a real application, these vectors would be the output of a machine learning (ML) model,
		// such as Workers AI, OpenAI, or Cohere.
		let inserted = await context.env.VECTORIZE_INDEX.insert(sampleVectors);

		// Return the number of IDs we successfully inserted
		return Response.json(inserted);
	}
};

Workers AI umožňuje spouštět modely strojového učení pomocí serverless GPU v globální síti Cloudflare.

Chcete-li navázat Workers AI na vaši Pages Function, nakonfigurujte binding Workers AI v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Při lokálním vývoji pomocí Wrangler můžete definovat AI binding pomocí --ai příznak. Wrangler spustíte ve vývojovém režimu příkazem wrangler pages dev --ai AI a zveřejněte context.env.AI binding.

Chcete-li nakonfigurovat vazbu Workers AI přes Cloudflare dashboard:

1. Přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte projekt Pages > Nastavení.

3. Vyberte prostředí Pages > Bindings > Přidat > Workers AI.

4. Pojmenujte svou vazbu v části Název proměnné.

5. Aby se binding projevil, znovu nasaďte projekt.

Chcete-li ve funkci Pages Function používat Workers AI, přistupujte k jeho vazbě přímo v kódu funkce Pages Function. V následujícím příkladu se vazba na Workers AI jmenuje AI a k vazbě máte přístup v kódu své Pages Function na context.env.

export async function onRequest(context) {
	const input = { prompt: "What is the origin of the phrase Hello, World" };

	const answer = await context.env.AI.run(
		"@cf/meta/llama-3.1-8b-instruct",
		input,
	);

	return Response.json(answer);
}

interface Env {
	AI: Ai;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	const input = { prompt: "What is the origin of the phrase Hello, World" };

	const answer = await context.env.AI.run(
		"@cf/meta/llama-3.1-8b-instruct",
		input,
	);

	return Response.json(answer);
};

S vazbami Workers AI můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li při místním vývoji pracovat s vazbou Workers AI přes Wrangler CLI, spusťte:

npx wrangler pages dev --ai=<BINDING_NAME>

Service bindings vám umožňují volat Worker přímo z vaší Pages Function.

Chcete-li svázat funkci Pages Function s Workerem, nakonfigurujte ve funkci Pages Function vazbu Service pomocí Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu Service přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > Service binding.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části Služba, vyberte požadovaný Worker.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití Service bindings ve vaší Function. V následujícím příkladu se Service binding nazývá SERVICE a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequestGet(context) {
	return context.env.SERVICE.fetch(context.request);
}

interface Env {
	SERVICE: Fetcher;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	return context.env.SERVICE.fetch(context.request);
};

S vazbami Service můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spusťte npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li pracovat s Service binding při lokálním vývoji spusťte Worker, ke kterému se chcete připojit, pomocí wrangler dev a paralelně spusťte wrangler pages dev hodnotou --service <BINDING_NAME>=<SCRIPT_NAME> kde SCRIPT_NAME udává název Workeru. Pokud se váš Worker jmenuje například my-worker, propojte se s tímto Workerem jeho spuštěním přes npx wrangler dev (v adresáři Workeru) spolu s npx wrangler pages dev <OUTPUT_DIR> --service MY_SERVICE=my-worker (v adresáři Pages). S touto vazbou pracujte pomocí context.env (například context.env.MY_SERVICE).

Pokud Service binding nastavíte přes Cloudflare dashboard, budete muset připojit wrangler pages dev hodnotou --service <BINDING_NAME>=<SCRIPT_NAME> kde BINDING_NAME je název Service bindingu a SCRIPT_NAME je název Workeru.

Chcete-li například vyvíjet lokálně a váš Worker se jmenuje my-worker, spusťte npx wrangler dev v my-worker adresář. V jiném terminálu také spusťte npx wrangler pages dev <OUTPUT_DIR> --service MY_SERVICE=my-worker v adresáři projektu Pages. S touto vazbou Service pracujte pomocí context.env (například context.env.MY_SERVICE).

Wrangler také umožňuje spustit váš projekt Pages a k němu připojené Workers ve stejné vývojářské relaci jediným příkazem. Chcete-li si to vyzkoušet, předejte Wrangler více příznaků -c, například takto: wrangler pages dev -c wrangler.jsonc -c ../other-worker/wrangler.jsonc. První argument musí odkazovat na váš konfigurační soubor Pages a následné konfigurace budou dostupné prostřednictvím Service bindingu z vašeho projektu Pages.

Queue Producers vám umožňují odesílat zprávy do fronty přímo z vaší Pages Function.

Chcete-li navázat frontu na vaši Pages Function, nakonfigurujte binding producenta fronty pomocí Konfigurační soubor Wrangler nebo Cloudflare dashboard:

Chcete-li nakonfigurovat vazbu producenta fronty přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > Queue.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části Queue, vyberte požadovanou frontu.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití bindingu producenta fronty ve vaší Function. V tomto příkladu se binding nazývá MY_QUEUE a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequest(context) {
	await context.env.MY_QUEUE.send({
		url: request.url,
		method: request.method,
		headers: Object.fromEntries(request.headers),
	});

	return new Response("Sent!");
}

interface Env {
	MY_QUEUE: Queue<any>;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	await context.env.MY_QUEUE.send({
		url: request.url,
		method: request.method,
		headers: Object.fromEntries(request.headers),
	});

	return new Response("Sent!");
};

Pokud v Pages Function používáte binding producenta fronty, budete moci lokálně odesílat události do fronty. Přijímat události z fronty pomocí Pages Function ale možné není. Budete muset vytvořit samostatný Worker konzument s obslužná rutina spotřebitele fronty a odebírejte události z fronty. Wrangler zatím nepodporuje lokální spouštění samostatných producer Functions a consumer Workers navázaných na stejnou frontu.

Hyperdrive je služba pro připojení k vašim stávajícím databázím z Cloudflare Workers a Pages Functions.

Chcete-li svázat konfiguraci Hyperdrive s funkcí Pages Function, můžete nakonfigurovat vazbu Hyperdrive v Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat vazbu Hyperdrive přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > Hyperdrive.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části konfigurace Hyperdrive, vyberte požadovanou konfiguraci.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití Hyperdrive ve vaší Function. V následujícím příkladu se konfigurace Hyperdrive nazývá HYPERDRIVE a k vazbě máte přístup v kódu své funkce na context.env:

import postgres from "postgres";

export async function onRequest(context) {
	// create connection to postgres database
	const sql = postgres(context.env.HYPERDRIVE.connectionString);

	try {
		const result = await sql`SELECT id, name, value FROM records`;

		return Response.json({result: result})
	} catch (e) {
		return Response.json({error: e.message, {status: 500}});
	}
}

import postgres from "postgres";

interface Env {
	HYPERDRIVE: Hyperdrive;
}

type MyRecord = {
	id: number;
	name: string;
	value: string;
};

export const onRequest: PagesFunction<Env> = async (context) => {
	// create connection to postgres database
	const sql = postgres(context.env.HYPERDRIVE.connectionString);

	try {
		const result = await sql<MyRecord[]>`SELECT id, name, value FROM records`;

		return Response.json({result: result})
	} catch (e) {
		return Response.json({error: e.message, {status: 500}});
	}
};

Chcete-li lokálně pracovat s vazbou Hyperdrive, musíte zadat lokální připojovací řetězec k databázi, ke které se váš projekt Pages připojí přímo. Můžete nastavit proměnnou prostředí CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_<BINDING_NAME> s připojovacím řetězcem databáze, nebo nakonfigurujte binding Hyperdrive v souboru Wrangler pomocí localConnectionString jak je uvedeno v dokumentace Hyperdrive pro lokální vývoj. Poté spusťte npx wrangler pages dev <OUTPUT_DIR>.

Analytics Engine binding umožňuje zapisovat analytická data přímo z vaší Pages Function.

Chcete-li navázat datovou sadu Analytics Engine na vaši Pages Function, musíte nakonfigurovat binding Analytics Engine pomocí Konfigurační soubor Wrangler nebo Cloudflare dashboard:

Chcete-li nakonfigurovat vazbu Analytics Engine přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Bindings > Přidat > Analytics engine.

4. Pojmenujte svou vazbu v části Název proměnné.

5. V části Dataset, zadejte požadovanou datovou sadu.

6. Aby se binding projevil, znovu nasaďte projekt.

Níže je příklad použití bindingu Analytics Engine ve vaší Function. V následujícím příkladu se binding nazývá ANALYTICS_ENGINE a k vazbě máte přístup v kódu své funkce na context.env:

export async function onRequest(context) {
	const url = new URL(context.request.url);

	context.env.ANALYTICS_ENGINE.writeDataPoint({
		indexes: [],
		blobs: [url.hostname, url.pathname],
		doubles: [],
	});

	return new Response("Logged analytic");
}

interface Env {
	ANALYTICS_ENGINE: AnalyticsEngineDataset;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	const url = new URL(context.request.url);

	context.env.ANALYTICS_ENGINE.writeDataPoint({
		indexes: [],
		blobs: [url.hostname, url.pathname],
		doubles: [],
	});

	return new Response("Logged analytic");
};

Vazbu Analytics Engine nelze použít lokálně.

proměnná prostředí je vložená hodnota, ke které mají přístup vaše funkce. Proměnné prostředí jsou typem vazby, která umožňuje připojit k vaší Pages Function textové řetězce nebo hodnoty JSON. Ukládají se jako čistý text. Proměnné prostředí nastavte přímo v Cloudflare dashboardu, a to jak pro produkční, tak pro náhledové prostředí, za běhu i při sestavení.

Proměnné prostředí do projektu Pages přidáte pomocí Konfigurační soubor Wrangler nebo Cloudflare dashboard.

Chcete-li nakonfigurovat proměnnou prostředí přes Cloudflare dashboard:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Proměnné a tajné klíče > Přidat .

4. Po nastavení názvu proměnné a hodnoty vyberte Save.

Níže je příklad použití proměnných prostředí ve vaší Function. Proměnná prostředí je v tomto příkladu nazvána ENVIRONMENT a k proměnné prostředí máte přístup na context.env:

export function onRequest(context) {
	if (context.env.ENVIRONMENT === "development") {
		return new Response("This is a local environment!");
	} else {
		return new Response("This is a live environment");
	}
}

interface Env {
	ENVIRONMENT: string;
}

export const onRequest: PagesFunction<Env> = async (context) => {
	if (context.env.ENVIRONMENT === "development") {
		return new Response("This is a local environment!");
	} else {
		return new Response("This is a live environment");
	}
};

S proměnnými prostředí můžete lokálně pracovat dvěma způsoby:

• Nastavte soubor Wrangler svého projektu Pages a spouštění npx wrangler pages dev.
• Předejte argumenty do wrangler pages dev přímo.

Chcete-li lokálně pracovat se svými proměnnými prostředí přes Wrangler CLI, přidejte --binding=<ENVIRONMENT_VARIABLE_NAME>=<ENVIRONMENT_VARIABLE_VALUE> do wrangler pages dev příkaz:

npx wrangler pages dev --binding=<ENVIRONMENT_VARIABLE_NAME>=<ENVIRONMENT_VARIABLE_VALUE>

Secrets jsou typ bindingu, který umožňuje připojit k vaší Pages Function šifrované textové hodnoty. Po nastavení secrets je již nelze zobrazit a přistupovat k nim lze pouze programově na context.env. Secrets slouží k ukládání citlivých informací, jako jsou API klíče a autorizační tokeny.

Přidání tajných klíčů do projektu Pages:

1. V dashboardu Cloudflare přejděte na Workers & Pages stránce.

   Přejděte na Workers & Pages ↗

2. Vyberte svůj projekt Pages.

3. Přejděte na Nastavení > Proměnné a tajné klíče > Přidat.

4. Nastavte název a hodnotu proměnné.

5. Vyberte Šifrovat a vytvořte svůj secret.

6. Vyberte Save.

Secrets se používají stejně jako proměnné prostředí. Při nastavování secrets pomocí Wrangler nebo v dashboardu Cloudflare je nutné to provést před nasazením, které tyto secrets využívá. Další pokyny naleznete v Proměnné prostředí.

Uložte secrets pro použití při lokálním vývoji buď do .dev.vars soubor nebo .env soubor ve stejném adresáři jako konfigurační soubor Wrangleru.

Tyto soubory by měly být formátovány pomocí dotenv ↗ syntax. Například:

SECRET_KEY="value"
API_TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"

Chcete-li nastavit různé tajné klíče pro každé prostředí Cloudflare, vytvořte soubory s názvem .dev.vars.<environment-name> nebo .env.<environment-name>.

Když v lokálním vývoji vyberete prostředí Cloudflare, načte se nejprve soubor specifický pro dané prostředí, a to před obecným .dev.vars (nebo .env) soubor.

• Při použití .dev.vars.<environment-name> soubory, všechny secrets musí být definovány pro každé prostředí zvlášť. Pokud .dev.vars.<environment-name> existuje, načte se jen ten; .dev.vars soubor se nenačte.
• Naproti tomu všechny odpovídající .env soubory se načtou a hodnoty se sloučí. Pro každou proměnnou se použije hodnota z nejspecifičtějšího souboru, a to v tomto pořadí priority:
  • .env.<environment-name>.local (nejvíce specifické)
  • .env.local
  • .env.<environment-name>
  • .env (nejméně specifické)