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

# SDK Go: bancos de dados gerenciados

> Crie, inspecione, atualize, inicie, pare e exclua bancos de dados gerenciados, leia seu status e suas métricas e gerencie suas credenciais com c.Databases.

`c.Databases` gerencia os bancos de dados gerenciados da Square Cloud (MongoDB, MySQL, PostgreSQL e Redis). Todo método recebe o `ctx` primeiro e, exceto `Create` e `StatusAll`, o id do banco de dados em seguida. Para listar seus bancos de dados, use [`c.Account.Me`](/pt-br/sdks/go/client#conta): seu slice `Databases` contém todos os bancos de dados que a chave pode ver.

A hospedagem de bancos de dados requer um plano Standard, Pro ou Enterprise.

Cada trecho abaixo roda sozinho dentro deste programa: cole um de cada vez em `main` e execute o `goimports` (veja [Executando os exemplos](/pt-br/sdks/go/client#executando-os-exemplos)).

```go theme={"system"}
package main

import (
	"context"
	"os"

	"github.com/squarecloudofc/sdk-api-go/v3"
)

var (
	ctx        = context.Background()
	c          = squarecloud.New(os.Getenv("SQUARECLOUD_API_KEY"))
	databaseID = "abc123def456abc123def456"
)

func main() {
	// Paste one snippet here, then run goimports.
}
```

## Criando um banco de dados

```go theme={"system"}
db, err := c.Databases.Create(ctx, squarecloud.DatabaseCreate{
	Name:    "my-db",
	Type:    squarecloud.DatabasePostgres, // DatabaseMongo, DatabaseMySQL, DatabaseRedis, DatabasePostgres
	Version: "17",                         // a full version or a prefix
	Memory:  1024,                         // MB
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(db.ID, db.ConnectionURL, db.Cluster)
fmt.Println(db.Password) // shown only here: save it
if db.Certificate != nil {
	fmt.Println(*db.Certificate) // base64 PEM (private key, then certificate)
}
```

| Campo | Descrição |
| - | - |
| `Name` (`name`) | De 1 a 32 caracteres |
| `Type` (`type`) | `DatabaseMongo`, `DatabaseMySQL`, `DatabaseRedis` ou `DatabasePostgres` (`mongo`, `mysql`, `redis`, `postgres`) |
| `Version` (`version`) | Uma versão completa ou um prefixo como `"8"` |
| `Memory` (`memory`) | MB, um `int`. Pelo menos 512 para Redis e 1024 para os demais |

O resultado é um `DatabaseCreated` com `ID`, `Name`, `Memory`, `CPU` (`float64`), `Type`, `Password`, `Certificate` (`*string`, `nil` quando a API não envia nenhum), `ConnectionURL` (`connection_url`) e `Cluster`. A senha e o certificado são retornados apenas por `Create` (e por [`ResetCredentials`](#credenciais)). Sem um prazo no `ctx`, a chamada espera pelo menos 2 minutos antes de expirar.

| Status | Código | Quando |
| - | - | - |
| 400 | `INVALID_NAME` | O nome não tem de 1 a 32 caracteres |
| 400 | `INVALID_DATABASE_TYPE`, `INVALID_DATABASE_VERSION` | Tipo desconhecido ou versão não suportada |
| 400 | `INVALID_MEMORY` | `memory` não é um número inteiro (uma fração ou uma string). `Memory` é um `int`, então o SDK Go nunca envia um valor assim |
| 400 | `INSUFFICIENT_MEMORY` | `Memory` está abaixo do mínimo da engine ou excede a memória disponível |
| 400 | `CLUSTER_SELECTION_FAILED` | Nenhum cluster tinha capacidade suficiente |
| 400 / 500 | `DATABASE_CREATION_FAILED` | O provisionamento falhou |
| 403 | `UPGRADE_REQUIRED` | O plano não inclui hospedagem de bancos de dados |
| 503 | `CLUSTER_MAINTENANCE_TRY_LATER` | O provisionamento está pausado para manutenção |

## Obtendo um banco de dados

```go theme={"system"}
db, err := c.Databases.Get(ctx, databaseID)
if err != nil {
	log.Fatal(err)
}

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

## Atualizando um banco de dados

`Update(ctx, databaseID, squarecloud.DatabaseUpdate{Name, RAM})` renomeia ou redimensiona um banco de dados. Campos com valor zero não são enviados; defina pelo menos um (caso contrário, 400 `NO_UPDATE_DATA`).

```go theme={"system"}
if err := c.Databases.Update(ctx, databaseID, squarecloud.DatabaseUpdate{Name: "orders", RAM: 2048}); err != nil {
	log.Fatal(err)
}
```

## Iniciar e parar

```go theme={"system"}
if err := c.Databases.Start(ctx, databaseID); err != nil {
	log.Fatal(err)
}
if err := c.Databases.Stop(ctx, databaseID); err != nil {
	log.Fatal(err)
}
```

Assim como as chamadas de ciclo de vida das aplicações, sem um prazo no `ctx` elas esperam pelo menos 2 minutos, e uma recusa resulta em **409** com um código e uma mensagem vazia: `CONTAINER_ALREADY_STARTED`, `CONTAINER_ALREADY_STOPPED`, `CONTAINER_NOT_FOUND`, `CONTAINER_INSUFFICIENT_DISK_SPACE`, `CONTAINER_NETWORK_CONFLICT` ou `ACTION_FAILED`. Enquanto uma restauração de snapshot está em andamento, elas resultam em 403 `RESTORE_IN_PROGRESS`.

## Status e métricas

`Status(ctx, databaseID)` retorna valores formatados; `StatusRaw(ctx, databaseID)` retorna números. `StatusAll(ctx)` retorna um resumo por banco de dados. `Metrics(ctx, databaseID)` retorna as últimas 24 horas, um ponto a cada 5 minutos, do mais recente para o mais antigo.

```go theme={"system"}
status, err := c.Databases.Status(ctx, databaseID)
if err != nil {
	log.Fatal(err)
}
fmt.Println(status.Running, status.CPU, status.RAM) // true "0.5%" "120.4MB"

raw, err := c.Databases.StatusRaw(ctx, databaseID)
if err != nil {
	log.Fatal(err)
}
fmt.Println(raw.CPU, raw.RAM) // 0.5 120.4

items, err := c.Databases.StatusAll(ctx)
if err != nil {
	log.Fatal(err)
}
for _, it := range items {
	fmt.Println(it.ID, it.Running, it.CPU, it.RAM) // CPU and RAM only while running
}

points, err := c.Databases.Metrics(ctx, databaseID)
if err != nil {
	log.Fatal(err)
}
if len(points) > 0 {
	fmt.Println(points[0].Date, points[0].CPU, points[0].RAM)
}
```

Os campos de status são os mesmos do [status de aplicações](/pt-br/sdks/go/managing_application#status).

## Credenciais

`Certificate(ctx, databaseID)` retorna o certificado TLS como PEM codificado em base64. `ResetCredentials(ctx, databaseID, reset)` rotaciona a senha (`squarecloud.ResetPassword`, retorna a nova) ou o certificado (`squarecloud.ResetCertificate`, retorna `""`). O banco de dados precisa estar em execução (400 `DATABASE_NOT_RUNNING`).

```go theme={"system"}
certificate, err := c.Databases.Certificate(ctx, databaseID)
if err != nil {
	log.Fatal(err)
}
pem, err := base64.StdEncoding.DecodeString(certificate)
if err != nil {
	log.Fatal(err)
}
if err := os.WriteFile("database.pem", pem, 0o600); err != nil {
	log.Fatal(err)
}
```

```go theme={"system"}
password, err := c.Databases.ResetCredentials(ctx, databaseID, squarecloud.ResetPassword)
if err != nil {
	log.Fatal(err)
}
fmt.Println(password) // the new password: save it

if _, err := c.Databases.ResetCredentials(ctx, databaseID, squarecloud.ResetCertificate); err != nil {
	log.Fatal(err)
}
```

## Excluindo um banco de dados

```go theme={"system"}
if err := c.Databases.Delete(ctx, databaseID); err != nil {
	log.Fatal(err)
}
```

<Warning>
  A exclusão é permanente. Crie um [snapshot](/pt-br/sdks/go/snapshots) antes, caso você possa precisar dos dados novamente.
</Warning>

## Snapshots

`c.Databases.Snapshots` tem os mesmos `List`, `Create` e `Restore` das aplicações. Veja [Snapshots](/pt-br/sdks/go/snapshots).

## Próximos passos

<CardGroup cols={3}>
  <Card title="Workspaces" icon="users" href="/pt-br/sdks/go/workspaces">
    Compartilhe aplicações com sua equipe.
  </Card>

  <Card title="Referência da API de bancos de dados" icon="code" href="/pt-br/api-reference/endpoint/databases/create">
    Os endpoints REST por trás destes métodos.
  </Card>

  <Card title="Bancos de dados pela CLI" icon="terminal" href="/pt-br/cli-reference/databases">
    As mesmas ações pelo terminal.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.