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

# Réseau et edge

> Gérez les domaines personnalisés, le DNS, les analyses edge, le suivi des erreurs, les logs de requêtes, les percentiles de latence et l'invalidation du cache pour les applications de type site web.

<Note>
  Les endpoints de cette page s'appliquent uniquement aux **applications de type site web** — les applications avec un domaine web. Les appeler sur une application non web échoue.
</Note>

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

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

## Domaine personnalisé

`api.SetApplicationCustomDomain(appID, domain)` définit le domaine personnalisé lié au site web.

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

## Enregistrements DNS

Après avoir attaché un domaine personnalisé, vous devez configurer le DNS chez votre registrar. `api.GetApplicationDNS(appID)` renvoie les enregistrements à créer sous forme de `[]squarecloud.DNSRecord`.

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

for _, record := range records {
	fmt.Printf("%s %s → %s (%s)\n", record.Type, record.Name, record.Value, record.Status)
}
```

| Champ    | Type     | Description                                                                                                                                                        |
| -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `Type`   | `string` | `"txt"` ou `"cname"` — les enregistrements TXT couvrent la validation de propriété et SSL ; le CNAME porte le trafic et pointe toujours vers `cname.squareweb.app` |
| `Name`   | `string` | Nom de l'enregistrement à créer                                                                                                                                    |
| `Value`  | `string` | Valeur de l'enregistrement                                                                                                                                         |
| `Status` | `string` | État de validation : `"pending"`, `"pending_validation"` ou `"active"`                                                                                             |

## Analyses

`api.GetApplicationAnalytics(appID, start, end)` renvoie les analyses edge agrégées pour la fenêtre donnée sous forme de `squarecloud.NetworkAnalytics`. La fenêtre est obligatoire et la rétention maximale est de **7 jours**.

```go theme={null}
end := time.Now()
start := end.Add(-24 * time.Hour)

analytics, err := api.GetApplicationAnalytics("abc123def456abc123def456", start, end)
if err != nil {
	panic(err)
}

fmt.Println(len(analytics.Visits), "time buckets") // séries de 15 minutes
fmt.Println(analytics.Countries)
fmt.Println(analytics.Paths)
```

La réponse contient des séries temporelles de 15 minutes (`Visits`, `Countries`, `Devices`, `OS`, `Browsers`, `Protocols`, `Methods`, `Paths`, `Referers`, `Providers`) et des agrégats sur toute la fenêtre (`IPs`, `StatusCodes`, `Bots`, `ContentTypes`).

<Note>
  Pour une fenêtre entièrement antérieure à la création de l'application, l'API renvoie un objet vide — chaque slice de la réponse est `nil`. Vérifiez les longueurs avant d'indexer.
</Note>

### Filtres d'exploration

Au-delà de la fenêtre, l'endpoint accepte des filtres optionnels sous forme de paramètres de requête — passez-les avec `rest.WithQueryParam`. Chaque filtre restreint d'un coup toutes les ventilations de la réponse :

| Filtre         | Notes                                                         |
| -------------- | ------------------------------------------------------------- |
| `country`      | Code pays à 2 lettres, ex. `"BR"`                             |
| `ip`           | Correspondance exacte d'IP                                    |
| `path`         | Correspondance par préfixe, ex. `"/api"`                      |
| `status`       | Code de statut HTTP, ex. `"404"`                              |
| `os`           | Système d'exploitation                                        |
| `browser`      | Nom du navigateur                                             |
| `protocol`     | Protocole de la requête                                       |
| `referer`      | Utilisez `"Direct"` pour les requêtes sans referer            |
| `provider`     | Fournisseur réseau, ex. `"GOOGLE (15169)"` (ASN)              |
| `content_type` | Utilisez `"Unknown"` pour les types de contenu non classifiés |
| `bot`          | Utilisez `"Unverified"` pour le trafic normal (non bot)       |

```go theme={null}
analytics, err := api.GetApplicationAnalytics(
	"abc123def456abc123def456",
	start, end,
	rest.WithQueryParam("country", "BR"),
	rest.WithQueryParam("status", "404"),
	rest.WithQueryParam("bot", "Unverified"),
)
```

## Suivi des erreurs

`api.GetApplicationNetworkErrors(appID, start, end)` renvoie la ventilation des erreurs edge. Par défaut, seules les erreurs 5xx sont incluses — ajoutez `include_4xx=true` pour inclure les 4xx.

```go theme={null}
errs, err := api.GetApplicationNetworkErrors(
	"abc123def456abc123def456",
	start, end,
	rest.WithQueryParam("include_4xx", "true"),
)
if err != nil {
	panic(err)
}
```

## Logs par requête

`api.GetApplicationNetworkLogs(appID, start, end)` renvoie les logs edge de chaque requête.

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

<Note>
  Les logs par requête nécessitent un [plan Pro](https://squarecloud.app/plans) ou supérieur.
</Note>

## Percentiles de latence

`api.GetApplicationNetworkPerformance(appID, start, end)` renvoie les latences p50 / p95 / p99 pour les couches edge et origine.

```go theme={null}
perf, err := api.GetApplicationNetworkPerformance("abc123def456abc123def456", start, end)
if err != nil {
	panic(err)
}
```

<Note>
  Les métriques de performance nécessitent un [plan Pro](https://squarecloud.app/plans) ou supérieur.
</Note>

## Purger le cache edge

`api.PurgeApplicationCache(appID)` invalide l'intégralité du cache edge pour les domaines de l'application.

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

## Domaines et répartiteurs de charge à l'échelle du compte

Ces deux méthodes opèrent sur toutes les applications du compte plutôt que sur un seul site web.

### Lister tous les domaines

`api.GetApplicationDomains()` renvoie tous les domaines configurés à travers les applications du compte sous forme de `[]squarecloud.AppDomain`. Les domaines personnalisés sont listés en premier ; les applications sans domaine web sont omises.

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

for _, domain := range domains {
	fmt.Println(domain.AppID, domain.Hostname, domain.Type) // "subdomain" | "custom"
}
```

### Répartiteurs de charge

`api.GetLoadBalancers()` regroupe les applications qui partagent un domaine personnalisé, en renvoyant un `squarecloud.LoadBalancers`.

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

fmt.Println("plan limit:", lb.Limit)
for _, balancer := range lb.Balancers {
	fmt.Println(balancer.Hostname, len(balancer.Apps), "apps")
}
```

Un groupe de 2 applications ou plus est un répartiteur de charge actif : le trafic est équilibré à l'edge avec basculement automatique lorsque l'une des applications est hors ligne. `Limit` est le nombre maximal d'applications pouvant partager un même domaine selon le plan du compte : 2 (Standard), 5 (Pro), 10 (Enterprise).