ramdb2-cli 2.0.0-alpha.1 → 2.0.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,18 @@
1
1
  # ramdb2-cli
2
2
 
3
+ ## 2.0.0-alpha.3
4
+
5
+ ### Minor Changes
6
+
7
+ - 92570bd: `ramdb2-cli infra down <server>`: stops a server (docker compose down), keeps its volumes; asks first, unless `--yes`.
8
+
9
+ ## 2.0.0-alpha.2
10
+
11
+ ### Minor Changes
12
+
13
+ - 989ba8b: `ramdb2-cli infra deploy <server>`: build, secrets decrypted by sops, `docker compose up` on the server through `DOCKER_HOST`, Let's Encrypt certificates, nginx reloaded.
14
+ - ee78e45: `ramdb2-cli infra keygen`, `infra backups`, `infra restore` and `infra fetch`: the backup key of a server, encrypted by sops; the backups of a site listed, restored or fetched through its server.
15
+
3
16
  ## 2.0.0-alpha.1
4
17
 
5
18
  ### Minor Changes
package/README.md CHANGED
@@ -414,6 +414,126 @@ All the errors of `infra.yaml` are reported at once. `build/<server>/` holds:
414
414
  - The healthcheck of the API sends the GraphQL query `health`: keep it open without a login.
415
415
  - Until a certificate exists, nginx serves a self-signed one, so that it can start.
416
416
 
417
+ ### Deploy
418
+
419
+ ```sh
420
+ ramdb2-cli infra deploy ovh1 # build, then up on the server, then the certificates
421
+ ramdb2-cli infra deploy ovh1 --staging # with the test certificates of Let's Encrypt
422
+ ```
423
+
424
+ The secrets live in the infra folder, encrypted by [sops](https://github.com/getsops/sops) (with
425
+ [age](https://github.com/FiloSottile/age) keys listed in `.sops.yaml`):
426
+
427
+ | File | Content |
428
+ |---|---|
429
+ | `secrets/<site>.env` | the environment of the API of a site (`TOKEN_SECRET`…) |
430
+ | `secrets/<server>.key` | the private SSH key of the server, for its backups |
431
+
432
+ `deploy` needs `docker`, `sops` and an SSH access to the server on your machine. It:
433
+
434
+ 1. runs `build` for the server;
435
+ 2. decrypts the secrets into a private temporary folder, deleted at the end;
436
+ 3. runs `docker compose up -d --build --remove-orphans` with `DOCKER_HOST` set to the `host` of the server: the
437
+ images are built on the server;
438
+ 4. asks Let's Encrypt for each certificate (nothing is done while a certificate is valid; it is made again when
439
+ its domains change), then reloads nginx.
440
+
441
+ It stops before Docker when a secret is missing or cannot be decrypted. A refused certificate (a domain that does
442
+ not point to the server yet) does not stop the others; the exit code is then 1.
443
+
444
+ The decrypted secrets live in `build/<server>/.secrets-*` (only you can read it) while a command runs, and are
445
+ deleted at the end, even on an error. Not in `/tmp`: Docker installed as a snap cannot read it.
446
+
447
+ ### Stop a server
448
+
449
+ ```sh
450
+ ramdb2-cli infra down ovh1 # asks first; --yes to skip the question
451
+ ```
452
+
453
+ `down` runs `docker compose down --remove-orphans` on the server: the containers of all its sites (ramdb2 and
454
+ custom) and its network are removed. The volumes (the databases, the backup queues), the images and the
455
+ certificates stay: `ramdb2-cli infra deploy ovh1` starts the server again as it was. Like every command that talks
456
+ to a server, it decrypts the secrets: Compose needs them to read `compose.yaml`.
457
+
458
+ ### Secrets: sops and age, once
459
+
460
+ ```sh
461
+ age-keygen -o ~/.config/sops/age/keys.txt # your age key, where sops looks for it
462
+ age-keygen -y ~/.config/sops/age/keys.txt # its public key, for .sops.yaml
463
+ ```
464
+
465
+ `.sops.yaml`, at the root of the infra folder:
466
+
467
+ ```yaml
468
+ creation_rules:
469
+ - path_regex: secrets/.*
470
+ age: age1...your public key...
471
+ ```
472
+
473
+ Keep a copy of your age key somewhere safe (a password manager): without it, no secret can be decrypted, and no
474
+ server can be deployed. Then the secrets of a site:
475
+
476
+ ```sh
477
+ sops secrets/ilife.env # opens your editor; saved encrypted. TOKEN_SECRET=..., one variable per line
478
+ ```
479
+
480
+ ### The backup key of a server
481
+
482
+ ```sh
483
+ ramdb2-cli infra keygen ovh1
484
+ ```
485
+
486
+ Creates an SSH key for the backups of the server: `secrets/ovh1.key`, encrypted by sops, and `secrets/ovh1.pub`.
487
+ It prints the line to add to `~backup/.ssh/authorized_keys` on the backup server:
488
+ `restrict ssh-ed25519 AAAA... ramdb2-backup-ovh1`. An existing key is replaced only with `--force`; install the
489
+ new public key then, and deploy again.
490
+
491
+ ### The backup server
492
+
493
+ Any OpenSSH server. A user `backup`, which can only use SFTP, locked in the backup folder, with keys only. In
494
+ `/etc/ssh/sshd_config`:
495
+
496
+ ```
497
+ PasswordAuthentication no
498
+ KbdInteractiveAuthentication no
499
+ Subsystem sftp internal-sftp
500
+
501
+ Match User backup
502
+ ChrootDirectory /volume1/backup
503
+ ForceCommand internal-sftp
504
+ AllowTcpForwarding no
505
+ X11Forwarding no
506
+ ```
507
+
508
+ - The chroot folder (`/volume1/backup`) belongs to root and only root can write it (an OpenSSH rule); the folder
509
+ of the backups inside it (`ramdb2`) belongs to `backup`.
510
+ - `backup.target` in `infra.yaml` is then `sftp://backup@host:22/ramdb2`: the path is seen from the chroot.
511
+ - Each server key sees the backups of every site: a site can move to another server and keep its backups.
512
+ - The first connection of a server accepts the host key of the backup server, then checks it.
513
+
514
+ ### Backups and restore
515
+
516
+ Each ramdb2 site has its backup container: a compressed image of the database every 5 minutes, sent to the
517
+ backup server, then pruned there (every backup of the last 24 hours, the last of each day for 30 days, the last of
518
+ each month forever). See [`ramdb2-server-backup`](https://www.npmjs.com/package/ramdb2-server). From your machine:
519
+
520
+ ```sh
521
+ ramdb2-cli infra backups ilife # the backups of the site, oldest first
522
+ ramdb2-cli infra restore ilife # the most recent backup
523
+ ramdb2-cli infra restore ilife 2026-11-06T14:00 # the last one at or before that moment (UTC)
524
+ ramdb2-cli infra fetch ilife ilife.db # the most recent backup, to a local file
525
+ ramdb2-cli infra fetch ilife ilife.db 2026-11-06T14:00
526
+ ```
527
+
528
+ - The server of a site is read in `infra.yaml`. The commands run on it, in the backup container of the site, with
529
+ the key of the server: your machine needs no access to the backup server.
530
+ - `restore` asks first (`--yes` to skip the question). It stops the API and the backups of the site, checks the
531
+ backup (`PRAGMA integrity_check`), replaces the database, then starts them again; when the backup is damaged,
532
+ the database is left as it was and the site starts again.
533
+ - A new server: install Docker, `ramdb2-cli infra deploy <server>`, then `ramdb2-cli infra restore <site>` for each
534
+ site.
535
+ - `fetch` writes a database you can open with any SQLite tool, or use as `DB_PATH` of the project on your machine.
536
+
417
537
  ---
418
538
 
419
539
  ## Programmatic use
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "ramdb2-cli",
3
- "version": "2.0.0-alpha.1",
3
+ "version": "2.0.0-alpha.3",
4
4
  "description": "Code generator and project scaffolding for ramdb2 and ramdb2-server",
5
5
  "type": "module",
6
6
  "exports": "./src/index.js",
@@ -28,7 +28,7 @@
28
28
  },
29
29
  "devDependencies": {
30
30
  "@vitejs/plugin-vue": "^6.0.10",
31
- "ramdb2-core": "^2.0.0-alpha.1",
31
+ "ramdb2-core": "^2.0.0-alpha.3",
32
32
  "vite": "^8.3.5",
33
33
  "vue": "^3.5.44",
34
34
  "vue-router": "^5.4.0"
package/src/cli.js CHANGED
@@ -8,6 +8,11 @@ import { plantuml } from './plantuml.js'
8
8
  import { query } from './query.js'
9
9
  import { readInfra } from './infra/config.js'
10
10
  import { buildInfra } from './infra/build.js'
11
+ import { deploy } from './infra/deploy.js'
12
+ import { down } from './infra/down.js'
13
+ import { keygen } from './infra/keygen.js'
14
+ import { fetch as fetchBackup, listBackups, restore } from './infra/backups.js'
15
+ import { createInterface } from 'node:readline/promises'
11
16
 
12
17
  const HELP = `ramdb2-cli: code generator of ramdb2
13
18
 
@@ -41,17 +46,41 @@ const HELP = `ramdb2-cli: code generator of ramdb2
41
46
  Writes build/<server>/ next to infra.yaml (all the servers by default): compose.yaml, the front nginx,
42
47
  the Dockerfiles of each site. Generated, rewritten each time: keep build/ out of git.
43
48
 
49
+ ramdb2-cli infra deploy <server> [--staging] [--config <infra.yaml>]
50
+ build, then the secrets decrypted by sops (secrets/<site>.env, secrets/<server>.key), docker compose up
51
+ on the server (DOCKER_HOST=ssh://...), the missing Let's Encrypt certificates, and nginx reloaded.
52
+ --staging: the test certificates of Let's Encrypt, not trusted by browsers.
53
+
54
+ ramdb2-cli infra down <server> [--yes]
55
+ Stops the server: docker compose down, its containers and its network removed. The volumes (the
56
+ databases), the images and the certificates stay: infra deploy starts it again. Asks first, unless --yes.
57
+
58
+ ramdb2-cli infra keygen <server> [--force]
59
+ Creates the SSH key of the server for its backups: secrets/<server>.key, encrypted by sops (.sops.yaml),
60
+ and secrets/<server>.pub, printed, to install on the backup server. --force replaces an existing key.
61
+
62
+ ramdb2-cli infra backups <site>
63
+ The backups of the site, oldest first, listed by its server.
64
+
65
+ ramdb2-cli infra restore <site> [<moment>] [--yes]
66
+ Stops the API and the backups of the site, restores the last backup at or before moment (UTC, e.g.
67
+ 2026-11-06T14:00; the most recent by default), checks it, starts them again. Asks first, unless --yes.
68
+
69
+ ramdb2-cli infra fetch <site> <file> [<moment>]
70
+ Writes the backup (the most recent, or the last at or before moment) to a local file, decompressed.
71
+
44
72
  ramdb2-cli convert --input <v1 preTypeDefs> --output <v2 preTypeDefs> [--force]
45
73
  Converts the v1 annotations ([PERSISTENT], [GROUP=], [FIELD=]) into directives, in a new file.
46
74
  `
47
75
 
48
76
  const commands = {
49
- infra(values, [action, ...servers]) {
50
- if (action !== 'build') return usage('infra needs an action: build')
51
- const infra = readInfra(values.config ?? 'infra.yaml')
52
- for (const { server, files } of buildInfra(infra, servers)) {
53
- console.log(`${server}: ${files.length} files`)
54
- for (const path of files) console.log(`written ${path}`)
77
+ async infra(values, args) {
78
+ // The infra commands fail with messages for the user: no stack trace
79
+ try {
80
+ await infra(values, args)
81
+ } catch (error) {
82
+ console.error(error.message)
83
+ process.exitCode = 1
55
84
  }
56
85
  },
57
86
  new(values, [dir]) {
@@ -104,6 +133,71 @@ function report({ written, kept, warnings }) {
104
133
  for (const warning of warnings) console.log(`warning ${warning}`)
105
134
  }
106
135
 
136
+ async function infra(values, [action, ...args]) {
137
+ const actions = ['build', 'deploy', 'down', 'keygen', 'backups', 'restore', 'fetch']
138
+ if (!actions.includes(action)) return usage(`infra needs an action: ${actions.join(', ')}`)
139
+ const infra = readInfra(values.config ?? 'infra.yaml')
140
+ switch (action) {
141
+ case 'build':
142
+ for (const { server, files } of buildInfra(infra, args)) {
143
+ console.log(`${server}: ${files.length} files`)
144
+ for (const path of files) console.log(`written ${path}`)
145
+ }
146
+ return
147
+ case 'deploy': {
148
+ if (args.length !== 1) return usage('infra deploy needs one server')
149
+ const { certificates } = await deploy(infra, args[0], { staging: values.staging ?? false })
150
+ if (certificates.some(certificate => !certificate.ok)) process.exitCode = 1
151
+ return
152
+ }
153
+ case 'down':
154
+ if (args.length !== 1) return usage('infra down needs one server')
155
+ if (!infra.servers.some(server => server.name === args[0])) throw new Error(`No server ${args[0]} in infra.yaml`)
156
+ if (!values.yes && !(await confirm(`Stop all the sites of ${args[0]}? Their data stays. [y/N] `))) {
157
+ console.log('Nothing done')
158
+ return
159
+ }
160
+ await down(infra, args[0])
161
+ return
162
+ case 'keygen':
163
+ if (args.length !== 1) return usage('infra keygen needs one server')
164
+ await keygen(infra, args[0], { force: values.force ?? false })
165
+ return
166
+ case 'backups':
167
+ if (args.length !== 1) return usage('infra backups needs one site')
168
+ for (const name of await listBackups(infra, args[0])) console.log(name)
169
+ return
170
+ case 'restore': {
171
+ const [site, moment] = args
172
+ if (site === undefined || args.length > 2) return usage('infra restore needs a site, and maybe a moment')
173
+ const what = `the database of ${site} by its backup ${moment === undefined ? 'the most recent' : `at or before ${moment} (UTC)`}`
174
+ if (!values.yes && !(await confirm(`Replace ${what}? The site stops meanwhile. [y/N] `))) {
175
+ console.log('Nothing done')
176
+ return
177
+ }
178
+ await restore(infra, site, { moment })
179
+ return
180
+ }
181
+ case 'fetch': {
182
+ const [site, file, moment] = args
183
+ if (site === undefined || file === undefined || args.length > 3) return usage('infra fetch needs a site and a file')
184
+ await fetchBackup(infra, site, file, { moment })
185
+ console.log(`written ${file}`)
186
+ return
187
+ }
188
+ }
189
+ }
190
+
191
+ async function confirm(question) {
192
+ if (!process.stdin.isTTY) throw new Error('Not a terminal: add --yes to confirm')
193
+ const terminal = createInterface({ input: process.stdin, output: process.stdout })
194
+ try {
195
+ return /^(y|yes|o|oui)$/i.test((await terminal.question(question)).trim())
196
+ } finally {
197
+ terminal.close()
198
+ }
199
+ }
200
+
107
201
  function usage(message) {
108
202
  console.error(`${message}\n\n${HELP}`)
109
203
  process.exitCode = 1
@@ -122,6 +216,8 @@ const { values, positionals } = parseArgs({
122
216
  variables: { type: 'string' },
123
217
  file: { type: 'string' },
124
218
  config: { type: 'string' },
219
+ staging: { type: 'boolean' },
220
+ yes: { type: 'boolean', short: 'y' },
125
221
  help: { type: 'boolean', short: 'h' },
126
222
  },
127
223
  })
@@ -133,7 +229,7 @@ if (values.help || command === undefined) {
133
229
  try {
134
230
  await command(values, positionals.slice(1))
135
231
  } catch (error) {
136
- console.error(['SchemaError', 'InfraError'].includes(error.name) || error.message.startsWith('No profile') ? error.message : error)
232
+ console.error(['SchemaError', 'InfraError'].includes(error.name) || error.message.startsWith('No profile') ? error.message : error)
137
233
  process.exitCode = 1
138
234
  }
139
235
  }
package/src/index.js CHANGED
@@ -8,3 +8,7 @@ export { DIRECTIVES } from './directives.js'
8
8
  export { operationNames } from './generate/operations.js'
9
9
  export { readInfra, InfraError } from './infra/config.js'
10
10
  export { buildInfra, serverFiles, certificates } from './infra/build.js'
11
+ export { deploy } from './infra/deploy.js'
12
+ export { down } from './infra/down.js'
13
+ export { keygen } from './infra/keygen.js'
14
+ export { listBackups, restore, fetch as fetchBackup } from './infra/backups.js'
@@ -0,0 +1,77 @@
1
+ // ramdb2-cli infra backups, restore and fetch (D56), from the deployment machine: ramdb2-server-backup run in the
2
+ // backup container of the site, on its server (DOCKER_HOST), with the key of the server. The deployment machine
3
+ // needs no access to the backup server.
4
+ import { renameSync, rmSync } from 'node:fs'
5
+ import { check, runCommand, serverOf, withServer } from './server.js'
6
+
7
+ const BACKUP = '/app/node_modules/.bin/ramdb2-server-backup'
8
+
9
+ /**
10
+ * The backups of a site, oldest first.
11
+ * @param {import('./config.js').Infra} infra
12
+ * @param {string} site
13
+ * @param {{run?: import('./server.js').Runner}} [options]
14
+ * @returns {Promise<string[]>}
15
+ */
16
+ export async function listBackups(infra, site, { run = runCommand } = {}) {
17
+ return withServer(infra, serverOf(infra, site), run, async ({ compose, env }) => {
18
+ const result = await run('docker', [...compose, 'run', '--rm', '--no-deps', '-T', '-e', 'LOG_LEVEL=warn',
19
+ `${site}-backup`, BACKUP, 'list'], { env, capture: true })
20
+ if (result.code !== 0) throw new Error(`The backups of ${site} could not be listed: ${result.stderr.trim()}`)
21
+ return result.stdout.split('\n').filter(line => line !== '')
22
+ })
23
+ }
24
+
25
+ /**
26
+ * Restores the last backup of a site at or before `moment` (UTC; the last one by default): stops its API and its
27
+ * backups, restores, starts them again, even when the restore failed (the database is then unchanged).
28
+ * @param {import('./config.js').Infra} infra
29
+ * @param {string} site
30
+ * @param {object} [options]
31
+ * @param {string} [options.moment]
32
+ * @param {import('./server.js').Runner} [options.run]
33
+ * @param {(line: string) => void} [options.print]
34
+ */
35
+ export async function restore(infra, site, { moment, run = runCommand, print = console.log } = {}) {
36
+ const server = serverOf(infra, site)
37
+ return withServer(infra, server, run, async ({ compose, env }) => {
38
+ const services = [`${site}-api`, `${site}-backup`]
39
+ print(`${site}: stopping ${services.join(', ')} on ${server}`)
40
+ await check(run('docker', [...compose, 'stop', ...services], { env }), 'docker compose stop')
41
+ let restored
42
+ try {
43
+ restored = await run('docker', [...compose, 'run', '--rm', '--no-deps', '-T', `${site}-backup`, BACKUP, 'restore',
44
+ ...(moment === undefined ? [] : [moment])], { env })
45
+ } finally {
46
+ print(`${site}: starting ${services.join(', ')}`)
47
+ await check(run('docker', [...compose, 'start', ...services], { env }), 'docker compose start')
48
+ }
49
+ if (restored.code !== 0) throw new Error(`The restore of ${site} failed: its database is unchanged`)
50
+ print(`${site}: restored`)
51
+ })
52
+ }
53
+
54
+ /**
55
+ * Writes a backup of a site to a local file, decompressed and checked: the last one at or before `moment`.
56
+ * @param {import('./config.js').Infra} infra
57
+ * @param {string} site
58
+ * @param {string} file
59
+ * @param {object} [options]
60
+ * @param {string} [options.moment]
61
+ * @param {import('./server.js').Runner} [options.run]
62
+ */
63
+ export async function fetch(infra, site, file, { moment, run = runCommand } = {}) {
64
+ return withServer(infra, serverOf(infra, site), run, async ({ compose, env }) => {
65
+ // The database comes on the standard output; the messages of the command go to the error output
66
+ const script = `${BACKUP} fetch /tmp/fetched.db "$@" >&2 && cat /tmp/fetched.db`
67
+ const part = `${file}.part`
68
+ try {
69
+ const result = await run('docker', [...compose, 'run', '--rm', '--no-deps', '-T', '-e', 'LOG_LEVEL=warn',
70
+ `${site}-backup`, 'sh', '-c', script, 'sh', ...(moment === undefined ? [] : [moment])], { env, stdout: part })
71
+ if (result.code !== 0) throw new Error(`The backup of ${site} could not be fetched`)
72
+ renameSync(part, file)
73
+ } finally {
74
+ rmSync(part, { force: true })
75
+ }
76
+ })
77
+ }
@@ -0,0 +1,41 @@
1
+ // ramdb2-cli infra deploy (D55): build, decrypt the secrets with sops, docker compose up on the server through
2
+ // DOCKER_HOST=ssh://, then the Let's Encrypt certificates, and nginx reloaded.
3
+ import { readFileSync } from 'node:fs'
4
+ import { join } from 'node:path'
5
+ import { check, runCommand, withServer } from './server.js'
6
+
7
+ /**
8
+ * Deploys one server.
9
+ * @param {import('./config.js').Infra} infra
10
+ * @param {string} name the server
11
+ * @param {object} [options]
12
+ * @param {boolean} [options.staging] the staging certificates of Let's Encrypt (not trusted by browsers, no rate limit)
13
+ * @param {import('./server.js').Runner} [options.run]
14
+ * @param {(line: string) => void} [options.print]
15
+ * @returns {Promise<{certificates: {name: string, ok: boolean}[]}>}
16
+ */
17
+ export function deploy(infra, name, { staging = false, run = runCommand, print = console.log } = {}) {
18
+ return withServer(infra, name, run, async ({ server, dir, compose, env }) => {
19
+ print(`${name}: files written in ${dir}`)
20
+ print(`${name}: docker compose up on ${server.host}`)
21
+ await check(run('docker', [...compose, 'up', '-d', '--build', '--remove-orphans'], { env }), 'docker compose up')
22
+
23
+ const certificates = []
24
+ for (const certificate of JSON.parse(readFileSync(join(dir, 'certificates.json'), 'utf8'))) {
25
+ print(`${name}: certificate ${certificate.name} (${certificate.domains.join(', ')})`)
26
+ const result = await run('docker', [...compose, 'run', '--rm', '--entrypoint', 'certbot', 'certbot',
27
+ 'certonly', '--webroot', '-w', '/var/www/certbot', '--cert-name', certificate.name,
28
+ ...certificate.domains.flatMap(domain => ['-d', domain]),
29
+ '--email', server.email, '--agree-tos', '--no-eff-email', '--non-interactive', '--keep-until-expiring',
30
+ ...(staging ? ['--staging'] : [])], { env })
31
+ if (result.code !== 0) print(`${name}: certificate ${certificate.name} not obtained: do its domains point to the server?`)
32
+ certificates.push({ name: certificate.name, ok: result.code === 0 })
33
+ }
34
+ if (certificates.length > 0) {
35
+ await check(run('docker', [...compose, 'exec', '-T', 'nginx', 'sh', '-c', 'ramdb2-certs && nginx -s reload'], { env }),
36
+ 'nginx reload')
37
+ }
38
+ print(`${name}: deployed`)
39
+ return { certificates }
40
+ })
41
+ }
@@ -0,0 +1,19 @@
1
+ // ramdb2-cli infra down (D55): stops and removes the containers and the network of a server. The volumes (the
2
+ // databases), the images and the certificates stay: infra deploy starts the server again as it was.
3
+ import { check, runCommand, withServer } from './server.js'
4
+
5
+ /**
6
+ * Stops one server. Its secrets are decrypted too: Compose needs them to read compose.yaml.
7
+ * @param {import('./config.js').Infra} infra
8
+ * @param {string} name the server
9
+ * @param {object} [options]
10
+ * @param {import('./server.js').Runner} [options.run]
11
+ * @param {(line: string) => void} [options.print]
12
+ */
13
+ export async function down(infra, name, { run = runCommand, print = console.log } = {}) {
14
+ return withServer(infra, name, run, async ({ server, compose, env }) => {
15
+ print(`${name}: docker compose down on ${server.host} (the volumes stay)`)
16
+ await check(run('docker', [...compose, 'down', '--remove-orphans'], { env }), 'docker compose down')
17
+ print(`${name}: stopped`)
18
+ })
19
+ }
@@ -0,0 +1,54 @@
1
+ // ramdb2-cli infra keygen (D56): the SSH key of a server for its backups, encrypted by sops in secrets/<server>.key,
2
+ // its public half in secrets/<server>.pub, to install on the backup server.
3
+ import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
4
+ import { tmpdir } from 'node:os'
5
+ import { join } from 'node:path'
6
+ import { runCommand } from './server.js'
7
+
8
+ /**
9
+ * Creates the backup key of a server. An existing key is replaced only with `force`.
10
+ * @param {import('./config.js').Infra} infra
11
+ * @param {string} name the server
12
+ * @param {object} [options]
13
+ * @param {boolean} [options.force]
14
+ * @param {import('./server.js').Runner} [options.run]
15
+ * @param {(line: string) => void} [options.print]
16
+ * @returns {Promise<{publicKey: string, files: string[]}>}
17
+ */
18
+ export async function keygen(infra, name, { force = false, run = runCommand, print = console.log } = {}) {
19
+ if (!infra.servers.some(server => server.name === name)) throw new Error(`No server ${name} in infra.yaml`)
20
+ const key = join(infra.dir, 'secrets', `${name}.key`)
21
+ const pub = join(infra.dir, 'secrets', `${name}.pub`)
22
+ if (existsSync(key) && !force) {
23
+ throw new Error(`secrets/${name}.key exists: --force replaces it (then install the new public key on the backup server)`)
24
+ }
25
+ if (!existsSync(join(infra.dir, '.sops.yaml'))) {
26
+ throw new Error('No .sops.yaml in the infra folder: it gives the age keys that encrypt secrets/ (see the README of ramdb2-cli)')
27
+ }
28
+ const work = mkdtempSync(join(tmpdir(), 'ramdb2-keygen-'))
29
+ chmodSync(work, 0o700)
30
+ try {
31
+ const comment = `ramdb2-backup-${name}`
32
+ const generated = await run('ssh-keygen', ['-q', '-t', 'ed25519', '-N', '', '-C', comment, '-f', join(work, 'key')], { capture: true })
33
+ if (generated.code !== 0) throw new Error(`ssh-keygen failed: ${generated.stderr.trim()}`)
34
+ // The rules of .sops.yaml are matched on the input file name: the final name is given instead
35
+ const encrypted = await run('sops', ['--encrypt', '--input-type', 'binary', '--output-type', 'binary',
36
+ '--filename-override', `secrets/${name}.key`, join(work, 'key')], { capture: true, cwd: infra.dir })
37
+ if (encrypted.code !== 0) throw new Error(`sops could not encrypt the key: ${encrypted.stderr.trim()}`)
38
+ mkdirSync(join(infra.dir, 'secrets'), { recursive: true })
39
+ writeFileSync(`${key}.part`, encrypted.stdout, { mode: 0o600 })
40
+ renameSync(`${key}.part`, key)
41
+ const publicKey = readFileSync(join(work, 'key.pub'), 'utf8').trim()
42
+ writeFileSync(pub, publicKey + '\n')
43
+ print(`written ${key} (encrypted by sops)`)
44
+ print(`written ${pub}`)
45
+ print(`\nThe public key of ${name}, for ~backup/.ssh/authorized_keys on the backup server (restrict: no shell,`)
46
+ print('no forwarding; the SFTP-only access comes from the sshd configuration, see the README of ramdb2-cli):\n')
47
+ print(`restrict ${publicKey}`)
48
+ print(`\nThen: ramdb2-cli infra deploy ${name}`)
49
+ return { publicKey, files: [key, pub] }
50
+ } finally {
51
+ rmSync(work, { recursive: true, force: true })
52
+ rmSync(`${key}.part`, { force: true })
53
+ }
54
+ }
@@ -0,0 +1,106 @@
1
+ // What the infra commands that talk to a server share: the files built, the secrets decrypted by sops into a
2
+ // private temporary folder, the environment of docker compose (DOCKER_HOST and the secrets) and the commands run.
3
+ import { spawn } from 'node:child_process'
4
+ import { chmodSync, createWriteStream, existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
5
+ import { join } from 'node:path'
6
+ import { buildInfra } from './build.js'
7
+
8
+ /**
9
+ * Runs a command; its output goes to the terminal unless `capture`. `stdout` may be a file, for binary output.
10
+ * @typedef {(command: string, args: string[], options?: {env?: Record<string, string>, capture?: boolean,
11
+ * cwd?: string, stdout?: string}) => Promise<{code: number, stdout: string, stderr: string}>} Runner
12
+ */
13
+
14
+ /**
15
+ * @typedef {object} Connection
16
+ * @property {import('./config.js').Server} server
17
+ * @property {string} dir build/<server>/
18
+ * @property {string[]} compose `compose -f build/<server>/compose.yaml`, for docker
19
+ * @property {Record<string, string>} env DOCKER_HOST, RAMDB2_SECRETS and BACKUP_SSH_KEY
20
+ */
21
+
22
+ /**
23
+ * Builds the files of a server, decrypts its secrets, runs `action`, then deletes the decrypted secrets.
24
+ * Stops before `action` when a secret is missing or cannot be decrypted.
25
+ * @template T
26
+ * @param {import('./config.js').Infra} infra
27
+ * @param {string} name the server
28
+ * @param {Runner} run
29
+ * @param {(connection: Connection) => Promise<T>} action
30
+ * @returns {Promise<T>}
31
+ */
32
+ export async function withServer(infra, name, run, action) {
33
+ const [{ dir }] = buildInfra(infra, [name])
34
+ const server = infra.servers.find(candidate => candidate.name === name)
35
+ const missing = server.sites.map(site => `secrets/${site.name}.env`)
36
+ .concat(server.sites.length > 0 ? [`secrets/${name}.key`] : [])
37
+ .filter(path => !existsSync(join(infra.dir, path)))
38
+ if (missing.length > 0) {
39
+ throw new Error(`Missing secrets, encrypted with sops: ${missing.join(', ')}`
40
+ + (missing.includes(`secrets/${name}.key`) ? ` (ramdb2-cli infra keygen ${name} creates the key)` : ''))
41
+ }
42
+ // In build/<server>/, not in the system temporary folder: Docker installed as a snap cannot read /tmp
43
+ const secrets = mkdtempSync(join(dir, '.secrets-'))
44
+ chmodSync(secrets, 0o700)
45
+ try {
46
+ const env = { DOCKER_HOST: server.host, RAMDB2_SECRETS: secrets, BACKUP_SSH_KEY: '' }
47
+ for (const site of server.sites) {
48
+ const values = await decrypt(run, join(infra.dir, 'secrets', `${site.name}.env`), 'dotenv')
49
+ writeFileSync(join(secrets, `${site.name}.env`), values, { mode: 0o600 })
50
+ }
51
+ if (server.sites.length > 0) env.BACKUP_SSH_KEY = await decrypt(run, join(infra.dir, 'secrets', `${name}.key`), 'binary')
52
+ return await action({ server, dir, compose: ['compose', '-f', join(dir, 'compose.yaml')], env })
53
+ } finally {
54
+ rmSync(secrets, { recursive: true, force: true })
55
+ }
56
+ }
57
+
58
+ /**
59
+ * The server of a site: a site name is unique on all the servers.
60
+ * @param {import('./config.js').Infra} infra
61
+ * @param {string} site
62
+ * @returns {string}
63
+ */
64
+ export function serverOf(infra, site) {
65
+ const server = infra.servers.find(candidate => candidate.sites.some(entry => entry.name === site))
66
+ if (server === undefined) throw new Error(`No ramdb2 site ${site} in infra.yaml`)
67
+ return server.name
68
+ }
69
+
70
+ async function decrypt(run, file, type) {
71
+ const result = await run('sops', ['--decrypt', '--input-type', type, '--output-type', type, file], { capture: true })
72
+ if (result.code !== 0) throw new Error(`sops could not decrypt ${file}: ${result.stderr.trim()}`)
73
+ return result.stdout
74
+ }
75
+
76
+ /**
77
+ * Fails with `what` when the command failed.
78
+ * @param {Promise<{code: number}>} promise
79
+ * @param {string} what
80
+ */
81
+ export async function check(promise, what) {
82
+ const result = await promise
83
+ if (result.code !== 0) throw new Error(`${what} failed (exit code ${result.code})`)
84
+ return result
85
+ }
86
+
87
+ /** @type {Runner} */
88
+ export function runCommand(command, args, { env = {}, capture = false, cwd, stdout: outputFile } = {}) {
89
+ return new Promise((resolve, reject) => {
90
+ const child = spawn(command, args, {
91
+ env: { ...process.env, ...env },
92
+ cwd,
93
+ stdio: ['inherit', capture || outputFile !== undefined ? 'pipe' : 'inherit', capture ? 'pipe' : 'inherit'],
94
+ })
95
+ let stdout = ''
96
+ let stderr = ''
97
+ // With an output file, the command is done once the file is written too
98
+ const file = outputFile === undefined ? null : createWriteStream(outputFile)
99
+ const written = file === null ? Promise.resolve() : new Promise((done, fail) => file.on('finish', done).on('error', fail))
100
+ if (file !== null) child.stdout.pipe(file)
101
+ else child.stdout?.on('data', chunk => { stdout += chunk })
102
+ child.stderr?.on('data', chunk => { stderr += chunk })
103
+ child.on('error', error => reject(error.code === 'ENOENT' ? new Error(`${command} is not installed`) : error))
104
+ child.on('close', code => written.then(() => resolve({ code, stdout, stderr }), reject))
105
+ })
106
+ }