std.cloud — DigitalOcean-Units

DigitalOcean API v2 Bindings für Lyx: 13 Units für alle DO-Dienste. Die Authentifizierung erfolgt über Bearer-Token (DOCredentials). HTTP-Transport via std.net.https. Keine externe SDK-Abhängigkeit.

→ std.cloud · Standard Library

Units im Überblick

Unit	Import	Beschreibung
`do/credentials`	`import std.cloud.do.credentials;`	Bearer-Token: Laden aus Token, Umgebungsvariable, Datei
`do/transport`	(intern)	HTTP-Client für DO API v2 (DOClient, DOGet/Post/Put/Patch/Delete)
`do/core`	`import std.cloud.do.core;`	Initialisierung und Version
`do/droplets`	`import std.cloud.do.droplets;`	VMs anlegen, starten, stoppen, Aktionen, SSH-Keys
`do/volumes`	`import std.cloud.do.volumes;`	Block-Storage anlegen, anhängen, Snapshots
`do/spaces`	`import std.cloud.do.spaces;`	Objekt-Speicher (S3-kompatibel): Buckets und Objekte
`do/databases`	`import std.cloud.do.databases;`	Managed Databases (PostgreSQL, MySQL, Redis)
`do/kubernetes`	`import std.cloud.do.kubernetes;`	DOKS: Cluster anlegen, Node-Pools, Kubeconfig
`do/apps`	`import std.cloud.do.apps;`	App Platform: Deploy von Quellcode/Container
`do/functions`	`import std.cloud.do.functions;`	Serverless Functions: Namespaces und Functions
`do/networking`	`import std.cloud.do.networking;`	Domains, DNS, Load Balancer, Floating IPs, VPCs, Firewalls
`do/monitoring`	`import std.cloud.do.monitoring;`	Alert Policies, Metriken (CPU, Bandbreite, Disk)
`do/registry`	`import std.cloud.do.registry;`	Container Registry: Repositories, Tags, Garbage Collection

std.cloud.do.credentials

Authentifizierung gegenüber der DigitalOcean API v2.

Funktion	Beschreibung
`DOCredentialsFromToken(token: pchar): DOCredentials`	Direkt aus Bearer-Token-String
`DOCredentialsFromEnv(): DOCredentials`	Aus Umgebungsvariable `DIGITALOCEAN_TOKEN`
`DOCredentialsFromFile(path: pchar): DOCredentials`	Aus Datei (Token als erste Zeile)
`DOCredentialsDefault(): DOCredentials`	Kette: Env → `~/.config/doctl/config.yaml`
`DOConfigLoad(path: pchar): DOCredentials`	Aus doctl-Konfigurationsdatei
`DOConfigSave(creds: DOCredentials, path: pchar): int64`	Token in Datei speichern
`DOTokenIsExpired(creds: DOCredentials): int64`	Prüft Ablaufzeit (1=abgelaufen)
`DOCredentialsFree(creds: DOCredentials)`	Freigibt allokierte Felder

std.cloud.do.droplets

VMs (Droplets) erstellen und verwalten. 43 pub Items.

Typen

Typ	Felder
`DODroplet`	id, name, region, size, imageId, publicIpv4, privateIpv4, status (alle `int64`)
`DOSSHKey`	id, name, fingerprint, publicKey
`DOAction`	id, status, type, completedAt

Funktionen (Auswahl)

Funktion	Beschreibung
`DropletCreateSimple(creds, name, region, size, imageSlug, sshKeyIds, count)`	Einfache Erstellung (gebräuchlichste Operation)
`DropletCreate(creds, name, region, size, imageSlug, sshKeyIds, userData, vpc, tags)`	Vollständige Parametrierung
`DropletDelete(creds, id)`	Droplet löschen
`DropletGet(creds, id): DODroplet`	Einzelnes Droplet abfragen
`DropletList(creds)`	Alle Droplets (JSON)
`DropletListByTag(creds, tag)`	Gefiltert nach Tag
`DropletWait(creds, id, status)`	Polling bis Droplet den gewünschten Status hat
`DropletGetIP(creds, id)`	Öffentliche IPv4-Adresse als `pchar`
`DropletPowerOn / DropletPowerOff / DropletReboot / DropletShutdown`	Power-Aktionen
`DropletAction(creds, id, action)`	Beliebige Aktion (`power_on`, `snapshot`, …)
`DropletActionWait(creds, dropletId, actionId)`	Auf Aktions-Abschluss warten
`SSHKeyCreate / SSHKeyDelete / SSHKeyList / SSHKeyGet`	SSH-Key-Verwaltung

import std.cloud.do.credentials;
import std.cloud.do.droplets;

fn main(): int64 {
    var creds: DOCredentials := DOCredentialsFromEnv();

    var keys: array<int64> := [12345678];
    var d: DODroplet := DropletCreateSimple(creds, "web-01"c, "fra1"c,
                                            "s-1vcpu-1gb"c, "ubuntu-22-04-x64"c,
                                            keys as int64, 1);
    // Warten bis Droplet aktiv ist
    d = DropletWait(creds, d.id, "active"c);
    var ip: int64 := DropletGetIP(creds, d.id);
    Print("Droplet IP: "c); Print(ip as pchar); PrintLn(""c);

    DODropletFree(d);
    DOCredentialsFree(creds);
    return 0;
}

std.cloud.do.volumes

DigitalOcean Block Storage: SSD-Volumes an Droplets anhängen. 21 pub Items.

Funktion	Beschreibung
`VolumeCreate(creds, name, region, sizeGb, desc)`	Volume anlegen
`VolumeDelete(creds, id)`	Volume löschen
`VolumeGet(creds, id): DOVolume`	Volume-Details
`VolumeList(creds)`	Alle Volumes
`VolumeAttach(creds, id, dropletId)`	An Droplet anhängen
`VolumeDetach(creds, id, dropletId)`	Vom Droplet trennen
`VolumeResize(creds, id, newSizeGb)`	Vergrößern
`SnapshotCreate(creds, volumeId, name)`	Snapshot anlegen
`SnapshotDelete(creds, id)`	Snapshot löschen
`SnapshotList(creds, volumeId)`	Snapshots eines Volumes

std.cloud.do.spaces

DigitalOcean Spaces (S3-kompatibler Objekt-Speicher). 17 pub Items.

Funktion	Beschreibung
`SpacesBucketCreate(creds, name, region)`	Bucket anlegen (Regions: `nyc3`, `ams3`, `sgp1`, `fra1`, …)
`SpacesBucketDelete(creds, name, region)`	Bucket löschen
`SpacesBucketList(creds, region)`	Buckets einer Region
`SpacesObjectPut(creds, bucket, region, key, data, dataLen, contentType, acl)`	Objekt aus Speicher hochladen
`SpacesObjectPutFile(creds, bucket, region, key, localPath, contentType, acl)`	Objekt aus Datei hochladen
`SpacesObjectGet(creds, bucket, region, key)`	Objekt-Body abrufen
`SpacesObjectGetFile(creds, bucket, region, key, localPath)`	In Datei speichern
`SpacesObjectDelete(creds, bucket, region, key)`	Objekt löschen
`SpacesObjectList(creds, bucket, region, prefix)`	Objekte auflisten

std.cloud.do.databases

Managed Databases (PostgreSQL, MySQL, Redis, MongoDB). 42 pub Items.

Funktion	Beschreibung
`DatabaseCreate(creds, name, engine, version, region, size, numNodes)`	Cluster erstellen (engine: `pg`/`mysql`/`redis`/`mongodb`)
`DatabaseDelete / DatabaseGet / DatabaseList`	CRUD
`DatabaseResize(creds, id, size, numNodes)`	Cluster skalieren
`DatabaseGetConnection: DODBConnection`	Verbindungsdaten abrufen (Host, Port, User, Password, Uri)
`DatabaseUserCreate / DatabaseUserDelete / DatabaseUserList / DatabaseUserGet`	Benutzer verwalten
`DatabaseDBCreate / DatabaseDBDelete / DatabaseDBList`	Datenbank-Namespaces
`DatabasePoolCreate / DatabasePoolDelete / DatabasePoolList / DatabasePoolGet`	Connection Pools (PgBouncer)
`DatabaseFirewallRuleSet / DatabaseFirewallRuleList`	Eingehende IP-Regeln

std.cloud.do.kubernetes

DigitalOcean Kubernetes (DOKS). 22 pub Items.

Funktion	Beschreibung
`K8sClusterCreate(creds, name, region, version, nodePoolName, nodeSize, nodeCount)`	Cluster anlegen
`K8sClusterDelete / K8sClusterGet / K8sClusterList`	CRUD
`K8sClusterWait(creds, id): DOK8sCluster`	Warten bis Cluster `running` ist
`K8sClusterUpgrade(creds, id, version)`	Kubernetes-Version aktualisieren
`K8sKubeconfig(creds, id)`	Kubeconfig-YAML abrufen (für kubectl)
`K8sNodePoolCreate / K8sNodePoolDelete / K8sNodePoolUpdate`	Node-Pool verwalten
`K8sVersionsList(creds)`	Verfügbare Kubernetes-Versionen

std.cloud.do.apps

DigitalOcean App Platform: Quellcode und Container deployen. 20 pub Items.

Funktion	Beschreibung
`AppCreate(creds, name, region, spec)`	App aus Spec-String erstellen
`AppCreateFromSpec(creds, specJson, specLen): DOApp`	App aus JSON-App-Spec
`AppDelete / AppGet / AppList / AppUpdate`	CRUD
`DeploymentCreate(creds, appId, forceBuild)`	Neues Deployment auslösen
`DeploymentGet / DeploymentList`	Deployment-Status abfragen
`DeploymentWait(creds, appId, deploymentId): DODeployment`	Auf Abschluss warten
`AppGetLogs(creds, appId, deploymentId, component)`	Deployment-Logs
`AppListRegions(creds)`	Verfügbare App-Platform-Regionen

std.cloud.do.functions

Serverless Functions. 17 pub Items.

Funktion	Beschreibung
`NamespaceCreate(creds, region, label): DONamespace`	Namespace anlegen
`NamespaceDelete / NamespaceGet / NamespaceList`	CRUD
`FunctionCreate(creds, namespaceId, name, runtime, source)`	Function anlegen
`FunctionDelete / FunctionGet / FunctionList`	CRUD
`FunctionInvoke(creds, namespaceId, functionName, params)`	Function aufrufen
`FunctionGetLogs(creds, namespaceId, functionName)`	Logs abrufen

std.cloud.do.networking

DNS, Load Balancer, Floating IPs, VPCs, Firewalls. 45 pub Items.

Bereich	Wichtige Funktionen
Domains & DNS	`DomainCreate/Delete/Get/List`, `DomainRecordCreate/Update/Delete/List/Get`
Load Balancer	`LBCreate(creds, name, region, algorithm, forwardingRules, healthCheck)`, `LBDelete/Get/List`, `LBAddDroplets/RemoveDroplets`
Floating IPs	`FloatingIPCreate(creds, region)`, `FloatingIPAssign/Unassign(creds, ip, dropletId)`, `FloatingIPDelete/List`
VPCs	`VPCCreate(creds, name, region, ipRange)`, `VPCDelete/Get/List`, `VPCMemberList`
Firewalls	`FirewallCreate(creds, name, inboundRules, outboundRules)`, `FirewallDelete/Get/List`, `FirewallAddDroplets/RemoveDroplets`

std.cloud.do.monitoring

Alert Policies und Metriken (CPU, Bandbreite, Disk, Speicher). 19 pub Items.

Funktion	Beschreibung
`AlertCreate(creds, type, compare, value, window, entities, tags, emails, slackWebhooks): DOAlert`	Alert Policy anlegen
`AlertDelete / AlertGet / AlertList / AlertUpdate`	Policy-Verwaltung
`MetricDropletCPU(creds, dropletId, startTime, endTime)`	CPU-Auslastungs-Zeitreihe
`MetricDropletBandwidth(creds, dropletId, dir, iface, startTime, endTime)`	Netzwerk-Bandbreite
`MetricDropletDisk(creds, dropletId, startTime, endTime)`	Disk-Nutzung
`MetricDropletMemory(creds, dropletId, startTime, endTime)`	Speicher-Nutzung

std.cloud.do.registry

DigitalOcean Container Registry. 17 pub Items.

Funktion	Beschreibung
`RegistryCreate(creds, name, region, subscriptionTier)`	Registry anlegen (tier: `starter`/`basic`/`professional`)
`RegistryDelete / RegistryGet`	Verwaltung
`RegistrySubscriptionGet(creds)`	Aktuellen Plan abrufen
`RepositoryList / RepositoryDelete`	Repositories in Registry
`RepositoryTagList / RepositoryTagDelete`	Tags in Repository
`RegistryDockerCredentials(creds, readWrite, expirySeconds)`	Docker-Login-Credentials
`RegistryGarbageCollectionRun(creds)`	Unreferenzierte Blobs bereinigen

Letzte Aktualisierung: 2026-06-12