Express.js-project maken en uitvoeren met ServBay

Wat is Express.js?

Express.js is een snel, open en minimalistisch webapplicatieframework gebaseerd op Node.js. Het biedt krachtige functionaliteiten voor het bouwen van single-page, multi-page en hybride webapplicaties. Express.js behoort tot de populairste frameworks binnen het Node.js-ecosysteem en is geliefd bij ontwikkelaars vanwege zijn eenvoudige en flexibele ontwerp.

Belangrijkste kenmerken en voordelen van Express.js

• Simpel & flexibel: Express.js beschikt over een eenvoudige API en een flexibel middleware-systeem, waardoor je efficiënt krachtige webapplicaties ontwikkelt.
• Middleware: Ondersteuning voor talloze middleware, waarmee je eenvoudig verzoeken en antwoorden verwerkt. Denk aan request body-parsing, sessiebeheer en het aanbieden van statische bestanden.
• Routing: Krachtige routeringsfunctionaliteit voor het afhandelen van verzoeken gebaseerd op verschillende HTTP-methodes (GET, POST, PUT, DELETE, enz.) en URL-paden.
• Uitstekende integratie: Naadloze integratie met diverse template-engines (zoals Pug, EJS, Handlebars), databases (zoals MongoDB, MySQL, PostgreSQL) en andere Node.js-modules.
• Community & ecosysteem: Een grote community en een rijkdom aan derde partij middleware en plug-ins waarborgen voldoende ondersteuning en bronnen.

Met Express.js bouw je in korte tijd schaalbare en performante webapplicaties en API’s. ServBay fungeert als krachtig lokaal webontwikkelplatform met een handige Node.js-omgeving, reverse proxy-functie en krachtig databasebeheer, speciaal voor je Express.js-projecten.

Een Express.js-project maken en uitvoeren met ServBay

Deze gids laat zien hoe je met de Node.js-omgeving van ServBay een Express.js-project kunt opzetten, configureren en uitvoeren. We gebruiken de Websites-functie van ServBay om de webserver te configureren en toegang via reverse proxy mogelijk te maken. Deze aanpak is ideaal voor toepassingen zoals Node.js, Python, Go en Java die op een eigen poort draaien.

Vereisten

Voor je begint, zorg dat je aan de volgende voorwaarden voldoet:

• ServBay correct geïnstalleerd op macOS.
• Node.js-pakket geïnstalleerd en geactiveerd via het “Pakketten”-tabblad in jouw ServBay-configuratie.
• (Optioneel) Indien je een database gaat gebruiken: het benodigde databasepakket (zoals MariaDB, PostgreSQL, MongoDB, Redis, MySQL) is geïnstalleerd en ingeschakeld in ServBay.
• Basiskennis van terminal- of commandlinegebruik.

Een Express.js-project opzetten

1. Project initialiseren

   Open de terminal en navigeer naar de door ServBay aanbevolen rootmap: /Applications/ServBay/www. Gebruik vervolgens npx express-generator om snel het skeleton van een nieuw Express.js-project te genereren. npx wordt standaard meegeleverd met npm v5.2+.

   cd /Applications/ServBay/www
   npx express-generator servbay-express-app

   Dit maakt in de map /Applications/ServBay/www een nieuwe projectmap servbay-express-app aan met de basisstructuur voor Express.js.

2. Projectafhankelijkheden installeren

   Ga in de terminal naar de nieuwe projectmap en installeer met npm install alle benodigde pakketten (o.a. Express.js en standaardtemplate-, statische-bestanden-afhandeling, enz.).

   cd servbay-express-app
   npm install

   Wacht tot alle afhankelijkheden zijn geïnstalleerd.

Aangepaste homepage-output in Express.js

Om te controleren of alles werkt, wijzigen we de standaard homepage-output.

1. Pas het bestand routes/index.js aan

   Express.js gebruikt routebestanden voor het afhandelen van verschillende URL-verzoeken. Open in jouw projectmap het bestand routes/index.js—dit behandelt de GET-verzoeken naar het hoofpad /. We passen het zo aan dat niet langer een Pug-template gerenderd wordt, maar direct een tekstuele response wordt gestuurd.

   var express = require('express');
   var router = express.Router();
   
   /* GET home page. */
   router.get('/', function(req, res, next) {
     // Gewijzigd naar een tekstuele response
     res.send('Hello ServBay!');
   });
   
   module.exports = router;

   Sla het bestand op.

Werken in ontwikkelmodus

Tijdens de ontwikkeling wil je wijzigingen direct kunnen beoordelen. Start hiervoor de lokale server met npm start.

1. Start de ontwikkelserver

   Voer in de projectmap het volgende commando uit om de ontwikkelserver op poort 8585 te starten. Met de variabele DEBUG wordt debugging-info weergegeven.

   cd /Applications/ServBay/www/servbay-express-app
   PORT=8585 DEBUG=servbay-express-app:* npm start

   De terminal toont nu informatie waaruit blijkt dat de Express.js-app op poort 8585 draait.

2. ServBay website reverse proxy instellen

   Omdat Express.js op een eigen poort draait (en niet op 80/443), stellen we via de Websites-functie van ServBay een reverse proxy in. De webserver van ServBay (standaard Caddy) luistert op poort 80/443 en stuurt aanvragen voor een specifiek domein door naar Express op poort 8585.

   Ga in ServBay naar het “Websites”-tabblad en voeg een nieuwe website toe met de volgende instellingen:

   • Naam: My first Express.js dev site (kies een herkenbare naam)
   • Domein: servbay-express-test.servbay.demo (met het .servbay.demo-domein profiteer je van automatische HTTPS)
   • Websitetype: Selecteer Reverse Proxy
   • IP: 127.0.0.1 (of localhost)
   • Poort: 8585 (de poort van je Express.js-app)

   Sla deze instellingen op en laat ServBay de wijzigingen toepassen. Certificaten (SSL) worden dan automatisch gegenereerd voor .servbay.demo-domeinen.

   Voor een gedetailleerde beschrijving zie de ServBay-documentatie over Node.js-websites toevoegen.

3. Website in ontwikkelmodus openen

   Open je browser en ga naar https://servbay-express-test.servbay.demo. De ServBay-webserver ontvangt deze aanvraag en stuurt hem via de reverse proxy door naar Express.js op poort 8585. Je ziet dan “Hello ServBay!” in de browser verschijnen.

   Dankzij de ondersteuning voor custom domeinen en gratis SSL-certificaten (inclusief automatische HTTPS op .servbay.demo), kun je lokaal veilig via HTTPS ontwikkelen—net als in productie.

Productieversie uitrollen

Als je klaar bent met ontwikkelen, kun je het project in productie brengen, of lokaal een productieomgeving simuleren.

1. Productieomgeving voorbereiden

   In productie wordt doorgaans de omgevingsvariabele NODE_ENV=production gebruikt. Dit heeft effect op bijvoorbeeld debug-instellingen en performance-optimalisaties. Controleer dat je app correct werkt met deze setting.

2. Productieserver starten

   Start in de hoofdmap van het project de server op een andere poort (bijv. 8586) en met de productie-instelling:

   cd /Applications/ServBay/www/servbay-express-app
   PORT=8586 NODE_ENV=production npm start

   Je ziet nu servermeldingen voor poort 8586.

3. ServBay website reverse proxy instellen (productie)

   Maak in ServBay wederom een nieuwe website aan voor de productie-omgeving:

   • Naam: My first Express.js production site
   • Domein: servbay-express-test-prod.servbay.demo (of elk ander gewenst domein)
   • Websitetype: Selecteer Reverse Proxy
   • IP: 127.0.0.1
   • Poort: 8586 (poort van de productie-instatie)

   Sla op en laat de wijzigingen doorvoeren.

4. Productie-site bezoeken

   Surf naar https://servbay-express-test-prod.servbay.demo om de productie-instantie van je Express.js-app lokaal te bezoeken, wederom via ServBay’s reverse proxy.

Databaseverbindingen

ServBay biedt lokaal diverse databasepakketten, bijvoorbeeld MariaDB, PostgreSQL, MongoDB en Redis. Heb je deze in ServBay geactiveerd, dan kan jouw Express.js project hier eenvoudig verbinding mee maken. Er zijn standaard credentials ingesteld, zoals root/password voor MariaDB/MySQL, de gebruiker user met wachtwoord password en standaard database servbay_default bij PostgreSQL.

Hieronder voorbeelden voor de verschillende databases. Installeer eerst steeds het juiste Node.js-databasepakket met npm install <pakketnaam>.

1. Verbinden met MongoDB

   Installeer het ORM-pakket mongoose:

   npm install mongoose

   Importeer en verbind vervolgens ergens in je project (zoals in app.js of een apart configuratiebestand):

   var mongoose = require('mongoose');
   
   // Verbind met lokaal draaiende MongoDB, database heet servbay-express-app
   // Standaard vereisen ServBay's MongoDB-instanties geen authenticatie
   mongoose.connect('mongodb://localhost/servbay-express-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true
   })
   .then(() => console.log('Connected to MongoDB'))
   .catch(err => console.error('MongoDB connection error:', err));

   Zorg dat het MongoDB-pakket in ServBay draait.

2. Verbinden met Redis

   Installeer de Redis-client redis:

   npm install redis

   Gebruik in je project:

   var redis = require('redis');
   // ServBay's standaard Redis draait op localhost:6379 zonder wachtwoord
   var client = redis.createClient({
       host: 'localhost',
       port: 6379
   });
   
   client.on('connect', function() {
       console.log('Connected to Redis');
   });
   
   client.on('error', function (err) {
     console.log('Redis Error: ' + err);
   });
   
   // Voorbeeld: key-value zetten en ophalen
   // client.set('mykey', 'Hello from Express!', redis.print);
   // client.get('mykey', function(err, reply) {
   //     if (err) throw err;
   //     console.log(reply); // Print "Hello from Express!"
   // });
   
   // Gebruik het client-object voor verdere Redis-operaties

   Zorg dat het Redis-pakket in ServBay draait.

3. Verbinden met MariaDB / MySQL

   MariaDB en MySQL worden op dezelfde manier benaderd, meestal via het mariadb- of mysql2-pakket. Hier een voorbeeld met mariadb:

   Installeer eerst het pakket:

   npm install mariadb # of: npm install mysql2

   Maak verbinding met de standaard gebruikersgegevens uit ServBay: root als gebruiker en “password” als wachtwoord.

   var mariadb = require('mariadb');
   // ServBay's standaard MariaDB/MySQL draait op localhost:3306
   var pool = mariadb.createPool({
     host: 'localhost',
     port: 3306, // standaard poort
     user: 'root', // standaard ServBay-gebruiker
     password: 'password', // standaard ServBay-wachtwoord
     database: 'servbay_express_app', // zelf in ServBay aanmaken indien nodig
     connectionLimit: 5 // poolgrootte
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB/MySQL");
       // Gebruik conn voor queries
       // conn.query("SELECT 1").then(...).catch(...).finally(() => conn.release());
       conn.release(); // na gebruik vrijgeven aan de pool
     })
     .catch(err => {
       console.log("Not connected due to error: " + err);
     });

   Controleer dat je vooraf in het databasebeheer van ServBay (zoals phpMyAdmin, Adminer) de database servbay_express_app hebt aangemaakt. Ook moet MariaDB/MySQL draaien in ServBay.

4. Verbinden met PostgreSQL

   Installeer de PostgreSQL-client pg:

   npm install pg

   Gebruik de standaard credentials (gebruiker user, wachtwoord password, standaard database servbay_default):

   var { Pool } = require('pg');
   // ServBay's standaard PostgreSQL draait op localhost:5432
   var pool = new Pool({
     user: 'user', // standaardgebruiker
     host: 'localhost',
     database: 'servbay_default', // of evt. een andere aangemaakte database
     password: 'password', // standaard wachtwoord
     port: 5432, // standaard poort
   });
   
   pool.connect((err, client, done) => {
     if (err) {
       console.error('PostgreSQL connection error:', err);
       return;
     }
     console.log('Connected to PostgreSQL');
     // Gebruik client voor queries
     // client.query('SELECT NOW()', (err, res) => { ... done(); });
     done(); // verbinding vrijgeven
   });
   
   // Of via async/await
   // try {
   //   const client = await pool.connect();
   //   console.log('Connected to PostgreSQL');
   //   // const res = await client.query('SELECT NOW()');
   //   // console.log(res.rows[0]);
   //   client.release(); // verbinding vrijgeven
   // } catch (err) {
   //   console.error('PostgreSQL connection error:', err);
   // }

   Zorg dat PostgreSQL draait in ServBay.

Samenvatting

Na het volgen van bovenstaande stappen heb je een Express.js-project succesvol opgezet, geconfigureerd en uitgevoerd met ServBay. Je hebt geleerd hoe je:

• Een project initialiseert met express-generator
• Je Express.js-app op een eigen poort draait
• Met ServBay’s Websites-functie een reverse proxy richt en via standaard HTTP/S-poorten toegang krijgt tot je Node.js-app
• In de ServBay-omgeving verbinding maakt met verschillende veelgebruikte databases

ServBay maakt het lokaal ontwikkelen en beheren van Node.js (Express.js)-applicaties aanzienlijk eenvoudiger. Zo kun je je maximaal focussen op de code. Extra functies zoals automatische SSL-certificaten, website-back-ups en logweergave verhogen bovendien het werkplezier en de efficiëntie tijdens lokale ontwikkeling.