Déployer une application

Cette page empaquette un serveur TypeScript en image de conteneur basée sur elide.dev/elide.

Écrire l’application

// server.ts
import { Hono } from "hono";

const app = new Hono();

app.use(async (c, next) => {
  await next();
  console.log(JSON.stringify({ method: c.req.method, path: c.req.path, status: c.res.status }));
});

app.get("/healthz", (c) => c.text("ok"));
app.get("/", (c) => c.json({ greeting: process.env.GREETING ?? "hello" }));

export default app;

// healthcheck.mjs
const res = await fetch("http://127.0.0.1:8080/healthz");
process.exit(res.ok ? 0 : 1);

{
  "name": "deploy-app",
  "type": "module",
  "dependencies": {
    "hono": "^4.7.0"
  }
}

Exécutez une fois elide install --ecosystems=npm pour écrire aube-lock.yaml.

Écrire le Dockerfile

FROM elide.dev/elide:1.6.0
WORKDIR /app
COPY package.json aube-lock.yaml ./
RUN elide install --ecosystems=npm
COPY . .
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s CMD ["elide", "healthcheck.mjs"]
CMD ["--allow-read=/app,/root/.cache/aube", "--allow-net=api.example.com", "serve", "--no-tui", "--host", "0.0.0.0", "--port", "8080", "server.ts"]

# .dockerignore
node_modules
.env

Ligne	Raison
`FROM elide.dev/elide:1.6.0`	Le point d’entrée de l’image est `elide`, donc `CMD` ne contient que ses arguments. Étiquettes : Images de conteneur.
`RUN elide install --ecosystems=npm`	Installe dans l’image. `node_modules` pointe vers `/root/.cache/aube`, donc un `node_modules` de l’hôte ne fonctionnerait pas.
`--host 0.0.0.0`	Un gestionnaire exporté par défaut écoute sur `127.0.0.1`, inaccessible depuis l’extérieur du conteneur.
`--no-tui`	Sans cette option, `docker run -t` lance l’interface en terminal et la sortie de l’application n’atteint jamais `docker logs`.
`HEALTHCHECK`	L’image n’a ni `curl` ni `wget` ; un court script Elide effectue le contrôle.

docker build -t my-app .
docker run -d --name my-app -p 8080:8080 -e GREETING=hi my-app
curl http://127.0.0.1:8080/

{"greeting":"hi"}

docker inspect --format '{{.State.Health.Status}}' my-app affiche healthy dès que le premier contrôle réussit. docker stop arrête le serveur en moins d’une seconde, avec le code de sortie 143.

Passer des variables d’environnement

process.env contient les variables du conteneur ; passez-les avec docker run -e NAME=value ou --env-file .env. Elide ne lit pas les fichiers .env et ne définit pas NODE_ENV. Pour les exécutions locales, chargez le fichier dans le code :

import { existsSync } from "node:fs";

if (existsSync(".env")) process.loadEnvFile();

Sans la vérification, process.loadEnvFile() lève ENOENT: no such file or directory, open '.env' lorsque le fichier est absent. Voir Variables d’environnement.

Restreindre le serveur

Les programmes s’exécutent sans restriction tant qu’aucune option de bac à sable n’est donnée. Accordez au serveur ce dont il a besoin, et rien de plus :

Option	Dans le Dockerfile ci-dessus
`--allow-read=PATHS`	`/app` et le magasin npm `/root/.cache/aube`.
`--allow-net=HOSTS`	Hôtes sortants. Écouter sur un port ne demande aucune autorisation.
`--allow-run=CMDS`	Non indiquée : les sous-processus restent autorisés. Donnez une liste pour les restreindre.
`--deny-net=HOSTS`	Hôtes bloqués même s’ils sont autorisés, par ex. `--deny-net=169.254.169.254`.
`--max-mem=SIZE`, `--timeout=DURATION`	Taille du tas et durée totale d’exécution.

Les options globales se placent avant la commande (serve, run). --deny-net et --deny-run exigent la forme avec =. Si le magasin npm manque dans --allow-read, le serveur s’arrête au démarrage :

Error: Filesystem read denied by policy: /app/node_modules/hono

Un appel sortant bloqué nomme l’option :

fetch to '169.254.169.254:80' denied by --deny-net

Toutes les options : Bac à sable et limites.

Lire les journaux

console.log écrit sur stdout et console.error sur stderr ; docker logs affiche les deux :

{"method":"GET","path":"/healthz","status":200}
{"method":"GET","path":"/","status":200}

elide serve --no-tui n’affiche aucun journal d’accès, et un gestionnaire qui lève une exception répond 500 sans afficher l’erreur. Journalisez les requêtes et les erreurs dans l’application, ou exportez les spans de requête, les métriques et les erreurs avec OpenTelemetry.

Déployer une application JVM

Construisez une image JVM depuis elide.pkl avec un artefact ContainerImage : Conteneurs JVM.
Compilez un exécutable natif : Native Image.