Déploiement de TypeScript sur Kubernetes : guide de base pour débutants

Déploiement de TypeScript sur Kubernetes : guide de base pour débutants

Le développement web moderne est impensable sans conteneurisation et orchestration. Si vous écrivez en TypeScript et souhaitez que votre application fonctionne de manière stable, évolue automatiquement et soit tolérante aux pannes — Kubernetes (K8s) deviendra votre meilleur ami. Dans ce guide, nous allons étape par étape voir comment empaqueter une application TypeScript dans Docker et la déployer dans un cluster Kubernetes. Le contenu est conçu pour les débutants : pas de magie, seulement des exemples et des explications clairs.

1. Préparation de l'application TypeScript

Avant de penser à Kubernetes, il faut s'assurer que votre application est prête à fonctionner dans un conteneur. Créons un simple serveur HTTP avec Express et TypeScript.

1.1. Initialisation du projet

Créez un dossier de projet et effectuez l'initialisation :

mkdir my-ts-app && cd my-ts-app\nnpm init -y\nnpm install express\nnpm install -D typescript @types/node @types/express ts-node nodemon

1.2. Configuration de TypeScript

Créez le fichier tsconfig.json :

{\n  "compilerOptions": {\n    "target": "ES2020",\n    "module": "commonjs",\n    "outDir": "./dist",\n    "rootDir": "./src",\n    "strict": true,\n    "esModuleInterop": true,\n    "skipLibCheck": true\n  },\n  "include": ["src/**/*"],\n  "exclude": ["node_modules", "dist"]\n}

1.3. Code de l'application

Créez le dossier src et le fichier index.ts :

import express, { Request, Response } from 'express';\n\nconst app = express();\nconst PORT = process.env.PORT || 3000;\n\napp.get('/', (req: Request, res: Response) => {\n  res.json({ message: 'Hello from TypeScript on Kubernetes!' });\n});\n\napp.listen(PORT, () => {\n  console.log(`Server running on port ${PORT}`);\n});

1.4. Compilation et exécution

Ajoutez les scripts dans package.json :

"scripts": {\n  "build": "tsc",\n  "start": "node dist/index.js",\n  "dev": "ts-node src/index.ts"\n}

Vérifiez l'exécution locale : npm run dev et ouvrez http://localhost:3000.

2. Conteneurisation avec Docker

Kubernetes fonctionne avec des conteneurs. Nous devons créer une image Docker de notre application TypeScript.

2.1. Dockerfile

Créez le fichier Dockerfile à la racine du projet :

FROM node:18-alpine AS builder\nWORKDIR /app\nCOPY package*.json ./\nRUN npm ci\nCOPY . .\nRUN npm run build\n\nFROM node:18-alpine AS production\nWORKDIR /app\nCOPY --from=builder /app/dist ./dist\nCOPY --from=builder /app/package*.json ./\nRUN npm ci --only=production\nEXPOSE 3000\nCMD ["node", "dist/index.js"]

Nous utilisons une construction multi-étapes : d'abord compiler TypeScript, puis créer une image finale légère.

2.2. Construction de l'image

docker build -t my-ts-app:latest .

Vérifiez localement :

docker run -p 3000:3000 my-ts-app:latest

2.3. .dockerignore

Pour ne pas copier les fichiers inutiles, créez .dockerignore :

node_modules\ndist\n.git\n*.md

3. Déploiement dans Kubernetes

Maintenant que nous avons une image Docker, nous pouvons passer à Kubernetes. Pour les tests locaux, je recommande Minikube ou Kind.

3.1. Lancement de Minikube

minikube start --driver=docker\nminikube status

3.2. Chargement de l'image dans Minikube

Pour que Kubernetes puisse trouver notre image, chargeons-la dans l'environnement Minikube :

minikube image load my-ts-app:latest

3.3. Création du Deployment

Créez le fichier deployment.yaml :

apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: my-ts-app-deployment\nspec:\n  replicas: 2\n  selector:\n    matchLabels:\n      app: my-ts