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

# Gerenciando aplicações

> Inspecione, controle e opere uma aplicação através da interface Applications — status, logs, métricas, ciclo de vida (start, stop, restart) e exclusão.

Todas as operações desta página vivem no client `rest.Rest`:

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

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

## Buscando uma aplicação

`api.GetApplication(appID)` retorna o registro completo `squarecloud.Application`.

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

fmt.Println(app.ID, app.Name, app.Cluster, app.CreatedAt)
```

### Propriedades da aplicação

| Campo         | Tipo      | Descrição                                                                                                                   |
| ------------- | --------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ID`          | `string`  | ID da aplicação (24 chars hex)                                                                                              |
| `Name`        | `string`  | Nome de exibição                                                                                                            |
| `Description` | `string`  | Descrição vinda do arquivo de configuração                                                                                  |
| `Owner`       | `string`  | ID do usuário dono                                                                                                          |
| `Cluster`     | `string`  | Cluster onde a aplicação roda                                                                                               |
| `RAM`         | `int`     | RAM alocada em MB                                                                                                           |
| `Language`    | `string`  | `javascript` \| `typescript` \| `python` \| `java` \| `elixir` \| `go` \| `rust` \| `ruby` \| `php` \| `dotnet` \| `static` |
| `Domain`      | `*string` | Host padrão `<subdomain>.squareweb.app` — `nil` para apps não-web                                                           |
| `Custom`      | `*string` | Domínio customizado vinculado à aplicação — `nil` quando não configurado                                                    |
| `CreatedAt`   | `string`  | Data de criação                                                                                                             |

`Domain` e `Custom` são ponteiros — sempre verifique se são `nil` antes de desreferenciar:

```go theme={null}
if app.Domain != nil {
	fmt.Println("rodando em", *app.Domain)
}
```

## Obtendo o status da aplicação

`api.GetApplicationStatus(appID)` retorna o estado de execução em tempo real com valores **formatados para leitura**.

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

fmt.Println(status.Status)  // "running" | "starting" | "restarting" | "exited" | "created" | "deleting"
fmt.Println(status.Running) // bool
fmt.Println(status.CPU)     // "0.50%"
fmt.Println(status.RAM)     // "120/512MB"
fmt.Println(status.Network) // totais formatados
fmt.Println(status.Storage) // ex.: "0B"

if status.Uptime != nil {
	fmt.Println(time.UnixMilli(*status.Uptime)) // iniciada em
}
```

`Uptime` é um `*int64` contendo o timestamp de início em milissegundos Unix — é `nil` quando a aplicação está parada.

### Status bruto

`api.GetApplicationStatusRaw(appID)` chama o mesmo endpoint com `?rawData=true` e retorna valores **numéricos** em vez de strings formatadas — CPU/RAM como números e rede como pares de bytes `[in, out]`. Use quando quiser calcular ou plotar em vez de exibir.

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

fmt.Println(raw.CPU)     // 0.5
fmt.Println(raw.RAM)     // 120
fmt.Println(raw.Network) // { Total: [in, out], Now: [in, out] } em bytes
```

<Note>
  O status formatado é conveniente para exibição (`"120/512MB"`); o status bruto é o que você quer para dashboards, alertas ou qualquer aritmética — converter strings formatadas de volta em números é frágil.
</Note>

### Status resumido para todas as aplicações

Para evitar uma requisição por aplicação, chame `api.GetApplicationListStatus()`:

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

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

Os valores de CPU e RAM só estão presentes para aplicações que estão em execução no momento.

## Obtendo os logs

`api.GetApplicationLogs(appID)` retorna a saída de log mais recente.

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

fmt.Println(logs.Logs) // string
```

## Obtendo métricas

`api.GetApplicationMetrics(appID)` retorna as últimas 24 horas de amostras de CPU, RAM e rede (até **288 pontos**, um a cada 5 minutos) como um `[]squarecloud.MetricPoint`.

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

fmt.Println(len(metrics), "pontos")
for _, point := range metrics {
	fmt.Println(point.Date, point.CPU, point.RAM, point.Net)
}
```

## Ciclo de vida

`api.PostApplicationSignal(appID, signal)` inicia, para ou reinicia a aplicação. O sinal é uma das constantes `squarecloud.ApplicationSignal*`:

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

// squarecloud.ApplicationSignalStop
// squarecloud.ApplicationSignalRestart
```

## Excluindo uma aplicação

<Warning>
  `DeleteApplication` remove a aplicação permanentemente. Sem um [snapshot](/pt-br/sdks/go/snapshots), os dados **não podem ser recuperados**.
</Warning>

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