node --version
npm --version

// On importe le module 'http' de Node.js
// C'est un module integre, pas besoin de l'installer
const http = require('http');

// On cree un serveur
const server = http.createServer((request, response) => {
  // Cette fonction est appelee a chaque requete

  // On envoie le code de statut 200 (OK)
  response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });

  // On envoie le corps de la reponse
  response.end('Hello World!');
});

// Le serveur ecoute sur le port 3000
server.listen(3000, () => {
  console.log('Serveur démarré sur http://localhost:3000');
});

node server.js

const http = require('http');

const server = http.createServer((request, response) => {
  // On recupere l'URL et la methode
  const url = request.url;
  const method = request.method;

  // On definit le Content-Type par defaut
  response.setHeader('Content-Type', 'text/html; charset=utf-8');

  // Routing basique
  if (url === '/' && method === 'GET') {
    response.writeHead(200);
    response.end(`
      
Page d'accueil
      
Bienvenue sur mon serveur !
      
    `);
  } else if (url === '/about' && method === 'GET') {
    response.writeHead(200);
    response.end(`
      
À propos
      
Ce serveur a été créé à la main, sans framework.
      
    `);
  } else if (url === '/contact' && method === 'GET') {
    response.writeHead(200);
    response.end(`
      
Contact
      
Envoyez-moi un message !
      
    `);
  } else {
    // 404 - Page non trouvee
    response.writeHead(404);
    response.end(`
      
404 - Page non trouvée
      
L'URL ${url} n'existe pas.
      Retour à l'accueil
    `);
  }
});

server.listen(3000, () => {
  console.log('Serveur démarré sur http://localhost:3000');
});

const http = require('http');
const url = require('url');  // Module pour parser les URLs

const server = http.createServer((request, response) => {
  // On parse l'URL
  const parsedUrl = url.parse(request.url, true);
  
  // parsedUrl.pathname = le chemin sans les query params
  // parsedUrl.query = un objet avec les parametres
  
  const pathname = parsedUrl.pathname;
  const query = parsedUrl.query;

  response.setHeader('Content-Type', 'text/html; charset=utf-8');

  if (pathname === '/greet') {
    // URL : /greet?name=John
    const name = query.name || 'Visiteur';
    response.writeHead(200);
    response.end(`<h1>Bonjour, ${name} !</h1>`);
  } else if (pathname === '/search') {
    // URL : /search?q=javascript&page=1
    const q = query.q || '';
    const page = query.page || '1';
    response.writeHead(200);
    response.end(`
      <h1>Recherche</h1>
      <p>Terme : ${q}</p>
      <p>Page : ${page}</p>
    `);
  } else {
    response.writeHead(404);
    response.end('<h1>404</h1>');
  }
});

server.listen(3000, () => {
  console.log('Serveur sur http://localhost:3000');
  console.log('Teste : http://localhost:3000/greet?name=John');
  console.log('Teste : http://localhost:3000/search?q=javascript&page=2');
});

const http = require('http');
const url = require('url');

// Fonction pour parser le body JSON
function parseJsonBody(request) {
  return new Promise((resolve, reject) => {
    let body = '';
    
    // Les donnees arrivent par morceaux (chunks)
    request.on('data', (chunk) => {
      body += chunk.toString();
    });
    
    // Quand toutes les donnees sont arrivees
    request.on('end', () => {
      try {
        if (body) {
          resolve(JSON.parse(body));
        } else {
          resolve({});
        }
      } catch (error) {
        reject(error);
      }
    });
    
    request.on('error', reject);
  });
}

const server = http.createServer(async (request, response) => {
  const parsedUrl = url.parse(request.url, true);
  const pathname = parsedUrl.pathname;
  const method = request.method;

  response.setHeader('Content-Type', 'application/json; charset=utf-8');

  // Route GET - Afficher un formulaire
  if (pathname === '/' && method === 'GET') {
    response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    response.end(`
      <h1>Envoyer des donnees</h1>
      <form action="/submit" method="POST">
        <p>
          <label>Nom : <input type="text" name="name" required></label>
        </p>
        <p>
          <label>Email : <input type="email" name="email" required></label>
        </p>
        <button type="submit">Envoyer</button>
      </form>
      
      <hr>
      
      <h2>Ou envoyer du JSON</h2>
      <pre>curl -X POST http://localhost:3000/json \\
  -H "Content-Type: application/json" \\
  -d '{"name":"John","email":"john@example.com"}'</pre>
    `);
    return;
  }

  // Route POST - JSON
  if (pathname === '/json' && method === 'POST') {
    try {
      const data = await parseJsonBody(request);
      response.writeHead(200);
      response.end(JSON.stringify({
        success: true,
        message: 'Données reçues',
        data: data
      }));
    } catch (error) {
      response.writeHead(400);
      response.end(JSON.stringify({
        success: false,
        error: 'JSON invalide'
      }));
    }
    return;
  }

  // Route POST - Formulaire (urlencoded)
  if (pathname === '/submit' && method === 'POST') {
    let body = '';
    
    request.on('data', (chunk) => {
      body += chunk.toString();
    });
    
    request.on('end', () => {
      // Parser les donnees urlencoded
      // Format: name=John&email=john@example.com
      const params = new URLSearchParams(body);
      const data = Object.fromEntries(params);
      
      response.writeHead(200);
      response.end(JSON.stringify({
        success: true,
        message: 'Formulaire reçu',
        data: data
      }));
    });
    return;
  }

  // 404
  response.writeHead(404);
  response.end(JSON.stringify({ error: 'Non trouvé' }));
});

server.listen(3000, () => {
  console.log('Serveur sur http://localhost:3000');
});

# Envoyer du JSON
curl -X POST http://localhost:3000/json -H "Content-Type: application/json" -d "{\"name\":\"John\",\"email\":\"john@example.com\"}"

mon-serveur/
├── server.js
└── public/
    ├── index.html
    ├── style.css
    └── image.jpg

const http = require('http');
const fs = require('fs');
const path = require('path');

// Dossier des fichiers statiques
const PUBLIC_DIR = path.join(__dirname, 'public');

// Map des types MIME
const MIME_TYPES = {
  '.html': 'text/html',
  '.css': 'text/css',
  '.js': 'application/javascript',
  '.json': 'application/json',
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.gif': 'image/gif',
  '.svg': 'image/svg+xml',
  '.ico': 'image/x-icon',
  '.txt': 'text/plain',
  '.pdf': 'application/pdf'
};

const server = http.createServer((request, response) => {
  // Si l'URL est '/', on sert index.html
  let filePath = request.url === '/' 
    ? path.join(PUBLIC_DIR, 'index.html')
    : path.join(PUBLIC_DIR, request.url);

  // Securite : empecher de sortir du dossier public
  if (!filePath.startsWith(PUBLIC_DIR)) {
    response.writeHead(403);
    response.end('Interdit');
    return;
  }

  // Determiner le type MIME
  const ext = path.extname(filePath);
  const contentType = MIME_TYPES[ext] || 'application/octet-stream';

  // Lire le fichier
  fs.readFile(filePath, (err, data) => {
    if (err) {
      if (err.code === 'ENOENT') {
        // Fichier non trouve
        response.writeHead(404);
        response.end('Fichier non trouvé');
      } else {
        // Autre erreur
        response.writeHead(500);
        response.end('Erreur serveur');
      }
      return;
    }

    // Envoyer le fichier
    response.writeHead(200, { 'Content-Type': contentType });
    response.end(data);
  });
});

server.listen(3000, () => {
  console.log('Serveur sur http://localhost:3000');
  console.log('Fichiers servis depuis le dossier public/');
});

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <title>Mon serveur</title>
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <h1>Bienvenue !</h1>
  <p>Ce fichier est servi par ton serveur Node.js.</p>
  <img src="image.jpg" alt="Une image">
</body>
</html>

body {
  font-family: Arial, sans-serif;
  max-width: 800px;
  margin: 0 auto;
  padding: 20px;
  background: #f5f5f5;
}

h1 {
  color: #333;
}

img {
  max-width: 100%;
  border-radius: 8px;
}

<h1>Bonjour, {{name}} !</h1>

<h1>Bonjour, John !</h1>

const http = require('http');
const fs = require('fs');
const path = require('path');

const TEMPLATES_DIR = path.join(__dirname, 'templates');

// Moteur de template minimaliste
function renderTemplate(templateName, data) {
  return new Promise((resolve, reject) => {
    const filePath = path.join(TEMPLATES_DIR, templateName);
    
    fs.readFile(filePath, 'utf-8', (err, template) => {
      if (err) {
        reject(err);
        return;
      }
      
      // Remplacer {{variable}} par sa valeur
      let html = template;
      for (const [key, value] of Object.entries(data)) {
        const regex = new RegExp(`{{${key}}}`, 'g');
        html = html.replace(regex, value);
      }
      
      resolve(html);
    });
  });
}

const server = http.createServer(async (request, response) => {
  const url = request.url;

  response.setHeader('Content-Type', 'text/html; charset=utf-8');

  try {
    if (url === '/' || url === '/home') {
      const html = await renderTemplate('home.html', {
        title: 'Page d\'accueil',
        message: 'Bienvenue sur mon site !',
        year: new Date().getFullYear()
      });
      response.writeHead(200);
      response.end(html);
    } else if (url === '/about') {
      const html = await renderTemplate('about.html', {
        title: 'À propos',
        author: 'Moi',
        year: new Date().getFullYear()
      });
      response.writeHead(200);
      response.end(html);
    } else {
      const html = await renderTemplate('404.html', {
        title: 'Page non trouvée'
      });
      response.writeHead(404);
      response.end(html);
    }
  } catch (error) {
    console.error(error);
    response.writeHead(500);
    response.end('<h1>Erreur serveur</h1>');
  }
});

server.listen(3000, () => {
  console.log('Serveur sur http://localhost:3000');
});

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <title>{{title}}</title>
</head>
<body>
  <h1>{{message}}</h1>
  <p>Année : {{year}}</p>
  <nav>
    <a href="/">Accueil</a> |
    <a href="/about">À propos</a>
  </nav>
</body>
</html>

const http = require('http');

// Notre "app" - un mini-framework maison
const app = {
  middlewares: [],

  // Ajouter un middleware
  use(middleware) {
    this.middlewares.push(middleware);
  },

  // Executer les middlewares
  handle(request, response) {
    let index = 0;

    const next = () => {
      if (index < this.middlewares.length) {
        const middleware = this.middlewares[index];
        index++;
        middleware(request, response, next);
      }
    };

    next();
  }
};

// --- MIDDLEWARES ---

// 1. Logger - affiche chaque requete
app.use((req, res, next) => {
  const time = new Date().toISOString();
  console.log(`[${time}] ${req.method} ${req.url}`);
  next();
});

// 2. Parser JSON body
app.use((req, res, next) => {
  let body = '';
  req.on('data', (chunk) => { body += chunk; });
  req.on('end', () => {
    try {
      req.body = body ? JSON.parse(body) : {};
      next();
    } catch (e) {
      res.writeHead(400);
      res.end(JSON.stringify({ error: 'JSON invalide' }));
    }
  });
});

// 3. Ajouter des headers CORS
app.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  next();
});

// 4. Route finale
app.use((req, res) => {
  res.setHeader('Content-Type', 'application/json');
  
  if (req.url === '/' && req.method === 'GET') {
    res.writeHead(200);
    res.end(JSON.stringify({ message: 'Bienvenue' }));
  } else if (req.url === '/api/data' && req.method === 'POST') {
    res.writeHead(200);
    res.end(JSON.stringify({ success: true, received: req.body }));
  } else {
    res.writeHead(404);
    res.end(JSON.stringify({ error: 'Non trouvé' }));
  }
});

// --- SERVEUR ---

const server = http.createServer((req, res) => {
  app.handle(req, res);
});

server.listen(3000, () => {
  console.log('Serveur avec middlewares sur http://localhost:3000');
  console.log('Teste : curl http://localhost:3000/');
  console.log('Teste : curl -X POST http://localhost:3000/api/data -H "Content-Type: application/json" -d \'{"test":"ok"}\'');
});

const http = require('http');
const url = require('url');

// Base de donnees en memoire (tres simple, pas persistante)
let todos = [
  { id: 1, title: 'Apprendre Node.js', done: false },
  { id: 2, title: 'Créer un serveur web', done: true },
  { id: 3, title: 'Comprendre HTTP', done: false }
];
let nextId = 4;

// Helper pour parser le body
function parseBody(req) {
  return new Promise((resolve) => {
    let body = '';
    req.on('data', (chunk) => { body += chunk; });
    req.on('end', () => {
      try {
        resolve(body ? JSON.parse(body) : {});
      } catch {
        resolve({});
      }
    });
  });
}

// Helper pour envoyer du JSON
function sendJson(res, status, data) {
  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify(data));
}

const server = http.createServer(async (req, res) => {
  const parsedUrl = url.parse(req.url, true);
  const pathname = parsedUrl.pathname;
  const method = req.method;

  // CORS
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');

  // Preflight pour CORS
  if (method === 'OPTIONS') {
    res.writeHead(204);
    res.end();
    return;
  }

  // Router
  // GET /api/todos - Liste toutes les todos
  if (pathname === '/api/todos' && method === 'GET') {
    sendJson(res, 200, { success: true, data: todos });
    return;
  }

  // GET /api/todos/:id - Une todo spécifique
  const matchGet = pathname.match(/^\/api\/todos\/(\d+)$/);
  if (matchGet && method === 'GET') {
    const id = parseInt(matchGet[1]);
    const todo = todos.find(t => t.id === id);
    if (todo) {
      sendJson(res, 200, { success: true, data: todo });
    } else {
      sendJson(res, 404, { success: false, error: 'Tâche non trouvée' });
    }
    return;
  }

  // POST /api/todos - Créer une todo
  if (pathname === '/api/todos' && method === 'POST') {
    const body = await parseBody(req);
    if (!body.title) {
      sendJson(res, 400, { success: false, error: 'Le titre est requis' });
      return;
    }
    const newTodo = {
      id: nextId++,
      title: body.title,
      done: body.done || false
    };
    todos.push(newTodo);
    sendJson(res, 201, { success: true, data: newTodo });
    return;
  }

  // PUT /api/todos/:id - Modifier une todo
  const matchPut = pathname.match(/^\/api\/todos\/(\d+)$/);
  if (matchPut && method === 'PUT') {
    const id = parseInt(matchPut[1]);
    const body = await parseBody(req);
    const todo = todos.find(t => t.id === id);
    if (!todo) {
      sendJson(res, 404, { success: false, error: 'Tâche non trouvée' });
      return;
    }
    if (body.title !== undefined) todo.title = body.title;
    if (body.done !== undefined) todo.done = body.done;
    sendJson(res, 200, { success: true, data: todo });
    return;
  }

  // DELETE /api/todos/:id - Supprimer une todo
  const matchDelete = pathname.match(/^\/api\/todos\/(\d+)$/);
  if (matchDelete && method === 'DELETE') {
    const id = parseInt(matchDelete[1]);
    const index = todos.findIndex(t => t.id === id);
    if (index === -1) {
      sendJson(res, 404, { success: false, error: 'Tâche non trouvée' });
      return;
    }
    todos.splice(index, 1);
    sendJson(res, 200, { success: true, message: 'Tâche supprimée' });
    return;
  }

  // Page d'accueil
  if (pathname === '/' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end(`
      <h1>API Todos</h1>
      <h2>Endpoints</h2>
      <ul>
        <li>GET /api/todos</li>
        <li>GET /api/todos/:id</li>
        <li>POST /api/todos { "title": "..." }</li>
        <li>PUT /api/todos/:id { "title": "...", "done": true }</li>
        <li>DELETE /api/todos/:id</li>
      </ul>
    `);
    return;
  }

  // 404
  sendJson(res, 404, { success: false, error: 'Non trouvé' });
});

server.listen(3000, () => {
  console.log('API Todos sur http://localhost:3000');
  console.log('');
  console.log('Endpoints:');
  console.log('  GET    /api/todos      - Liste');
  console.log('  GET    /api/todos/1   - Détail');
  console.log('  POST   /api/todos      - Créer');
  console.log('  PUT    /api/todos/1    - Modifier');
  console.log('  DELETE /api/todos/1    - Supprimer');
});

# Lister les todos
curl http://localhost:3000/api/todos

# Créer une todo
curl -X POST http://localhost:3000/api/todos -H "Content-Type: application/json" -d "{\"title\":\"Nouvelle tâche\"}"

# Modifier une todo
curl -X PUT http://localhost:3000/api/todos/1 -H "Content-Type: application/json" -d "{\"done\":true}"

# Supprimer une todo
curl -X DELETE http://localhost:3000/api/todos/1

const http = require('http');
const crypto = require('crypto');

// Stockage des sessions en memoire
// En production, utiliser Redis ou une base de donnees
const sessions = new Map();

// Generer un ID de session unique
function generateSessionId() {
  return crypto.randomBytes(16).toString('hex');
}

// Parser les cookies
function parseCookies(cookieHeader) {
  const cookies = {};
  if (!cookieHeader) return cookies;
  
  cookieHeader.split(';').forEach(cookie => {
    const [name, value] = cookie.trim().split('=');
    cookies[name] = value;
  });
  
  return cookies;
}

// Helper pour parser le body
function parseBody(req) {
  return new Promise((resolve) => {
    let body = '';
    req.on('data', (chunk) => { body += chunk; });
    req.on('end', () => {
      try {
        resolve(body ? JSON.parse(body) : {});
      } catch {
        resolve({});
      }
    });
  });
}

const server = http.createServer(async (req, res) => {
  const cookies = parseCookies(req.headers.cookie);
  
  // Recuperer ou creer une session
  let sessionId = cookies.sessionId;
  let session = sessions.get(sessionId);
  
  if (!session) {
    sessionId = generateSessionId();
    session = { views: 0, user: null };
    sessions.set(sessionId, session);
  }

  res.setHeader('Content-Type', 'text/html; charset=utf-8');

  // Page d'accueil
  if (req.url === '/' && req.method === 'GET') {
    session.views++;
    
    // Definir le cookie de session
    res.setHeader('Set-Cookie', `sessionId=${sessionId}; HttpOnly; Path=/`);
    
    res.writeHead(200);
    res.end(`
      <h1>Sessions Demo</h1>
      <p>Session ID: ${sessionId}</p>
      <p>Pages vues: ${session.views}</p>
      <p>Utilisateur: ${session.user || 'Non connecté'}</p>
      <hr>
      <form action="/login" method="POST">
        <input type="text" name="username" placeholder="Username">
        <button type="submit">Login</button>
      </form>
      <br>
      <a href="/logout">Logout</a>
    `);
    return;
  }

  // Login
  if (req.url === '/login' && req.method === 'POST') {
    const body = await parseBody(req);
    // En réalité, il faudrait verifier le mot de passe
    session.user = body.username || 'Anonyme';
    
    res.setHeader('Set-Cookie', `sessionId=${sessionId}; HttpOnly; Path=/`);
    res.writeHead(302, { 'Location': '/' });
    res.end();
    return;
  }

  // Logout
  if (req.url === '/logout' && req.method === 'GET') {
    sessions.delete(sessionId);
    res.writeHead(302, { 'Location': '/' });
    res.end();
    return;
  }

  // 404
  res.writeHead(404);
  res.end('<h1>404</h1>');
});

server.listen(3000, () => {
  console.log('Serveur avec sessions sur http://localhost:3000');
  console.log('Ouvre le navigateur et rafraichis plusieurs fois.');
  console.log('Tu verras le compteur de pages vues augmenter.');
});

# Generer une cle privee
openssl genrsa -out key.pem 2048

# Generer un certificat auto-signé
openssl req -new -x509 -key key.pem -out cert.pem -days 365

# Repondre aux questions (ou appuyer sur Entree pour laisser vide)

const https = require('https');
const fs = require('fs');
const path = require('path');

// Charger le certificat et la cle
const options = {
  key: fs.readFileSync(path.join(__dirname, 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'cert.pem'))
};

const server = https.createServer(options, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
  res.end(`
    <h1>HTTPS fonctionne !</h1>
    <p>Tu accèdes à cette page en HTTPS.</p>
    <p>Le cadenas à côté de l'URL indique que la connexion est sécurisée.</p>
  `);
});

server.listen(443, () => {
  console.log('Serveur HTTPS sur https://localhost');
  console.log('Note: Sur Windows, il faut peut-être lancer en administrateur pour le port 443');
});

# Image de base avec Node.js
FROM node:20-alpine

# Dossier de travail dans le conteneur
WORKDIR /app

# Copier les fichiers de dépendances (si package.json existe)
COPY package*.json ./

# Installer les dépendances (si nécessaire)
RUN npm ci --only=production || true

# Copier le code
COPY . .

# Exposer le port
EXPOSE 3000

# Commande de démarrage
CMD ["node", "server.js"]

services:
  webserver:
    build: .
    container_name: mon-serveur-web
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
    volumes:
      - ./public:/app/public
      - ./templates:/app/templates

# Construire l'image
docker build -t mon-serveur-web .

# Lancer le conteneur
docker run -d -p 3000:3000 --name webserver mon-serveur-web

# Ou avec docker-compose
docker-compose up -d

# Voir les logs
docker logs webserver

# Arrêter le conteneur
docker stop webserver