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

# Gestionar aplicaciones

> Inspecciona, controla y opera una aplicación a través de la interfaz Applications — estado, logs, métricas, ciclo de vida (iniciar, detener, reiniciar) y eliminación.

Todas las operaciones de esta página viven en el cliente `rest.Rest`:

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

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

## Obtención de una aplicación

`api.GetApplication(appID)` devuelve el 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)
```

### Propiedades de la aplicación

| Campo         | Tipo      | Descripción                                                                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ID`          | `string`  | ID de la aplicación (24 caracteres hex)                                                                                     |
| `Name`        | `string`  | Nombre visible                                                                                                              |
| `Description` | `string`  | Descripción proveniente del archivo de configuración                                                                        |
| `Owner`       | `string`  | ID del usuario propietario                                                                                                  |
| `Cluster`     | `string`  | Cluster en el que corre la app                                                                                              |
| `RAM`         | `int`     | RAM asignada en MB                                                                                                          |
| `Language`    | `string`  | `javascript` \| `typescript` \| `python` \| `java` \| `elixir` \| `go` \| `rust` \| `ruby` \| `php` \| `dotnet` \| `static` |
| `Domain`      | `*string` | Host predeterminado `<subdomain>.squareweb.app` — `nil` para apps que no son web                                            |
| `Custom`      | `*string` | Dominio personalizado vinculado a la app — `nil` cuando no está configurado                                                 |
| `CreatedAt`   | `string`  | Fecha de creación                                                                                                           |

`Domain` y `Custom` son punteros — comprueba siempre que no sean nil antes de desreferenciarlos:

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

## Obtención del estado de la aplicación

`api.GetApplicationStatus(appID)` devuelve el estado de ejecución en vivo con valores **formateados para humanos**.

```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) // totales formateados
fmt.Println(status.Storage) // e.g. "0B"

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

`Uptime` es un `*int64` que contiene el timestamp de inicio en milisegundos Unix — es `nil` cuando la aplicación está detenida.

### Estado en bruto

`api.GetApplicationStatusRaw(appID)` llama al mismo endpoint con `?rawData=true` y devuelve valores **numéricos** en lugar de strings formateados — CPU/RAM como números y la red como pares de bytes `[in, out]`. Úsalo cuando quieras calcular o graficar en lugar de imprimir.

```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] } en bytes
```

<Note>
  El estado formateado es conveniente para mostrar (`"120/512MB"`); el estado en bruto es lo que quieres para dashboards, alertas o cualquier aritmética — convertir strings formateados de vuelta a números es frágil.
</Note>

### Resumen de estado de cada aplicación

Para evitar una solicitud por app, llama a `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)
}
```

Las cifras de CPU y RAM solo están presentes para las aplicaciones que están actualmente en ejecución.

## Obtención de los logs

`api.GetApplicationLogs(appID)` devuelve la salida de log más reciente.

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

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

## Obtención de métricas

`api.GetApplicationMetrics(appID)` devuelve las últimas 24 horas de muestras de CPU, RAM y red (hasta **288 puntos**, uno cada 5 minutos) como un `[]squarecloud.MetricPoint`.

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

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

## Ciclo de vida

`api.PostApplicationSignal(appID, signal)` inicia, detiene o reinicia la aplicación. La señal es una de las constantes `squarecloud.ApplicationSignal*`:

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

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

## Eliminación de una aplicación

<Warning>
  `DeleteApplication` elimina la aplicación de forma permanente. A menos que tengas un [snapshot](/es/sdks/go/snapshots), los datos **no se pueden recuperar**.
</Warning>

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