TOC

Comment configurer une application Node.js pour la production sur CentOS 7

introduction

Node.js is an open source Javascript runtime environment for easily building server-side and networking applications. La plate-forme fonctionne sous Linux, OS X, FreeBSD et Windows, et ses applications sont écrites en JavaScript. Node.js applications can be run at the command line but we will teach you how to run them as a service, so they will automatically restart on reboot or failure, so you can use them in a production environment.

Dans ce didacticiel, nous couvrirons la configuration d’un environnement Node.js prêt à la production composé de deux serveurs CentOS 7; un serveur exécutera les applications Node.js gérées par PM2, tandis que l'autre fournira aux utilisateurs un accès à l'application via un proxy inverse Nginx vers le serveur d'applications.

La version Ubuntu de ce tutoriel peut être trouvéehere.

Conditions préalables

Ce guide utilise deux serveurs CentOS 7with private networking (dans le même centre de données). Le réseau privé peut être configuré sur de nouveaux serveurs lors de leur création (dans la sectionSelect additional options). Nous nous y référerons par les noms suivants:

  • app: Le serveur sur lequel nous installerons le runtime Node.js, votre application Node.js et PM2.

  • web: Le serveur sur lequel nous installerons le serveur Web Nginx, qui agira en tant que proxy inverse pour votre application. Les utilisateurs accéderont à l’adresse IP publique de ce serveur pour accéder à votre application Node.js.

[.note] #Note: Reportez-vous auxDigitalOcean Documentation - How to Enable Private Networking on Droplets si vous avez l'intention d'utiliser un serveur existant sur lequel aucun réseau privé n'est actuellement configuré.
#

Avant de commencer ce guide, vous devez avoir un utilisateur normal non root avec les privilègessudo configurés sur vos deux serveurs. C'est l'utilisateur sous lequel vous devez vous connecter à vos serveurs. Vous pouvez apprendre à configurer un compte utilisateur régulier en suivant nosinitial server setup guide for CentOS 7.

Commandes exécutées sur le serveurapp: 

an_example_command_on_app

Commandes exécutées sur le serveurweb: 

an_example_command_on_web

Il est possible d'utiliser un seul serveur pour ce didacticiel, mais vous devrez apporter quelques modifications en cours de route. Utilisez simplement l’adresse IP localhost, c.-à-d. 127.0.0.1, partout où l'adresse IP privée du serveurapp est utilisée.

Voici un schéma de ce que sera votre configuration après avoir suivi ce tutoriel:

Reverse Proxy to Node.js Application

Si vous souhaitez pouvoir accéder à votre serveurweb via un nom de domaine, au lieu de son adresse IP publique, achetez un nom de domaine puis suivez ces tutoriels:

Commençons par installer le runtime Node.js sur le serveurapp.

[[step-1 -—- Installing-node-js]] == Étape 1 - Installation de Node.js

Nous installerons la dernière version LTS de Node.js, sur le serveurapp.

Connectez-vous en SSH à votre serveurapp en utilisant l'utilisateur normal non root avec les privilègessudo.

Sur le serveurapp, utilisonscurl pour télécharger le fichier de configuration du référentiel RPM deNodeSource: 

curl -L -o nodesource_setup.sh https://rpm.nodesource.com/setup_10.x

CURL utilisera le protocole HTTPS pour télécharger le script de configuration sur votre serveur, avec la sortie comprenant les informations relatives au téléchargement: 

Output  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 11109  100 11109    0     0  70128      0 --:--:-- --:--:-- --:--:-- 70757

Ensuite, vous devriez inspecter le contenu du script. La commande suivante ouvrira le script de configuration NodeSource dans la console de vos serveurs, que vous pourrez ensuite croiser avec lesNodeSource setup script (à partir du référentiel Github de NodeSource Distributions) pour confirmer le script qui s'est téléchargé correctement: 

vi nodesource_setup.sh

Une fois satisfait du fichier, quittezvi en tapant:q àquit et revenez à la ligne de commande.

Exécutons maintenant le script de configuration pour installer le référentiel RPM NodeSource. Cela nous permettra d’accéder au référentiel de NodeSource depuis le gestionnaire de packages deyum: 

sudo -E bash nodesource_setup.sh

Le script affiche des informations sur la configuration pour notre référence: 

Output## Installing the NodeSource Node.js 10.x repo...

## Inspecting system...

+ rpm -q --whatprovides redhat-release || rpm -q --whatprovides centos-release || rpm -q --whatprovides cloudlinux-release || rpm -q --whatprovides sl-release
+ uname -m

## Confirming "el7-x86_64" is supported...

+ curl -sLf -o /dev/null 'https://rpm.nodesource.com/pub_10.x/el/7/x86_64/nodesource-release-el7-1.noarch.rpm'

## Downloading release setup RPM...

+ mktemp
+ curl -sL -o '/tmp/tmp.2aCcULVx8n' 'https://rpm.nodesource.com/pub_10.x/el/7/x86_64/nodesource-release-el7-1.noarch.rpm'

## Installing release setup RPM...

+ rpm -i --nosignature --force '/tmp/tmp.2aCcULVx8n'

## Cleaning up...

+ rm -f '/tmp/tmp.2aCcULVx8n'

## Checking for existing installations...

+ rpm -qa 'node|npm' | grep -v nodesource

## Run `sudo yum install -y nodejs` to install Node.js 10.x and npm.
## You may also need development tools to build native addons:
     sudo yum install gcc-c++ make
## To install the Yarn package manager, run:
     curl -sL https://dl.yarnpkg.com/rpm/yarn.repo | sudo tee /etc/yum.repos.d/yarn.repo
     sudo yum install yarn

Avant d'installer Node.js, il est important de nettoyer toutes les informations mises en cache deyum. Effacer le cache garantira queyum utilise la connexion réseau pour obtenir Node.js à partir de notre nouveau référentiel NodeSource (ce qui empêchera tout conflit potentiel causé par des packages obsolètes): 

sudo yum clean all

Ensuite, nous allons télécharger et rendre utilisables toutes les métadonnées pour les dépôtsyum actuellement activés. Cela garantira que nos requêtesyum sont complétées le plus rapidement possible: 

sudo yum makecache fast

Pour compiler et installer des modules complémentaires natifs à partir denpm, nous devons également installer des outils de construction: 

sudo yum install -y gcc-c++ make

Nous pouvons maintenant installer la dernière version du paquet Node.js: 

sudo yum install -y nodejs

Vérifiez que Node est installé en vérifiant sa version avec cette commande: 

node -v

Votre sortie indiquera le numéro de version que vous utilisez: 

Outputv10.16.3

Le moteur d'exécution Node.js est maintenant installé et prêt à exécuter une application. Écrivons une application Node.js.

[[step-2 -—- creation-the-node-js-application]] == Étape 2 - Création de l'application Node.js

Nous allons maintenant créer une application Hello World qui renvoie simplement"Hello World" à toutes les requêtes HTTP. Il s'agit d'un exemple d'application qui vous aidera à configurer Node.js, que vous pouvez remplacer par votre propre application - assurez-vous simplement de modifier votre application pour écouter les adresses IP et les ports appropriés.

Parce que nous voulons que notre application Node.js traite les requêtes provenant de notre serveur proxy inverse (web), nous utiliserons l’interface de réseau privé de notre serveurapp pour la communication entre serveurs. Recherchez l'adresse de réseau privé de votre serveurapp.

Si vous utilisez un Droplet DigitalOcean comme serveur, vous pouvez rechercher l’adresse IP privée du serveur via le serviceMetadata. Sur le serveurapp, utilisez la commandecurl pour récupérer l'adresse IP maintenant: 

curl -sw "\n" http://169.254.169.254/metadata/v1/interfaces/private/0/ipv4/address

Vous voudrez copier le résultat (l'adresse IP privée), car il sera utilisé pour configurer l'application Node.js.

Ensuite, créez et ouvrez votre application Node.js pour l’éditer. Pour ce tutoriel, nous utiliseronsvi pour éditer un exemple d'application appeléhello.js: 

vi hello.js

Insérez le code suivant dans le fichier et assurez-vous de remplacer l’adresse IP privée du serveurapp par les deux élémentsAPP_PRIVATE_IP_ADDRESS en surbrillance. Si vous le souhaitez, vous pouvez également remplacer le port en surbrillance,8080, aux deux emplacements (assurez-vous d'utiliser un port non-admin, c.-à-d. 1024 ou plus):

hello.js

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(8080, 'APP_PRIVATE_IP_ADDRESS');
console.log('Server running at http://APP_PRIVATE_IP_ADDRESS:8080/');

Maintenant, enregistrez et quittez en appuyant surESC pour quitter le mode--INSERT--, suivi de:wq verswrite etquit en une seule commande.

Cette application Node.js écoute simplement sur l'adresse IP et le port spécifiés, et renvoie"Hello World" avec un code de réussite HTTP200. Cela signifie que l'application est uniquement accessible à partir de serveurs sur le même réseau privé, comme notre serveurweb.

Si vous souhaitez tester si votre application fonctionne, exécutez cette commandenode sur le serveurapp: 

node hello.js

[.note] #Note: L'exécution d'une application Node.js de cette manière bloquera les commandes supplémentaires jusqu'à ce que l'application soit supprimée en appuyant surCTRL+C.
#

Cela économisera beaucoup de débogage Nginx si nous testons d'abord que notre serveurweb est capable de communiquer avec l'application Node.js surapp.

Afin de tester l'application, ouvrez une autre session de terminal et connectez-vous à votre serveurweb. Étant donné que le serveur Web se trouve sur le même réseau privé, il doit pouvoir atteindre l'adresse IP privée du serveurapp en utilisantcurl. Veillez à remplacer l’adresse IP privée du serveurapp parAPP_PRIVATE_IP_ADDRESS et par le port si vous l’avez modifiée: 

curl http://APP_PRIVATE_IP_ADDRESS:8080

Si vous voyez la sortie suivante, l'application fonctionne correctement et écoute sur l'adresse IP et le port appropriés: 

Node Application OutputHello World

Si vous ne voyez pas la sortie appropriée, assurez-vous que votre application Node.js est en cours d'exécution et configurée pour écouter l'adresse IP et le port appropriés.

Sur le serveurapp, assurez-vous de tuer l'application en appuyant surCTRL+C.

[[step-3 -—- installation-and-using-pm2]] == Étape 3 - Installation et utilisation de PM2

Nous allons maintenant installer PM2, un gestionnaire de processus pour les applications Node.js. PM2 fournit un moyen simple de gérer et de démonaliser les applications (les exécuter en tant que service).

Nous utiliserons Node Packaged Modules (NPM), qui est essentiellement un gestionnaire de packages pour les modules Node qui s'installe avec Node.js, pour installer PM2 sur notre serveurapp. Utilisez cette commande pour installer PM2: 

sudo npm install pm2@latest -g

Nous aborderons quelques utilisations de base des PM2.

La première chose que vous voudrez faire est d'utiliser la commandepm2 start pour exécuter votre application,hello.js, en arrière-plan: 

pm2 start hello.js

Cela ajoute également votre application à la liste de processus de PM2, qui est sortie chaque fois que vous démarrez une application: 

Output┌──────────┬────┬──────┬───────┬────────┬─────────┬────────┬─────────────┬──────────┐
│ App name │ id │ mode │ pid   │ status │ restart │ uptime │ memory      │ watching │
├──────────┼────┼──────┼───────┼────────┼─────────┼────────┼─────────────┼──────────┤
│ hello    │ 0  │ fork │ 30099 │ online │ 0       │ 0s     │ 14.227 MB   │ disabled │
└──────────┴────┴──────┴───────┴────────┴─────────┴────────┴─────────────┴──────────┘

Comme vous pouvez le voir, PM2 assigne automatiquement unApp name (basé sur le nom de fichier, sans l'extension.js) et un PM2id. PM2 conserve également d'autres informations, telles que lesPID du processus, son état actuel et l'utilisation de la mémoire.

Les applications exécutées sous PM2 seront automatiquement redémarrées si l'application se bloque ou est tuée, mais une étape supplémentaire doit être franchie pour que l'application se lance au démarrage du système (démarrage ou redémarrage). Heureusement, PM2 fournit un moyen simple de le faire, la sous-commandestartup.

La sous-commandestartup génère et configure un script de démarrage pour lancer PM2 et ses processus gérés au démarrage du serveur. Vous devez également spécifier le système d'initialisation sur lequel vous exécutez, qui estsystemd, dans notre cas: 

sudo pm2 startup systemd

Vous verrez une sortie comme celle-ci, indiquant que le service PM2 a été installé: 

Output[PM2] Generating system init script in /etc/systemd/system/pm2.service
[PM2] Making script booting at startup...
[PM2] -systemd- Using the command:
      su root -c "pm2 dump && pm2 kill" && su root -c "systemctl daemon-reload && systemctl enable pm2 && systemctl start pm2"
[PM2] Dumping processes
[PM2] Stopping PM2...
[PM2] All processes have been stopped and deleted
[PM2] PM2 stopped
[PM2] Done.

Pour que PM2 sache quelles applications démarrer au démarrage, nous devons enregistrer la liste de processus actuelle. Pour sauvegarder la liste: 

pm2 save

Vous verrez une sortie comme celle-ci, indiquant que la liste de processus PM2 a été enregistrée: 

Output[PM2] Saving current process list...
[PM2] Successfully saved in /home/deployer/.pm2/dump.pm2

Maintenant, vos applications gérées par PM2 devraient démarrer automatiquement au démarrage.

PM2 fournit de nombreuses sous-commandes qui vous permettent de gérer ou de rechercher des informations sur vos applications. Notez que l'exécution depm2 sans aucun argument affichera une page d'aide, comprenant des exemples d'utilisation, qui couvre l'utilisation de PM2 plus en détail que cette section du didacticiel.

Arrêtez une application avec cette commande (spécifiez les PM2App name ouid): 

pm2 stop example

Redémarrez une application avec cette commande (spécifiez les PM2App name ouid): 

pm2 restart example

La liste des applications actuellement gérées par PM2 peut également être consultée avec la sous-commandelist: 

pm2 list

Vous trouverez plus d'informations sur une application spécifique en utilisant la sous-commandeinfo (spécifiez les PM2App name ouid): 

pm2 info example

Le moniteur de processus PM2 peut être extrait avec la sous-commandemonit. Ceci affiche l'état de l'application, l'utilisation du processeur et de la mémoire: 

pm2 monit

[.note] #Note: L'exécution de la commandemonit de PM2 bloquera les commandes supplémentaires jusqu'à ce que l'application soit supprimée en appuyant surCTRL+C.
#

Maintenant que votre application Node.js est en cours d’exécution et gérée par PM2, configurons le proxy inverse.

[[step-4 -—- setting-up-an-nginx-reverse-proxy-server]] == Étape 4 - Configuration d'un serveur proxy inverse Nginx

Maintenant que votre application est en cours d'exécution et écoute sur une adresse IP privée, vous devez configurer un moyen permettant à vos utilisateurs d'y accéder. Nous allons configurer un serveur Web Nginx en tant que proxy inverse à cette fin. Ce tutoriel va configurer un serveur Nginx de toutes pièces. Si vous avez déjà une configuration de serveur Nginx, vous pouvez simplement copier le bloclocation dans le bloc serveur de votre choix (assurez-vous que l'emplacement n'est pas en conflit avec le contenu existant de votre serveur Web).

Sur le serveurweb, installons le packageepel-release en utilisant yum: 

sudo yum install epel-release

Ensuite, installez Nginx: 

sudo yum install nginx

Ouvrez maintenant le fichier de configuration Nginx pour le modifier: 

sudo vi /etc/nginx/nginx.conf

Tout d'abord, recherchez la ligne oùserver_name est défini, dans le bloc serveur par défaut. Ça devrait ressembler a quelque chose comme ca:

nginx.conf excerpt — server_name (before)

server_name _;

Mettez à jour le nom du serveur pour remplacer le trait de soulignement (_) par votre propre nom de domaine pour la directiveserver_name (ou l'adresse IP si vous n'avez pas configuré de domaine).

nginx.conf excerpt — server_name (after)

server_name your-domain;

Ensuite, recherchez la ligne oùlocation / est défini (généralement quelques lignes sous le nom_serveur), dans le même bloc de serveur par défaut. Ça devrait ressembler a quelque chose comme ca:

nginx.conf excerpt — location / (before)

        location / {
        }

Remplacez-le par le bloc de code suivant et assurez-vous de remplacer l'adresse IP privée du serveurapp par lesAPP_PRIVATE_IP_ADDRESS. De plus, modifiez le port (8080) si votre application est configurée pour écouter sur un autre port:

/etc/nginx/nginx.conf excerpt — location / (after)

    location / {
        proxy_pass http://APP_PRIVATE_IP_ADDRESS:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

Cela configure le serveurweb pour répondre aux requêtes à sa racine. En supposant que notre serveur est disponible àyour-domain, accéder àhttp://your-domain/ via un navigateur Web enverrait la demande à l'adresse IP privée du serveur d'application sur le port8080, qui serait reçue et répondue par le Application Node.js.

Vous pouvez ajouter des blocslocation supplémentaires au même bloc serveur pour fournir l'accès à d'autres applications sur le même serveurweb. Par exemple, si vous exécutiez également une autre application Node.js sur le serveurapp sur le port8081, vous pouvez ajouter ce bloc d'emplacement pour en autoriser l'accès viahttp://your-domain/app2:

Configuration Nginx - Emplacements supplémentaires 

    location /app2 {
        proxy_pass http://APP_PRIVATE_IP_ADDRESS:8081;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

Une fois que vous avez terminé de modifier le (s) bloc (s) d'emplacement pour vos applications, enregistrez et quittez en appuyant surESC pour quitter le mode--INSERT--, suivi de:wq àwrite etquit en une seule commande.

Sur le serveurweb, redémarrez Nginx: 

sudo systemctl start nginx

Nous voulons ensuite nous assurer que Nginx est exécuté à chaque redémarrage du serveur: 

sudo systemctl enable nginx

La commandeenable doit fournir la sortie suivante 

OutputCreated symlink from /etc/systemd/system/multi-user.target.wants/nginx.service to /usr/lib/systemd/system/nginx.service.

Vous pouvez également confirmer que Nginx est en cours d'exécution et est activé, en demandant son statut àsystemctl: 

sudo systemctl status nginx

La commande status affichera les informations de configuration pour le service Nginx: 

Output● nginx.service - The nginx HTTP and reverse proxy server
   Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
   Active: active (running) since Mon 2019-10-14 09:37:23 UTC; 3min 29s ago
 Main PID: 12818 (nginx)
   CGroup: /system.slice/nginx.service
           ├─12818 nginx: master process /usr/sbin/nginx
           └─12819 nginx: worker process

Oct 14 09:37:23 centos-s-1vcpu-1gb-sgp1-01 systemd[1]: Starting The nginx HTTP and reverse proxy server...
Oct 14 09:37:23 centos-s-1vcpu-1gb-sgp1-01 nginx[12814]: nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
Oct 14 09:37:23 centos-s-1vcpu-1gb-sgp1-01 nginx[12814]: nginx: configuration file /etc/nginx/nginx.conf test is successful
Oct 14 09:37:23 centos-s-1vcpu-1gb-sgp1-01 systemd[1]: Failed to read PID from file /run/nginx.pid: Invalid argument
Oct 14 09:37:23 centos-s-1vcpu-1gb-sgp1-01 systemd[1]: Started The nginx HTTP and reverse proxy server.

Enfin, donnez à Nginx la possibilité de relayer le trafic viaSecurity-Enhanced Linux (SELinux). SELinux fournit une couche de sécurité qui implémente le contrôle obligatoire (MAC) dans le noyau Linux. Chaque objet du système d'exploitation (processus, descripteur de fichier, fichier, etc.) est étiqueté avec un contexte SELinux qui définit les autorisations et les opérations que l'objet peut effectuer.

Nginx est étiqueté avec le contextehttpd_t et par conséquent, un certain nombre de configurations sont bloquées par SELinux, sauf autorisation explicite. Pour illustrer cela, exécutez la commande suivante pour confirmer que le service Nginx est étiquetéhttpd_t: 

ps -eZ

Cette commande fournit des informations sur l'état du processus. Recherchez les informations de processus spécifiques à Nginx pour voir l'étiquette. Vous verrez leshttpd_t, d'une manière similaire à ce qui suit: 

Output...
system_u:system_r:httpd_t:s0    10208 ?        00:00:00 nginx
system_u:system_r:httpd_t:s0    10209 ?        00:00:00 nginx
...

Voyons maintenant le statut des booléens par défaut liés à l'étiquette SELinuxhttpd_t. Nous pouvons afficher ces informations en exécutant la commande suivante: 

getsebool -a

Nous ne sommes intéressés que par les booléens associés àhttpdpour ce tutoriel: 

Output...
httpd_anon_write --> off
httpd_builtin_scripting --> on
httpd_can_check_spam --> off
httpd_can_connect_ftp --> off
httpd_can_connect_ldap --> off
httpd_can_connect_mythtv --> off
httpd_can_connect_zabbix --> off
httpd_can_network_connect --> off
httpd_can_network_connect_cobbler --> off
httpd_can_network_connect_db --> off
httpd_can_network_memcache --> off
httpd_can_network_relay --> off
httpd_can_sendmail --> off
httpd_dbus_avahi --> off
httpd_dbus_sssd --> off
httpd_dontaudit_search_dirs --> off
httpd_enable_cgi --> on
httpd_enable_ftp_server --> off
httpd_enable_homedirs --> off
httpd_execmem --> off
httpd_graceful_shutdown --> on
httpd_manage_ipa --> off
httpd_mod_auth_ntlm_winbind --> off
httpd_mod_auth_pam --> off
httpd_read_user_content --> off
httpd_run_ipa --> off
httpd_run_preupgrade --> off
httpd_run_stickshift --> off
httpd_serve_cobbler_files --> off
httpd_setrlimit --> off
httpd_ssi_exec --> off
httpd_sys_script_anon_write --> off
httpd_tmp_exec --> off
httpd_tty_comm --> off
httpd_unified --> off
httpd_use_cifs --> off
httpd_use_fusefs --> off
httpd_use_gpg --> off
httpd_use_nfs --> off
httpd_use_openstack --> off
httpd_use_sasl --> off
httpd_verify_dns --> off
...

Les deux booléens à noter sonthttpd_can_network_connect ethttpd_can_network_relay. LeRedhat Documentation fournit des détails sur chacun des booléenshttpd et leur fonction associée (si vous souhaitez en savoir plus sur chaque booléen), bien que vous trouverez ci-dessous les explications des deux booléens liés à ce didacticiel: 

...
httpd_can_network_connect: When disabled, this Boolean prevents HTTP scripts and modules from initiating a connection to a network or remote port. Enable this Boolean to allow this access.
httpd_can_network_relay: Enable this Boolean when httpd is being used as a forward or reverse proxy.
...

Puisque notre configuration ne fait que relayer le trafic, nous devons juste dire à SELinux que le serveurhttpd, dans notre cas Nginx, peut utiliser le réseau pour relayer le trafic dans la configuration de proxy inverse que nous avons mise en place. Nous utiliserons l'indicateur-P, pour nous assurer que les changements sont permanents (l'omission de cet indicateur entraînera le retour dehttpd_can_network_relay à son état par défaut, désactivé, au redémarrage du serveur): 

sudo setsebool -P httpd_can_network_relay on

En supposant que votre application Node.js est en cours d'exécution et que votre application et les configurations Nginx sont correctes, vous devriez pouvoir accéder à votre application via le proxy inverse du serveurweb. Essayez-le en accédant à l'URL de votre serveurweb (son adresse IP publique ou son nom de domaine).

[.note] #Note: Si vous prévoyez également d'utiliser votre serveurweb pour héberger d'autres sites (en tant qu'hôtes virtuels conventionnels), vous devrez également activer leshttpd_can_network_connect .
#

Conclusion

Votre application Node.js s'exécute maintenant derrière un proxy inverse Nginx. Cette configuration de proxy inverse est suffisamment souple pour permettre à vos utilisateurs d'accéder à d'autres applications ou à du contenu Web statique que vous souhaitez partager.

De plus, si vous cherchez à crypter les transmissions entre votre serveur Web et vos utilisateurs,here is a tutorial that will help you get HTTPS (TLS/SSL) support set up.

Related