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

# Gestire le applicazioni

> Ispeziona, controlla e gestisci un'applicazione tramite l'interfaccia Applications — stato, log, metriche, ciclo di vita (start, stop, restart) ed eliminazione.

Ogni operazione di questa pagina vive sul client `rest.Rest`:

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

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

## Recuperare un'applicazione

`api.GetApplication(appID)` restituisce il record 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)
```

### Proprietà dell'applicazione

| Campo         | Tipo      | Descrizione                                                                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ID`          | `string`  | ID dell'applicazione (24 caratteri esadecimali)                                                                             |
| `Name`        | `string`  | Nome visualizzato                                                                                                           |
| `Description` | `string`  | Descrizione dal file di configurazione                                                                                      |
| `Owner`       | `string`  | ID utente del proprietario                                                                                                  |
| `Cluster`     | `string`  | Cluster su cui gira l'app                                                                                                   |
| `RAM`         | `int`     | RAM allocata in MB                                                                                                          |
| `Language`    | `string`  | `javascript` \| `typescript` \| `python` \| `java` \| `elixir` \| `go` \| `rust` \| `ruby` \| `php` \| `dotnet` \| `static` |
| `Domain`      | `*string` | Host predefinito `<subdomain>.squareweb.app` — `nil` per le app non web                                                     |
| `Custom`      | `*string` | Dominio personalizzato associato all'app — `nil` quando non configurato                                                     |
| `CreatedAt`   | `string`  | Data di creazione                                                                                                           |

`Domain` e `Custom` sono puntatori — verifica sempre che non siano `nil` prima di dereferenziarli:

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

## Ottenere lo stato dell'applicazione

`api.GetApplicationStatus(appID)` restituisce lo stato runtime in tempo reale con valori **formattati per la lettura**.

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

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

`Uptime` è un `*int64` che contiene il timestamp di avvio in millisecondi Unix — è `nil` quando l'applicazione è ferma.

### Stato raw

`api.GetApplicationStatusRaw(appID)` chiama lo stesso endpoint con `?rawData=true` e restituisce valori **numerici** invece di stringhe formattate — CPU/RAM come numeri e la rete come coppie di byte `[in, out]`. Usalo quando vuoi calcolare o tracciare grafici invece di stampare.

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

<Note>
  Lo stato formattato è comodo per la visualizzazione (`"120/512MB"`); lo stato raw è quello che ti serve per dashboard, alert o qualsiasi calcolo — riconvertire in numeri le stringhe formattate è fragile.
</Note>

### Stato riepilogativo di ogni applicazione

Per evitare una richiesta per ogni app, chiama `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)
}
```

I valori di CPU e RAM sono presenti solo per le applicazioni attualmente in esecuzione.

## Ottenere i log

`api.GetApplicationLogs(appID)` restituisce l'output di log più recente.

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

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

## Ottenere le metriche

`api.GetApplicationMetrics(appID)` restituisce le ultime 24 ore di campioni di CPU, RAM e rete (fino a **288 punti**, uno ogni 5 minuti) come `[]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 di vita

`api.PostApplicationSignal(appID, signal)` avvia, ferma o riavvia l'applicazione. Il segnale è una delle costanti `squarecloud.ApplicationSignal*`:

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

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

## Eliminare un'applicazione

<Warning>
  `DeleteApplication` rimuove l'applicazione in modo permanente. A meno che tu non abbia uno [snapshot](/it/sdks/go/snapshots), i dati **non possono essere recuperati**.
</Warning>

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