Inhaltsverzeichnis

std.cloud — Cloudflare-Units

Cloudflare API v4 Bindings für Lyx: 16 Units für alle Cloudflare-Dienste. Authentifizierung über API-Token (empfohlen) oder Legacy API-Key + E-Mail. Der HTTP-Transport nutzt std.net.https mit automatischem Retry.

std.cloud · Standard Library


Units im Überblick

Unit Import Beschreibung
cf/credentials import std.cloud.cf.credentials; API-Token, Legacy API-Key, Env-Variablen, Config-Datei
cf/transport (intern) CFClient, CFResponse, HTTP-Helpers
cf/zones import std.cloud.cf.zones; Domains verwalten: Anlegen, Pause/Unpause, Settings
cf/dns import std.cloud.cf.dns; DNS-Records CRUD, Upsert-Muster
cf/workers import std.cloud.cf.workers; Worker-Scripts deployen, Routes, Secrets, Crons, Tail
cf/kv import std.cloud.cf.kv; Workers KV: Key-Value-Store mit TTL und Bulk-Operationen
cf/r2 import std.cloud.cf.r2; R2 Objekt-Speicher: Upload/Download, Multipart, Presigned URLs
cf/d1 import std.cloud.cf.d1; D1 SQLite-Datenbank: Query, Exec, ExecScript
cf/cache import std.cloud.cf.cache; Cache-Purge, Page Rules, Cache-Rules, Transform-Rules
cf/waf import std.cloud.cf.waf; Firewall-Rules, IP-Sperren, Rate Limiting
cf/lb import std.cloud.cf.lb; Load Balancer: Health Checks, Pools, Load Balancer
cf/pages import std.cloud.cf.pages; Cloudflare Pages: Projekte und Deployments
cf/tunnel import std.cloud.cf.tunnel; Cloudflare Tunnel: erstellen, Token, Konfiguration
cf/email import std.cloud.cf.email; Email Routing: Regeln, DNS-Verifikation
cf/analytics import std.cloud.cf.analytics; Zone-Analytics, GraphQL, Logpush
cf/core (intern) JSON-Builder, Pfad-Builder (interne Helpers)

std.cloud.cf.credentials

Drei Authentifizierungsarten — API-Token ist die empfohlene Methode:

Typen

Typ Felder Beschreibung
CFCredentials authType, token, apiKey, email, accountId, zoneId Zugangsdaten (alle Felder int64/pchar)

Konstanten

Konstante Bedeutung
CF_AUTH_TOKEN Bearer-Token (empfohlen)
CF_AUTH_KEY Legacy: API-Key + E-Mail
CF_AUTH_SERVICE Service-Key (Account-level)

Funktionen

Funktion Beschreibung
CFCredentialsFromToken(token, accountId: pchar): CFCredentials API-Token + Account-ID
CFCredentialsFromKey(apiKey, email, accountId: pchar): CFCredentials Legacy API-Key
CFCredentialsFromEnv(): CFCredentials Aus CLOUDFLARE_API_TOKEN + CLOUDFLARE_ACCOUNT_ID
CFCredentialsDefault(): CFCredentials Env → Config-Datei
CFConfigLoad(path: pchar): CFCredentials Aus Konfigurationsdatei
CFConfigSave(c: CFCredentials, path: pchar): int64 Credentials in Datei speichern
CFCredentialsFree(c: CFCredentials) Allokierte Felder freigeben

CFClient und CFResponse

CFClient wird aus CFCredentials erstellt und an alle Service-Funktionen übergeben. Cloudflare-Antworten unterscheiden sich von AWS: Die API liefert immer HTTP 200 — der Erfolg wird über das success-Feld in CFResponse signalisiert.

Feld Typ Bedeutung
success int64 1 = Erfolg, 0 = Fehler
statusCode int64 HTTP-Statuscode (fast immer 200)
result int64 Allokierter JSON-String mit dem Ergebnis
resultLen int64 Länge von result
errors int64 JSON-Array mit Fehlern (bei success == 0)
messages int64 JSON-Array mit Hinweisen

import std.cloud.cf.credentials;
import std.cloud.cf.transport;
import std.cloud.cf.zones;

fn main(): int64 {
    // Credentials aus Umgebung laden
    var creds: CFCredentials := CFCredentialsFromEnv();
    var c: CFClient := CFClientNew(creds);

    // Alle Zones des Accounts
    var result: int64 := ZoneList(c, creds.accountId as pchar);
    if (result != 0) {
        Print(result as pchar);
        PrintLn(""c);
        free(result, StrLen(result as pchar) + 1);
    }

    CFClientFree(c);
    CFCredentialsFree(creds);
    return 0;
}

Umgebungsvariablen:

Variable Bedeutung
CLOUDFLARE_API_TOKEN API-Token (empfohlen)
CLOUDFLARE_ACCOUNT_ID Account-ID
CLOUDFLARE_API_KEY Legacy API-Key
CLOUDFLARE_API_EMAIL Legacy E-Mail

std.cloud.cf.zones

Domain-Verwaltung. Eine Zone entspricht einer Domain. 29 pub Items.

Funktion Beschreibung
ZoneCreate(c, domain, accountId, zoneType): CFZone Zone anlegen (zoneType: full/partial/secondary)
ZoneDelete(c, zoneId): int64 Zone löschen
ZoneGet(c, zoneId): CFZone Zone-Details
ZoneGetByDomain(c, domain): CFZone Zone per Domain-Name finden
ZoneList(c, accountId): int64 Alle Zones des Accounts (JSON)
ZoneListAccount(c, accountId): int64 Wie ZoneList
ZonePause(c, zoneId): int64 Cloudflare-Proxy deaktivieren (DNS-Only)
ZoneUnpause(c, zoneId): int64 Proxy wieder aktivieren
ZoneActivationCheck(c, zoneId): int64 Nameserver-Aktivierung prüfen
ZoneSettingGet(c, zoneId, setting): CFSetting Einzelne Einstellung lesen
ZoneSettingSet(c, zoneId, setting, value): int64 Einstellung setzen
ZoneSSLSet / ZoneAlwaysHTTPS / ZoneMinify SSL-Level, HTTPS-Zwang, Minify
ZoneDevelopmentMode(c, zoneId, enable): int64 Development Mode an/aus

std.cloud.cf.dns

DNS-Records verwalten. 23 pub Items.

Funktion Beschreibung
DNSRecordCreate(c, zoneId, type, name, content, ttl, proxied): CFDNSRecord Record anlegen
DNSRecordUpdate(c, zoneId, recordId, type, name, content, ttl, proxied): CFDNSRecord Record ersetzen
DNSRecordPatch(c, zoneId, recordId, content): CFDNSRecord Nur Inhalt ändern
DNSRecordDelete(c, zoneId, recordId): int64 Record löschen
DNSRecordGet(c, zoneId, recordId): CFDNSRecord Einzelner Record
DNSRecordList(c, zoneId): int64 Alle Records der Zone (JSON)
DNSRecordListByType(c, zoneId, recType): int64 Gefiltert nach Typ (A, CNAME, MX, …)
DNSRecordListByName(c, zoneId, name): int64 Gefiltert nach Name
DNSRecordFind(c, zoneId, recType, name): CFDNSRecord Ersten passenden Record liefern
DNSRecordUpsert(c, zoneId, type, name, content, ttl, proxied): CFDNSRecord Anlegen oder aktualisieren

import std.cloud.cf.credentials;
import std.cloud.cf.transport;
import std.cloud.cf.dns;

fn main(): int64 {
    var creds: CFCredentials := CFCredentialsFromEnv();
    var c: CFClient := CFClientNew(creds);

    // A-Record setzen (oder aktualisieren, falls schon vorhanden)
    var r: CFDNSRecord := DNSRecordUpsert(c,
        "abc123def456"c,   // zoneId
        "A"c,              // Typ
        "api"c,            // Name → api.meine-domain.de
        "1.2.3.4"c,        // Content
        1,                 // TTL (1 = auto)
        1                  // proxied: 1 = ja (oranges Wolkensymbol)
    );
    CFDNSRecordFree(r);

    CFClientFree(c);
    CFCredentialsFree(creds);
    return 0;
}


std.cloud.cf.workers

Cloudflare Workers: serverless JavaScript/WASM an Cloudflares Edge deployen. 27 pub Items.

Funktion Beschreibung
WorkerDeploy(c, accountId, scriptName, scriptContent, scriptLen): int64 Script als einzelne Datei deployen
WorkerDeployModule(c, accountId, scriptName, esm, esmLen): int64 ES-Modul-Format
WorkerDeployWithBindings(c, accountId, scriptName, script, scriptLen, bindings): int64 Mit KV/R2/D1-Bindings
WorkerDeployWasm(c, accountId, scriptName, wasm, wasmLen): int64 WebAssembly-Binary deployen
WorkerDelete(c, accountId, scriptName): int64 Script löschen
WorkerGet(c, accountId, scriptName): CFWorkerScript Script-Metadaten
WorkerList(c, accountId): int64 Alle Scripts (JSON)
WorkerDownload(c, accountId, scriptName): int64 Script-Code herunterladen
WorkerRouteCreate(c, zoneId, pattern, scriptName): CFWorkerRoute Route anlegen (z.B. meine-domain.de/api/*)
WorkerRouteUpdate / WorkerRouteDelete / WorkerRouteList Route-Verwaltung
WorkerSecretSet(c, accountId, scriptName, key, value): int64 Secret (Env-Variable) setzen
WorkerSecretDelete / WorkerSecretList Secret-Verwaltung
WorkerCronCreate(c, accountId, scriptName, cron): int64 Cron-Trigger anlegen (z.B. 0 * * * *)
WorkerCronList(c, accountId, scriptName): int64 Cron-Trigger auflisten
WorkerTailStart(c, accountId, scriptName): int64 Live-Log-Stream starten
WorkerSubdomainCreate / WorkerEnableSubdomain / WorkerDisableSubdomain workers.dev-Subdomain verwalten

std.cloud.cf.kv

Workers KV: globaler Key-Value-Store für Worker-Scripts. 19 pub Items.

Funktion Beschreibung
KVNamespaceCreate(c, accountId, title): CFKVNamespace Namespace anlegen
KVNamespaceDelete / KVNamespaceRename / KVNamespaceList Namespace-Verwaltung
KVGet(c, accountId, nsId, key): int64 Wert lesen (allokierter Puffer, 0 wenn nicht vorhanden)
KVPut(c, accountId, nsId, key, value, valueLen): int64 Wert schreiben
KVPutWithTTL(c, accountId, nsId, key, value, valueLen, ttlSeconds): int64 Mit Ablaufzeit (Sekunden)
KVPutWithExpiry(c, accountId, nsId, key, value, valueLen, unixTs): int64 Mit absolutem Ablauf-Timestamp
KVPutWithMeta(c, accountId, nsId, key, value, valueLen, meta): int64 Mit Metadaten-JSON
KVDelete(c, accountId, nsId, key): int64 Eintrag löschen
KVExists(c, accountId, nsId, key): int64 Existenz prüfen (1/0)
KVList(c, accountId, nsId, prefix, cursor, limit): int64 Keys paginiert auflisten
KVListAll(c, accountId, nsId, prefix): int64 Alle Keys (automatisch paginiert)
KVPutBulk(c, accountId, nsId, entries, count): int64 Mehrere Keys gleichzeitig schreiben
KVDeleteBulk(c, accountId, nsId, keys, count): int64 Mehrere Keys gleichzeitig löschen

std.cloud.cf.r2

Cloudflare R2: S3-kompatibler Objekt-Speicher ohne Egress-Kosten. 27 pub Items.

R2 verwendet einen eigenen R2Conn-Handle (nicht CFClient), der über R2Connect erstellt wird.

Funktion Beschreibung
R2Connect(creds, accountId): R2Conn R2-Verbindung aufbauen
R2Disconnect©: void Verbindung schließen
R2BucketCreate(creds, accountId, bucket, location): int64 Bucket anlegen (location: wnam/enam/weur/eeur/apac)
R2BucketDelete(creds, accountId, bucket): int64 Bucket löschen
R2BucketList(creds, accountId): int64 Alle Buckets
R2BucketExists(creds, accountId, bucket): int64 Bucket-Existenz prüfen
R2Upload(c, bucket, key, data, dataLen): int64 Objekt hochladen
R2Download(c, bucket, key): int64 Objekt herunterladen
R2Delete(c, bucket, key): int64 Objekt löschen
R2Exists(c, bucket, key): int64 Objekt-Existenz prüfen
R2List(c, bucket, prefix): int64 Objekte auflisten
R2Copy(c, srcBucket, srcKey, dstBucket, dstKey): int64 Server-seitiges Kopieren
R2GetMeta(c, bucket, key): int64 Metadaten ohne Body (HEAD)
R2MultipartStart/Upload/Complete/Abort Multipart-Upload für große Dateien
R2PresignedURL(c, bucket, key, method, expirySeconds): int64 Presigned URL (GET/PUT/DELETE)
R2BucketEnablePublic(creds, accountId, bucket): int64 Öffentlichen Bucket-Zugriff aktivieren
R2PublicURL(accountId, bucket, key): int64 Öffentliche URL eines Objekts berechnen
R2CustomDomainAdd / R2CustomDomainList / R2CustomDomainRemove Custom Domain für Bucket
R2AccessKeyCreate / R2AccessKeyList / R2AccessKeyDelete S3-kompatible Access Keys verwalten

std.cloud.cf.d1

D1: SQLite-Datenbank an Cloudflares Edge (für Worker-Bindings). 24 pub Items.

Funktion Beschreibung
D1Create(c, accountId, name): CFD1Database Datenbank anlegen
D1Delete(c, accountId, dbId): int64 Datenbank löschen
D1Get(c, accountId, dbId): CFD1Database Datenbank-Details per ID
D1GetByName(c, accountId, name): CFD1Database Datenbank-Details per Name
D1List(c, accountId): int64 Alle Datenbanken (JSON)
D1Query(c, accountId, dbId, sql, params, paramCount): D1Result SELECT mit Parametern — gibt Zeilen zurück
D1Exec(c, accountId, dbId, sql): D1Result INSERT/UPDATE/DELETE
D1ExecScript(c, accountId, dbId, sqlScript): int64 Mehrere Statements aus Script

import std.cloud.cf.credentials;
import std.cloud.cf.transport;
import std.cloud.cf.d1;

fn main(): int64 {
    var creds: CFCredentials := CFCredentialsFromEnv();
    var c: CFClient := CFClientNew(creds);

    var db: CFD1Database := D1GetByName(c, creds.accountId as pchar, "meine-db"c);

    // Tabelle anlegen
    D1Exec(c, creds.accountId as pchar, db.id as pchar,
           "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)"c);

    // Datensatz einfügen
    D1Exec(c, creds.accountId as pchar, db.id as pchar,
           "INSERT INTO users (name) VALUES ('Alice')"c);

    // Abfrage
    var params: array<pchar> := [];
    var result: D1Result := D1Query(c, creds.accountId as pchar, db.id as pchar,
                                    "SELECT * FROM users"c, 0 as int64, 0);
    D1ResultFree(result);
    CFD1DatabaseFree(db);

    CFClientFree(c);
    CFCredentialsFree(creds);
    return 0;
}


std.cloud.cf.cache

Cache-Verwaltung, Page Rules und Transform Rules. 31 pub Items.

Cache-Purge

Funktion Beschreibung
CachePurgeAll(c, zoneId): int64 Gesamten Cache der Zone leeren
CachePurgeFiles(c, zoneId, urls, count): int64 Bestimmte URLs invalidieren
CachePurgeTags(c, zoneId, tags, count): int64 Nach Cache-Tags invalidieren
CachePurgePrefixes(c, zoneId, prefixes, count): int64 Nach URL-Prefix invalidieren
CachePurgeHosts(c, zoneId, hosts, count): int64 Alle URLs eines Hostnamens

Cache-Rules und Page Rules

Funktion Beschreibung
CacheRuleCreate(c, zoneId, description, expression, action, ttl): CFCacheRule Cache-Regel anlegen
CacheRuleDelete / CacheRuleList Regeln verwalten
PageRuleCreate(c, zoneId, url, settings, priority, status): CFPageRule Page Rule anlegen
PageRuleRedirect(c, zoneId, urlPattern, target, statusCode): CFPageRule Weiterleitungs-Rule
PageRuleForceHTTPS(c, zoneId, pattern): CFPageRule HTTPS-Zwang für URL-Muster
PageRuleCacheEverything(c, zoneId, pattern, ttl): CFPageRule Alles cachen (inkl. HTML)
PageRuleDelete / PageRuleList Regeln verwalten
TransformRuleCreate / TransformRuleDelete / TransformRuleList Transform Rules

Zone-Settings

Häufig verwendete Konstanten für ZoneSettingSet:

Konstante Bedeutung
CF_PR_ALWAYS_HTTPS HTTP→HTTPS-Weiterleitung
CF_PR_BROWSER_CACHE_TTL Browser-Cache-Dauer
CF_PR_CACHE_LEVEL Cache-Level (aggressive/basic/simplified)
CF_PR_EDGE_CACHE_TTL Edge-Cache-Dauer
CF_PR_SSL SSL-Modus (off/flexible/full/strict)

std.cloud.cf.waf

Web Application Firewall: Firewall-Rules, IP-Sperren, Rate Limiting. 32 pub Items.

Funktion Beschreibung
FirewallRuleCreate(c, zoneId, expression, action, priority, description): CFFirewallRule WAF-Regel mit Filterausdruck
FirewallRuleDelete / FirewallRuleList Regeln verwalten
FirewallRuleEnable / FirewallRuleDisable Regel aktivieren / deaktivieren
FirewallBlockIP(c, zoneId, ip, note): CFFirewallRule IP-Adresse sperren
FirewallBlockCountry(c, zoneId, countryCode, note): CFFirewallRule Ganzes Land sperren (ISO 3166-1)
FirewallAllowIP(c, zoneId, ip, note): CFFirewallRule IP auf Whitelist setzen
FirewallChallengePath(c, zoneId, pathPrefix, note): CFFirewallRule JS-Challenge für Pfad-Prefix
IPRuleCreate(c, zoneId, mode, target, value, notes): CFIPAccessRule IP-Zugriffs-Regel (Zone-Level)
IPRuleCreateAccount(c, mode, target, value, notes): CFIPAccessRule Account-Level IP-Regel
IPRuleDelete / IPRuleList / IPRuleListAccount IP-Regeln verwalten
RateLimitCreate(c, zoneId, threshold, period, action, url): CFRateLimit Rate-Limiting anlegen
RateLimitDelete / RateLimitList Rate-Limits verwalten

std.cloud.cf.lb

Cloudflare Load Balancer: Health Checks, Pools, Load Balancer. 20 pub Items.

Schicht Funktionen Beschreibung
Health Check HealthCheckCreate(c, accountId, name, type, address, port, path, interval, retries) Endpunkt-Überwachung (HTTP/HTTPS/TCP)
Origin Pool PoolCreate(c, accountId, name, origins, originCount, healthCheckId, minOrigins) Gruppe von Endpunkten
Load Balancer LBCreate(c, zoneId, name, defaultPoolIds, fallbackPoolId, proxied) Öffentlicher Einstiegspunkt
Funktion Beschreibung
HealthCheckDelete / HealthCheckList Health-Check-Verwaltung
PoolDelete / PoolGet / PoolList Pool-Verwaltung
PoolHealthGet(c, accountId, poolId) Aktuellen Health-Status eines Pools
LBDelete / LBGet / LBList Load-Balancer-Verwaltung
LBHealthGet(c, zoneId, lbId) Health-Status aller Pools des LB

std.cloud.cf.pages

Cloudflare Pages: statische Sites und Full-Stack-Apps deployen. 23 pub Items.

Funktion Beschreibung
PagesProjectCreate(c, accountId, name, productionBranch): CFPagesProject Projekt anlegen
PagesProjectDelete / PagesProjectGet / PagesProjectList / PagesProjectUpdate Projekt-Verwaltung
PagesDeploy(c, accountId, projectName, files, fileCount, branch): CFPagesDeployment Deployment aus Dateiliste
PagesDeployDir(c, accountId, projectName, localDir, branch): CFPagesDeployment Deployment aus lokalem Verzeichnis
PagesDeploymentGet(c, accountId, projectName, deploymentId): CFPagesDeployment Deployment-Status
PagesDeploymentList(c, accountId, projectName): int64 Alle Deployments
PagesDeploymentRetry / PagesDeploymentRollback Deployment neu starten / zurückrollen
PagesCustomDomainAdd / PagesCustomDomainList / PagesCustomDomainDelete Custom Domains
PagesEnvVarSet / PagesEnvVarDelete / PagesEnvVarList Umgebungsvariablen

std.cloud.cf.tunnel

Cloudflare Tunnel (ehemals Argo Tunnel): Server hinter NAT/Firewall öffentlich erreichbar machen ohne offene Ports. 22 pub Items.

Funktion Beschreibung
TunnelCreate(c, accountId, name, secret): CFTunnel Tunnel anlegen (secret = 32 Byte Hex)
TunnelDelete(c, accountId, tunnelId): int64 Tunnel löschen
TunnelGet / TunnelGetByName / TunnelList Tunnel-Verwaltung
TunnelCleanup(c, accountId, tunnelId): int64 Veraltete Verbindungen bereinigen
TunnelToken(c, accountId, tunnelId): int64 Connector-Token abrufen (für cloudflared)
TunnelTokenSave(c, accountId, tunnelId, path): int64 Token in Datei speichern
TunnelConfigGet(c, accountId, tunnelId): int64 Ingress-Regeln abrufen (JSON)
TunnelConfigSet(c, accountId, tunnelId, config): int64 Ingress-Regeln setzen
TunnelIngressAdd / TunnelIngressDelete / TunnelIngressList Einzel-Ingress-Einträge verwalten

std.cloud.cf.email

Email Routing: eingehende E-Mails an Adressen oder Worker weiterleiten. 19 pub Items.

Funktion Beschreibung
EmailRoutingGet(c, zoneId): CFEmailSettings Aktuellen Status abrufen
EmailRoutingEnable / EmailRoutingDisable Email Routing an/aus
EmailRoutingDNSGet(c, zoneId): int64 Erforderliche DNS-Records (MX, SPF)
EmailRoutingDNSVerify(c, zoneId): int64 DNS-Konfiguration prüfen
EmailRuleCreate(c, zoneId, name, priority, matchers, actions): CFEmailRule Weiterleitungsregel anlegen
EmailRuleCreateWorker(c, zoneId, name, priority, matcher, workerName): CFEmailRule E-Mail an Worker weiterleiten
EmailRuleDelete / EmailRuleGet / EmailRuleList Regeln verwalten
EmailRuleEnable / EmailRuleDisable Regel aktivieren / deaktivieren
EmailCatchAllGet / EmailCatchAllSet Catch-All-Adresse

std.cloud.cf.analytics

Zone-Analytics, GraphQL-API und Logpush. 14 pub Items.

Funktion Beschreibung
AnalyticsDashboard(c, zoneId, since, until): int64 Gesamt-Analytics einer Zone (JSON)
AnalyticsTimeseries(c, zoneId, since, until, metrics): int64 Zeitreihen-Daten
AnalyticsGraphQL(c, query, variables): int64 Freie GraphQL-Abfrage gegen api.cloudflare.com/client/v4/graphql
AnalyticsTop10IPs(c, zoneId, since): int64 Top-10 angreifende IPs
AnalyticsTop10URLs(c, zoneId, since): int64 Top-10 aufgerufene URLs
AnalyticsFirewallEvents(c, zoneId, since, limit): int64 WAF-Ereignisse
AnalyticsWorkerInvocations(c, accountId, scriptName, since, until): int64 Worker-Aufrufstatistiken
WebAnalyticsSiteCreate(c, accountId, zoneTag): int64 Web Analytics aktivieren
WebAnalyticsSiteList(c, accountId): int64 Alle Web-Analytics-Sites
LogpushJobCreate(c, zoneId, accountId, destination, dataset, fields): int64 Log-Export anlegen
LogpushJobUpdate / LogpushJobDelete Job-Verwaltung

Letzte Aktualisierung: 2026-06-12