1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
# Configuration
Ce document décrit le format du fichier de configuration pour Sovrabase. La configuration est stockée dans un fichier TOML (généralement `config.toml`) et contient tous les paramètres nécessaires au fonctionnement de l'application.
## Emplacement du fichier
Le fichier de configuration doit être placé dans le répertoire racine du projet et nommé `config.toml`.
## Structure de la configuration
La configuration est organisée en plusieurs sections pour une meilleure organisation et lisibilité.
### Niveau racine
| Champ | Type | Défaut | Description |
|-------|------|---------|-------------|
| `region` | string | "supabase" | L'identifiant de région pour l'application |
### Section [rpc]
Configuration pour le service RPC (Remote Procedure Call).
| Champ | Type | Description |
|-------|------|-------------|
| `rpc_secret` | string | Clé secrète utilisée pour l'authentification RPC. **Doit être identique sur tous les nœuds du cluster** pour permettre la communication inter-nœuds. |
| `rpc_addr` | string | Adresse réseau et port pour le serveur RPC (ex: "[::]:8080") |
### Section [api]
Configuration pour le service API principal.
| Champ | Type | Description |
|-------|------|-------------|
| `api_addr` | string | Adresse réseau et port pour le serveur API (ex: "0.0.0.0:3000") |
| `api_domain` | string | Nom de domaine pour l'API (ex: "example.com") |
### Section [internal_db]
Configuration pour la base de données interne utilisée par l'application.
| Champ | Type | Description |
|-------|------|-------------|
| `manager` | string | Type de base de données. Valeurs supportées : "postgres", "mysql", "sqlite" |
| `uri` | string | URI de connexion à la base de données. Pour SQLite, utiliser un chemin de fichier (ex: "./database/internal.db") |
### Section [external_db]
Configuration pour les bases de données externes auxquelles l'application peut se connecter.
| Champ | Type | Description |
|-------|------|-------------|
| `manager` | string | Type de base de données. Valeurs supportées : "postgres", "mysql" |
| `uri` | string | URI de connexion à la base de données pour l'utilisateur root. Doit pointer vers l'adresse du serveur de base de données sans spécifier de base de données particulière (ex: "postgres://root:password@localhost:5432/") |
### Section [s3_api]
Configuration pour le service API compatible S3.
| Champ | Type | Description |
|-------|------|-------------|
| `s3_region` | string | Identifiant de région S3 (ex: "garage") |
| `api_bind_addr` | string | Adresse réseau et port pour le serveur API S3 (ex: "[::]:3900") |
| `root_domain` | string | Domaine racine pour les buckets S3 (ex: ".s3.garage") |
### Section [cluster]
Configuration pour le système distribué et multi-nœuds (prise en charge de l'architecture multi-région).
| Champ | Type | Description |
|-------|------|-------------|
| `node_id` | string | Identifiant unique du nœud dans le cluster |
| `is_rpc_server` | bool | Indique si ce nœud agit comme serveur RPC pour les autres nœuds |
| `rpc_servers` | []string | Liste des **adresses réseau** (IP:port ou hostname:port) des serveurs RPC dans le cluster pour la découverte et connexion |
**⚠️ Important** : La clé `rpc_secret` (section [rpc]) doit être **identique sur tous les nœuds** du cluster pour permettre l'authentification mutuelle entre nœuds.
## Exemple de configuration
```toml
region = "supabase"
[rpc]
rpc_secret = "random_secret_12345"
rpc_addr = "0.0.0.0:8080"
[api]
api_addr = "0.0.0.0:3000"
api_domain = "example.com"
[internal_db]
manager = "sqlite"
uri = "./database/internal.db"
[external_db]
manager = "postgres"
uri = "postgres://root:password@localhost:5432/"
[s3_api]
s3_region = "garage"
api_bind_addr = "[::]:3900"
root_domain = ".s3.garage"
[cluster]
node_id = "node-01"
is_rpc_server = true
rpc_servers = ["192.168.1.10:8080"]
```
## Chargement de la configuration
La configuration est chargée en utilisant la fonction `config.LoadConfig()` :
```go
cfg, err := config.LoadConfig("config.toml")
if err != nil {
log.Fatal("Échec du chargement de la configuration:", err)
}
// Accès aux valeurs de configuration
fmt.Println("Adresse RPC:", cfg.RPC.RPCAddr)
fmt.Println("Domaine API:", cfg.API.APIDomain)
fmt.Println("BD interne:", cfg.InternalDB.Manager)
fmt.Println("ID du nœud:", cfg.Cluster.NodeID)
fmt.Println("Serveur RPC:", cfg.Cluster.IsRPCServer)
```
## Bonnes pratiques de déploiement cluster
### Configuration RPC dans un cluster
Pour un déploiement multi-nœuds, assurez-vous que :
- **Clé RPC commune** : Tous les nœuds utilisent la **même valeur** pour `rpc_secret`
- **Serveurs RPC désignés** : Au moins un nœud par région doit avoir `is_rpc_server = true`
- **Liste de découverte** : Tous les nœuds doivent lister les **adresses réseau réelles** (IP:port) des serveurs RPC dans `rpc_servers`
- **IDs uniques** : Chaque nœud doit avoir un `node_id` unique dans le cluster
**Comprendre `rpc_servers`** : Cette liste contient les adresses réseau des nœuds qui agissent comme serveurs RPC. Les clients RPC utilisent cette liste pour découvrir et se connecter aux serveurs disponibles dans le cluster.
**Exemple de configuration cluster** :
```toml
# Nœud 1 (serveur RPC) - Région Europe
[cluster]
node_id = "node-01"
is_rpc_server = true
rpc_servers = ["192.168.1.10:8080"] # Son propre adresse RPC
# Nœud 2 (client RPC) - Région Europe
[cluster]
node_id = "node-02"
is_rpc_server = false
rpc_servers = ["192.168.1.10:8080", "192.168.1.11:8080"] # Liste des serveurs RPC disponibles
# Nœud 3 (serveur RPC) - Région Asie
[cluster]
node_id = "node-03"
is_rpc_server = true
rpc_servers = ["192.168.2.10:8080"] # Son propre adresse RPC
```
## Notes de sécurité
- Stockez le fichier de configuration de manière sécurisée et évitez de commiter les secrets dans le contrôle de version
- Utilisez des valeurs fortes et générées aléatoirement pour `rpc_secret`
- Assurez-vous que les credentials de base de données dans les URI ont les permissions appropriées (accès root pour external_db)
- Envisagez d'utiliser des variables d'environnement ou des systèmes de gestion des secrets pour les valeurs sensibles en production
|
