> ## Documentation Index
> Fetch the complete documentation index at: https://docs.squarecloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Datenbanken

> Stelle Square Cloud-Datenbanken bereit, überwache und verwalte sie, inklusive Rotation von Zugangsdaten und Snapshots.

<Info>
  Datenbanken werden über die in `rest.Rest` eingebettete Schnittstelle `Databases` bereitgestellt. Sie sind in den Plänen **Standard, Pro und Enterprise** verfügbar.
</Info>

```go theme={null}
client := rest.NewClient(os.Getenv("SQUARECLOUD_API_KEY"))
defer client.Close()

api := rest.New(client)
```

## Eine Datenbank erstellen

`api.CreateDatabase(opts)` stellt eine neue Datenbank aus einer `squarecloud.DatabaseCreateOptions` bereit.

```go theme={null}
created, err := api.CreateDatabase(squarecloud.DatabaseCreateOptions{
	Name:    "my-mongo",
	Memory:  1024,
	Type:    squarecloud.DatabaseTypeMongo,
	Version: "8",
})
if err != nil {
	panic(err)
}

fmt.Println(created.ID)
fmt.Println(created.ConnectionURL) // ready to use — password already embedded
fmt.Println(created.Password)      // shown once — store securely
fmt.Println(created.Certificate)   // shown once — only for engines that issue a TLS cert
```

| Feld      | Typ                        | Beschreibung                                                                                                                                    |
| --------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `Name`    | `string`                   | Anzeigename, 1–32 Zeichen                                                                                                                       |
| `Memory`  | `int`                      | Zugewiesener Speicher in MB                                                                                                                     |
| `Type`    | `squarecloud.DatabaseType` | Engine: `DatabaseTypeMongo`, `DatabaseTypeMySQL`, `DatabaseTypeRedis` oder `DatabaseTypePostgres` (Slugs `mongo`, `mysql`, `redis`, `postgres`) |
| `Version` | `string`                   | Engine-Version                                                                                                                                  |

<Warning>
  `Password` (und `Certificate`, sofern zutreffend) erscheinen **nur in der Erstellungsantwort** und können später nicht wiederhergestellt werden — speichere sie jetzt. `ConnectionURL` kommt einsatzbereit mit eingebettetem Passwort.
</Warning>

Ein nicht unterstützter Typ schlägt mit `INVALID_DATABASE_TYPE` fehl; zu wenig Speicher für den Plan schlägt mit `INSUFFICIENT_MEMORY` fehl; ein Fehler während der Bereitstellung schlägt mit `DATABASE_CREATION_FAILED` fehl.

## Deine Datenbanken auflisten

`api.GetDatabases()` listet jede Datenbank, die dir gehört, als kompakte `squarecloud.UserDatabase`-Deskriptoren auf:

```go theme={null}
dbs, err := api.GetDatabases()
if err != nil {
	panic(err)
}

for _, db := range dbs {
	fmt.Printf("%s (%s)\n", db.Name, db.ID)
}
```

## Eine einzelne Datenbank abrufen

```go theme={null}
db, err := api.GetDatabase("abc123def456abc123def456")
if err != nil {
	panic(err)
}

fmt.Println(db.ID, db.Name, db.Type, db.RAM, db.Cluster, db.CreatedAt)
```

## Lebenszyklus

```go theme={null}
err := api.StartDatabase("abc123def456abc123def456")
if err != nil {
	panic(err)
}

err = api.StopDatabase("abc123def456abc123def456")
```

## Status und Metriken

Die Status- und Metrik-Endpoints der Datenbanken teilen dieselben Formen wie die der Anwendungen (es sind Typ-Aliase) — siehe [Anwendungen verwalten](/de/sdks/go/managing_application#den-anwendungsstatus-abrufen) für die Aufschlüsselung Feld für Feld.

```go theme={null}
status, err := api.GetDatabaseStatus("abc123def456abc123def456")
if err != nil {
	panic(err)
}
fmt.Println(status.Status, status.CPU, status.RAM) // formatted strings

raw, err := api.GetDatabaseStatusRaw("abc123def456abc123def456") // numeric values
if err != nil {
	panic(err)
}

metrics, err := api.GetDatabaseMetrics("abc123def456abc123def456")
if err != nil {
	panic(err)
}
fmt.Println(len(metrics), "metric points (up to 288 over 24h)")
```

### Zusammenfassender Status für jede Datenbank

```go theme={null}
list, err := api.GetDatabaseListStatus()
if err != nil {
	panic(err)
}

for _, summary := range list {
	fmt.Printf("%s → running=%v\n", summary.ID, summary.Running)
}
```

## Aktualisieren

`api.UpdateDatabase(dbID, opts)` ändert den Anzeigenamen und/oder die Speicherzuweisung. Mindestens ein Feld muss angegeben werden.

```go theme={null}
err := api.UpdateDatabase("abc123def456abc123def456", squarecloud.DatabaseUpdateOptions{
	Name: "primary-db",
	RAM:  1024,
})
if err != nil {
	panic(err)
}
```

## Zugangsdaten

`api.GetDatabaseCertificate(dbID)` gibt das TLS-Zertifikat zurück (base64-kodiertes PEM):

```go theme={null}
cert, err := api.GetDatabaseCertificate("abc123def456abc123def456")
if err != nil {
	panic(err)
}
fmt.Println("certificate length:", len(cert))
```

`api.ResetDatabaseCredentials(dbID, reset)` rotiert entweder das Passwort oder das Zertifikat, unter Verwendung der `squarecloud.DatabaseReset*`-Konstanten:

```go theme={null}
// Rotate the password — the new value is shown only once
result, err := api.ResetDatabaseCredentials("abc123def456abc123def456", squarecloud.DatabaseResetPassword)
if err != nil {
	panic(err)
}
fmt.Println("new password:", result.Password)

// Rotate the certificate — fetch the new one via GetDatabaseCertificate
_, err = api.ResetDatabaseCredentials("abc123def456abc123def456", squarecloud.DatabaseResetCertificate)
```

<Warning>
  Das neue Passwort wird **nur in der Antwort des Passwort-Resets** zurückgegeben und ein einziges Mal angezeigt — speichere es sofort.
</Warning>

## Snapshots

Datenbank-Snapshots spiegeln die Snapshot-API der Anwendungen wider — siehe [Snapshots](/de/sdks/go/snapshots#datenbank-snapshots).

```go theme={null}
snapshots, err := api.GetDatabaseSnapshots("abc123def456abc123def456")
if err != nil {
	panic(err)
}

created, err := api.CreateDatabaseSnapshot("abc123def456abc123def456")
if err != nil {
	panic(err)
}
fmt.Println("download URL:", created.URL)
```

## Eine Datenbank löschen

<Warning>
  Das Löschen einer Datenbank ist unwiderruflich. Stelle sicher, dass du einen aktuellen [Snapshot](/de/sdks/go/snapshots) hast, falls du die Daten wiederherstellen musst.
</Warning>

```go theme={null}
err := api.DeleteDatabase("abc123def456abc123def456")
if err != nil {
	panic(err)
}
```