====== 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.

→ [[lyx_-_programmiersprache:units:cloud|std.cloud]] · [[lyx_-_programmiersprache:units|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 |

<code lyx>
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;
}
</code>

**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 |

<code lyx>
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;
}
</code>

----

===== 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(c): 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 |

<code lyx>
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;
}
</code>

----

===== 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