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

# Gestion des applications

> Inspectez, contrôlez et opérez une application via l'interface Applications — statut, logs, métriques, cycle de vie (démarrage, arrêt, redémarrage) et suppression.

Chaque opération de cette page vit sur le client `rest.Rest` :

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

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

## Récupérer une application

`api.GetApplication(appID)` renvoie l'enregistrement complet `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)
```

### Propriétés de l'application

| Champ         | Type      | Description                                                                                                                 |
| ------------- | --------- | --------------------------------------------------------------------------------------------------------------------------- |
| `ID`          | `string`  | ID de l'application (24 caractères hexadécimaux)                                                                            |
| `Name`        | `string`  | Nom d'affichage                                                                                                             |
| `Description` | `string`  | Description issue du fichier de configuration                                                                               |
| `Owner`       | `string`  | ID de l'utilisateur propriétaire                                                                                            |
| `Cluster`     | `string`  | Cluster sur lequel l'application s'exécute                                                                                  |
| `RAM`         | `int`     | RAM allouée en Mo                                                                                                           |
| `Language`    | `string`  | `javascript` \| `typescript` \| `python` \| `java` \| `elixir` \| `go` \| `rust` \| `ruby` \| `php` \| `dotnet` \| `static` |
| `Domain`      | `*string` | Hôte par défaut `<subdomain>.squareweb.app` — `nil` pour les applications non web                                           |
| `Custom`      | `*string` | Domaine personnalisé lié à l'application — `nil` lorsqu'il n'est pas configuré                                              |
| `CreatedAt`   | `string`  | Date de création                                                                                                            |

`Domain` et `Custom` sont des pointeurs — vérifiez toujours qu'ils ne sont pas `nil` avant de les déréférencer :

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

## Obtenir le statut de l'application

`api.GetApplicationStatus(appID)` renvoie l'état d'exécution en direct avec des valeurs **formatées pour l'affichage**.

```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) // totaux formatés
fmt.Println(status.Storage) // e.g. "0B"

if status.Uptime != nil {
	fmt.Println(time.UnixMilli(*status.Uptime)) // démarrée à
}
```

`Uptime` est un `*int64` contenant l'horodatage de démarrage en millisecondes Unix — il vaut `nil` lorsque l'application est arrêtée.

### Statut brut

`api.GetApplicationStatusRaw(appID)` appelle le même endpoint avec `?rawData=true` et renvoie des valeurs **numériques** au lieu de chaînes formatées — CPU/RAM sous forme de nombres et le réseau sous forme de paires d'octets `[in, out]`. Utilisez-le lorsque vous voulez calculer ou tracer plutôt qu'afficher.

```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 octets
```

<Note>
  Le statut formaté est pratique pour l'affichage (`"120/512MB"`) ; le statut brut est ce qu'il vous faut pour les tableaux de bord, les alertes ou tout calcul — reconvertir des chaînes formatées en nombres est fragile.
</Note>

### Statut résumé de chaque application

Pour éviter une requête par application, appelez `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)
}
```

Les valeurs de CPU et de RAM ne sont présentes que pour les applications en cours d'exécution.

## Obtenir les logs

`api.GetApplicationLogs(appID)` renvoie la sortie de logs la plus récente.

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

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

## Obtenir les métriques

`api.GetApplicationMetrics(appID)` renvoie les dernières 24 heures d'échantillons de CPU, RAM et réseau (jusqu'à **288 points**, un toutes les 5 minutes) sous forme de `[]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)
}
```

## Cycle de vie

`api.PostApplicationSignal(appID, signal)` démarre, arrête ou redémarre l'application. Le signal est l'une des constantes `squarecloud.ApplicationSignal*` :

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

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

## Supprimer une application

<Warning>
  `DeleteApplication` supprime définitivement l'application. À moins d'avoir un [snapshot](/fr/sdks/go/snapshots), les données **ne peuvent pas être récupérées**.
</Warning>

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