---
# System prepended metadata

title: Configurer un VPS
tags: [' server', ' vps', support]

---

---
title: Configurer un VPS
tags: support, vps, server
robots: noindex, nofollow
author: Julien Noyer
---

# Héberger une application MEAN sur un VPS

![](https://i.imgur.com/IL2hc6d.jpg)

## Introduction

Une application développée sur la stack dite "**[M](https://docs.mongodb.com/?_ga=2.64824623.1642676613.1512819330-1761454187.1512819330)[E](http://expressjs.com/fr/)[A](https://angular.io/api)[N](https://nodejs.org/en/docs/)**" présente l'avantage d'être basé sur un seul langagee, à savoir la [**Javascrip**](https://developer.mozilla.org/fr/docs/Web/JavaScript), et cette avantage reste intéressant en terme de déploiement. Le technologie [**Javascrip**](https://developer.mozilla.org/fr/docs/Web/JavaScript) étant supportée chez tous les hébergeurs et les solutions qu'ils proposent, le déploiemeent est alors simplifié dans la mesure ou le choix de telle ou telle solution ne sont pas contraintes par le langage utilisé pour déveloperr l'application.

Les instructions qui vont suivre sont basées sur différrents tutoriels et peuvent être suives pour n'importe quel hébergeur proposant une offre qui donne accès à une connexion [**SSH**](https://fr.wikipedia.org/wiki/Secure_Shell) vers un serveur (privé ou mutualisé), il est primordial que la commande [**sudo**](https://fr.wikipedia.org/wiki/Sudo) soit autorisée sur le serveur. L'hébergeur qui est présentée dans ce tutoriel est [**Digital Ocean**](https://cloud.digitalocean.com) car il présente plusieurs avantages, notament celui d'être intégré dans le pack [**GitHub Education**](https://education.github.com).

---
<br><br><br><br><br><br>

# Configuration du Droplet (VPS) [Digital Ocean](https://cloud.digitalocean.com)

*Build Faster, Scale Easier. DigitalOcean's Optimized Droplets Saves Your Team Time*

![](https://i.imgur.com/yjGUQql.jpg)


## Sélection de l'offre Digital Ocean

L'outil proposé par [**Digital Ocean**](https://cloud.digitalocean.com) s'appel un Droplet, il faut se rendre dans la section **Create > Droplet** du site qui permet de les configurer et de suivre les étapes. Pour ce tutorel la configuration suivante est utilsée : 

- Distribution : Ubuntu 18.04.3 (LTS)x64
- Plan : 5 dollars/mo Standrad
- Datacenter : Amsterdam
- Authentication : One time passord


> Il est possible d'associer une clef SSH à votre [**VPS**](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel), nous conseillons de ne pas le faire pour pouvoir l'ajouter en ligne de commande pendant la configuration du serveur.

Une fois les étapes de configurations passées, un mail est envoyé par [**Digital Ocean**](https://cloud.digitalocean.com) contenant les information pour ce connecter au **Droplet** créé. Nous allons à présent utiliser ces identifiants pour nous connecter et configurer le **Droplet**.

<br>

## Première connexion au Droplet (VPS)

Comme dit précédemment peu importe l'hébergeur selectionner, les différentes commandes que nous allons utiliser sont applicables sur n'importe quel serveur [**Linux**](https://fr.wikipedia.org/wiki/Linux).

La connexion au serveur est faite en [**Secure Shell (SSH)**](https://fr.wikipedia.org/wiki/Secure_Shell) via un invite de commande avec la commande suivante : 

```
ssh root@ip.du.droplet
```

Un messagee s'affice alors dans le terminal vous demandant d'accepter la connexion au serveur : 

```
The authenticity of host 'ip.du.droplet (ip.du.droplet)' can't be established.
ECDSA key fingerprint is SHA256:ucLbhJljBojqwF2c/py/GABOdltQo7c6N53B+VFL3ZU.
Are you sure you want to continue connecting (yes/no)?
```

Il faut accepter la connexion pour ensuite indiquer le mot de passe reçu par mail : 

```
Warning: Permanently added 'ip.du.droplet' (ECDSA) to the list of known hosts.
root@ip.du.droplet's password:
```
A la première connexion sur le serveur avec l'identifiant **root**, il est demandé de changer le mote de passe. C'est une prremière étape de sécurité qui impose de ne pas garder le mot de passee généré par [**Digital Ocean**](https://cloud.digitalocean.com).

```
Changing password for root.
(current) UNIX password:
Enter new UNIX password:
Retype new UNIX password:
```

> Les mots de passe ne s'affichent pas, il faut veiller à bien les renseigner.

Une fois la connexion établie sur le serveur il faut avant toute chose s'assurer qu'il est à jour en tapant les commandes suivantes : 

```
apt-get update
apt-get upgrade
apt-get install
```

<br>

## Création du compte "admin"

Il va de soit que l'utilisation d'un compte nommé **root** est une faille de sécurité dans la mesure ou il sera le premier à être testé dans le cadre d'une attaque. C'est pourquoi la première étape qu'il faut suivre dans la configuration d'un server distant et l'ajout d'un compte sudo et la suppression du compte **root**. 

Pour créer un nouvel utilisateur il faut taper les commandes suivantes : 

```
adduser adminserveur
usermod -aG sudo adminserveur
su - adminserveur
```

> C'est 3 commandes permettent de créer un profil, de l'ajouter au groupe `sudo` et de et changer de profil utilisateur.

La dernière commande permettant de se changer de profil, il est à présent possible d'associer une clef [**SSH**](https://fr.wikipedia.org/wiki/Secure_Shell) au nouveau profil pour sécuriser la connexion au serveur avec cette utilisateur. Dans un premeier temps il faut créer un dossier et un fichier pour enregister la clef sur le serveur : 

```
mkdir ~/.ssh
chmod 700 ~/.ssh
nano ~/.ssh/authorized_keys
```

> La commande [**chmod**](https://fr.wikipedia.org/wiki/Chmod) permet de changer les droits en lectur/écriture sur un fichier ou un dossier.

La dernière commande ouvre l'éditeur [**Nano**](https://doc.ubuntu-fr.org/nano) dans lequel nous allons coller la clef [**SSH**](https://fr.wikipedia.org/wiki/Secure_Shell) de notre compte. Dans un autre invite de commande nous allons tous d'abord **créer une nouvelle clef si aucune n'est présente sur la machine** : 

```
ssh-keygen -t rsa
```

> Surr Mac pout vérifier si une clef est présente sur une machine il faut téperr la commande `cat ~/.ssh/id_rsa.pub`.

Un message s'affiche demandant d'indiquer le chemin vers la clef `.../.ssh/id_rsa`, **attention car si une clef existe déjà elle sera remplacée**.

> L'ajout d'une `passphrase` est recommandé pour sécuriser la clef.

Nous pouvons maintenant copier la clef que nous venons de créer avec la commande suivante : 

```
pbcopy < ~/.ssh/id_rsa.pub
```

Une fois la clef copiée il suffi de la coller dans la fenêtre [**Nano**](https://doc.ubuntu-fr.org/nano) ouverte précédemment pour l'associer au profil `adminserveur` créé sur le serveur. Nous enregistrons le fichier puis nous modifions les permissions sur le dossier `.ssh` avec la commande suivante : 

```
chmod 600  ~/.ssh/authorized_keys
```

> **NB** : les commandes présentées pour gérer les clefs SSH correspondent à l'OS Machintosh, si elles ne fonctionnent pas **pour Windows il est possbile d'utiliser [Putty](https://akril.net/cle-ssh-sous-windows-avec-putty/)**.
 
<br>

## Vérification du profil adminserveur

Une fois l'utilisateur `adminserveur` créé, il est primordial de s'assurer que la connexion SSH soit correctement configurer avant de passer aux étapes suivantes. **Tout en conservant la connexion avec le profil `root` actif**, nous ouvrons une nouvelle fenêtre d'invite de commande pour nous connecter à présent avec le profil `adminserveur` : 

```
ssh adminserveur@ip.du.droplet
```

Lorsque la connexion est établie nous sommes à présent connecté au serveur avec le profil `adminserveur`, nous testons à présent que nous sommes bien dans le groupe `sudo` avec la commande suivante : 

```
sudo ls
```

Le mot de passe nous est demandé et une fois renseigné aucun message d'erreur ne n'affiche, la configuration est correct nous poouvons donc passer à l'étape suivante.

> **NB** : S'il y à un problème à l'une des étapes de vérification, il faut revoir soit vérifier la clef `ssh` soit le `chmod` du fichier `authorized_keys`.

<br>

## Gestion du profil root

Nous allons à présent bloquer la possibilité de s'identifier avec l'utilisateur `root` et nous allons imposer la connexion via clef SSH. Le fichier de configuration `sshd_config` nous permet de gérer les méthode de connexion  : 

```
sudo nano /etc/ssh/sshd_config
````

Dans ce fichier il faut changer les valeur de `PermitRootLogin` et `PasswordAuthentication` puis sauvegarder le fichier : 

```
PermitRootLogin no
PasswordAuthentication no
```

Une fois la configuration modifier il faut redémarrer le service [**SSH**](https://fr.wikipedia.org/wiki/Secure_Shell) : 

```
sudo service ssh restart
```

Il est à présent nécessaire de vérifier la configguration, il faut d'abord nous deconnecter pour ensuite relancer la connexion [**SSH**](https://fr.wikipedia.org/wiki/Secure_Shell) avec le nouveau compte : 

```
ssh adminserveur@ip.du.droplet
```

> **NB** : il ne faut surtout pas se déconnecter du profil `root` avant d'avoir vérifié la connexion `ssh` du profil `adminserveur` au risque de ne plus pouvoir se reconnecter au serveur.

---
<br><br><br><br><br><br>

# Préparation du VPS pour le déploiement

![](https://i.imgur.com/MmNyJgf.jpg)


Une fois la problématique de connexion sur le [**VPS**](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel) passsée, nous pouvons à présent nus occuperr d'installer les modules pour déployer notre application Javascript. Les dernières versions des **Droplets** [**Digital Ocean**](https://cloud.digitalocean.com) intégrent la commande [**Git**](https://git-scm.com), si ce n'est pas le cas, il faut l'installer aveec la commande : 

```
sudo apt-get install git-all
```

> Cette commande vous permet également de mettre tous les ouutils [**Git**](https://git-scm.com) à jour.

<br>

## Installation des modules serveurs

Pour commencer nous allons installer les modules nous permettant d'utiliser un environement - [**Javascrip**](https://developer.mozilla.org/fr/docs/Web/JavaScript) sur notre serveur, à savoir [NodeJS](https://nodejs.org/en/) avec les commandes suivantes : 

```
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
sudo apt-get install nodejs
```

> Il faut **vérifier** avant de taper la commande le **numéro de version** de NodeJS.

La commande NPM est à présent disponible sur notre serveur, nous allons en profiter pour installer [**PM2**](https://pm2.keymetrics.io), un module qui nous permettra de génrer nos commande `npm start` et [**LetsEncrypt**](https://letsencrypt.org/fr/) qui nous permettra de géré nos certificat SSL: 

```
sudo npm i -g pm2
sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt
```

Nous allons à présent installer [**MongoDB**](https://www.mongodb.com/fr) qui nous permettra de gérer les données de notre application : 

```
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927
echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list
sudo apt-get install -y mongodb
```

Pour finir nous allons installer [**NGINX**](https://www.nginx.com), un [**reverse-proxy**](https://fr.wikipedia.org/wiki/NGINX) qui nous permettra de gérer les URLS de notre VPS : 

```
sudo apt-get install nginx
```

<br>

## Activation du service NGINX

Pour terminer la préparation du VPS nous allons activer [**NGINX**](https://www.nginx.com) et définir son comportement par defaut pour indiquer que nous redirigeons toutes les requêtes HTTP en HTTPS que nouos configurerons plus tard  avec [**LetsEncrypt**](https://letsencrypt.org/fr/).

Pour commencer nous ajoutons ouvrir le fichier`default` dans la configuration de [**NGINX**](https://www.nginx.com) et l'ouvrons dans [**Nano**](https://doc.ubuntu-fr.org/nano) : 

```
sudo nano /etc/nginx/sites-enabled/default
```

Une fois [**Nano**](https://doc.ubuntu-fr.org/nano) ouvert, nous remplaçons le code affiché par le suivant avant de fermer et d'enregistrer le fichier : 

```
# HTTP — redirect all traffic to HTTPS
server {
    listen 80;
    listen [::]:80 default_server ipv6only=on;
    return 301 https://$host$request_uri;
}
```

Nous allons à présent crypter les requêtes grâce à la commande `dhparam` afin de gérer les reqêtes [**HTTPS**](https://fr.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure) :

```
sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
```

Nous devons maintenant créer un fichier de configuration [**SSL**](https://fr.wikipedia.org/wiki/Transport_Layer_Security), afin de rendre les requêtes [**HTTPS**](https://fr.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure) valident. Pour cela nous crééons un fichier `ssl-params.conf` :

```
sudo nano /etc/nginx/snippets/ssl-params.conf
```

Et nous ajoutons le code suivant avant d'enregister le fichier : 

```
# See https://cipherli.st/ for details on this configuration
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";
ssl_ecdh_curve secp384r1; # Requires nginx >= 1.1.0
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off; # Requires nginx >= 1.5.9
ssl_stapling on; # Requires nginx >= 1.3.7
ssl_stapling_verify on; # Requires nginx => 1.3.7
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload";
add_header X-Frame-Options DENY;
add_header X-Content-Type-Options nosniff;

# Add our strong Diffie-Hellman group
ssl_dhparam /etc/ssl/certs/dhparam.pem;
```

Pour finir la configuration de [**NGINX**](https://www.nginx.com) nous devons autoriser certains type de connexion avec les commandes suivantes : 

```
sudo ufw allow OpenSSH
sudo ufw allow http
sudo ufw allow https
sudo ufw enable
```

Nous pouvons à présent démarrer le service [**NGINX**](https://www.nginx.com) pour finir notre configuration, dans un premier temps nous devons redémarrer notre VPS : 

```
sudo reboot
```

Il faut ensuite nous reconnecter pour lancer le service [**NGINX**](https://www.nginx.com) : 

```
sudo systemctl start nginx
```

<br>

## Activation du service [MongoDB](https://www.mongodb.com/fr)

Pour configurer [**MongoDB**](https://www.mongodb.com/fr) en tant que service nous allons créer un fichier qui nous permettra de le configurer :

```
sudo nano /etc/systemd/system/mongodb.service
```

Nous allons coller le code suivant avant d'enrigistrer le fichier : 

```
[Unit]
Description=High-performance, schema-free document-oriented database
After=network.target

[Service]
User=mongodb
ExecStart=/usr/bin/mongod --quiet --config /etc/mongod.conf

[Install]
WantedBy=multi-user.target
```

Nous pouvons à présent lancer le service [**MongoDB**](https://www.mongodb.com/fr) avec la commande suivante : 

```
sudo systemctl start mongodb
```

> Pour vérifier le statut du service il faut taper la commande `sudo systemctl status mongodb`.

<br>

## Activation du service [PM2](https://pm2.keymetrics.io)

Nous allons à présent configurer [**PM2**](https://pm2.keymetrics.io) pour qu’il puisse redémarrer si le serveur redémarre en tapant la commande suivante :

```
pm2 startup systemd
```

Cette dernière commande permet d’afficher un code à taper pour valider la configuration qui ressemble au code suivant : 

```
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u dws --hp /home/adminuser
```

---
<br><br><br><br><br><br>

# Déployer l'application sur le [VPS](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel)

![](https://i.imgur.com/A5TfmL2.jpg)


L'application que nous allons installer sur le VPS est basée sur la stack "**[M](https://docs.mongodb.com/)[E](http://expressjs.com/fr/)[A](https://angular.io/api)[N](https://nodejs.org/en/docs/)**" et nous l'avons versionnée sur [**GitHub**](https://github.com). Pour l'installer sur notre [**VPS**](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel) nous allons simplement créer un dossier à la racine de notre dossier utilisateur de notre [**VPS**](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel).

Une fois le dossier crée il suffi de la connecter au répertoire [**GitHub**](https://github.com) pour récuperer les fichier sources du projet, installer les dépendances et créer les fichiers nécessaires au démarrage du projet (comme les fichiers d'environnement par exemple). Ce tutoriel ne prend pas en compte ces notions qui sont spécifiques à chaque projet.

<br>

## Gestion des certificats [SSL](https://fr.wikipedia.org/wiki/Transport_Layer_Security)

Les certificats [**SSL**](https://fr.wikipedia.org/wiki/Transport_Layer_Security) nous permettent de configurer l'accés [**HTTPS**](https://fr.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure) à nos noms de domaines. Avant de commencer cette configuration sur le [**VPS**](https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel) nous avons dans un premier temps acheté un nom dee domaine que nous avons fait pointé sur l'[**adresse IP**](https://fr.wikipedia.org/wiki/Adresse_IP) de notre **Droplet**.

Une fois le nom de domaine correctement configuré, nous devons dans un premier temps stoper [**NGINX**](https://www.nginx.com) et lancer la commande [**LetsEncrypt**](https://letsencrypt.org/fr/) pour générer les clef SSL : 

```
sudo systemctl stop nginx.service
sudo /opt/letsencrypt/letsencrypt-auto certonly --standalone
```

Nous suivons les instruction de [**LetsEncrypt**](https://letsencrypt.org/fr/) pour nous identifier puis nous définissions à la fin du processus notre nom de domaine (sans https://). Une fois le nom de domaine enregistré un message de validation affiche l'endroit ou sont stockées les clef [**SSL**](https://fr.wikipedia.org/wiki/Transport_Layer_Security) : 

```
Congratulations! Your certificate and chain have been saved at:
/etc/letsencrypt/live/<nom.de.domaine>/fullchain.pem
Your key file has been saved at:
/etc/letsencrypt/live/<nom.de.domaine>/privkey.pem
```

> Lorsque le certificat arrive à expiration vous pouvez le renouveler en tapant la commande `sudo /opt/letsencrypt/letsencrypt-auto renew`

Les clef que nous venons de créer vont nous permettre à présent d'ajouter un fichier de configuration dans [**NGINX**](https://www.nginx.com) afin d'associer correctement les cleefs [**SSL**](https://fr.wikipedia.org/wiki/Transport_Layer_Security) à notre nom de domaine. Nous ouvons donc un nouuveau fichier dans [**Nano**](https://doc.ubuntu-fr.org/nano) : 

```
sudo nano /etc/nginx/sites-enabled/<nom.de.domaine>
```

> Il est recommander de nommer le fichier par le nom de domaine

Dans le fichier qui vient de s'ouvir nous collons le code suivant pour gérer les clef [**SSL**](https://fr.wikipedia.org/wiki/Transport_Layer_Security) pour ce nom de domaine : 

```
# HTTPS proxy all requests to the Node app
server {
    # Enable HTTP/2
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name <nom.de.domaine>;

    # Use the LetsEncrypt certificates
    ssl_certificate /etc/letsencrypt/live/<nom.de.domaine>/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<nom.de.domaine>/privkey.pem;

    # Include the SSL configuration from cipherli.st
    include snippets/ssl-params.conf;

    location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-NginX-Proxy true;
        proxy_pass http://localhost:<port>/;
        proxy_ssl_session_reuse off;
        proxy_set_header Host $http_host;
        proxy_cache_bypass $http_upgrade;
        proxy_redirect off;
    }
}

```

Nous prenons soins de bien modifier les informations pour qu'elles correspondent à notre configuration : 

- **nom.de.domaine** : le domaine que nous avons fait poointer sur le serveur
- **port** : le port qui corrrespond à notre application

Pour vérifier notre configuration [**NGINX**](https://www.nginx.com) nous tapons la commande `sudo nginx -t` qui noous affiche en résultat : 

```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```

Notre configuration est à présent terminé, nous pouvons pour la finaliser et activer le nom dde domaine ssur notre VPS, redemmarer le service [**NGINX**](https://www.nginx.com) avec la commande suivante : 

```
sudo systemctl start nginx.service
```

<br>

## Renouveler le certificat automatiquement avec [CertBot](https://certbot.eff.org)

Le certificat SSL que nous avons généré n'est valable que pour 90 jours, c'est à dire qu'il à besoin d'être renouveler avant la fin de cette prériode pour que notre nom de domaine conserve sa certification. Pour ne pas avoir à renouveler le certificat manuellement nous allons mettre en place un [CRON](https://fr.wikipedia.org/wiki/Cron) sur le serveur pour qu'il se renouvel automatiquement.

Dans un premier temps nous devons mettre à jour le VPS et supprimer notre précédente installation de Letsencrypt et CertBot : 

```
sudo apt-get remove letsencrypt
sudo apt-get remove certbot
sudo apt-get install software-properties-common
sudo apt-get update
```

> Ces commandes ne suppriment pas le ou les certificats déjà créés sur le VPS.

Nous allons à présent installer la dernière version de CertBot et un plugin Nginx essentiel pour la suite de la configuration : 

```
sudo apt-get install certbot
sudo apt-get install python3-certbot-nginx
```

A la fin de l'installation la commande `certbot` est disponible sur le VPS, elle va nous permettre de sélectionner le ou les noms de domaine dont nous souhaitons gérer la mise à jour automatique des certificats. Nous tapons donc la commande : 

```
sudo certbot --nginx
```

Cette commande nous affiche la liste des certificats préseent sur le serveur : 

```
Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: <nom.de.domaine>
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel):
```

Nous tapons `1` puis sur la touche `enter` pour valider notrre choix suite à quoi deux nouvelles questions nous sont posées : 

```
What would you like to do?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: Attempt to reinstall this existing certificate
2: Renew & replace the cert (limit ~5 per 7 days)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

...


Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
```

Nous sélectionnons la première réponse à chaque question puis la fin du processus s'exécute pour au final afficher un message de confirmation.

> Nous pouvons renouveler les certificats à la main de cette façon `sudo certbot renew --nginx`.

Il est possible que la commande `sudo certbot --nginx` ne s'exécute pas en raison d'un problème de syntaxe dans le ou les fichiers de configuration de nom de domaine dans le dossier `site-enabled` de Nginx. Dans ce cas il faut éditer ces fichiers pour vérifier les commentaires qui peuvent présenter des problèmes de copier/coller.

> Plus de détails sur ce fil de discution https://bit.ly/2TiTiYt.

Une fois la configuration des certificats terrminée, nnous pouvons créer à présent une tâche en CRON qui va renouveller automatiquement le certificat. Nous tapons la commandee suivante pour ouvrir le fichier `crontab` : 

```
sudo crontab -e
```

> Il est demandé à cette étape de séectionner un éditeur.

Puis nous ajoutons à la fin du fichier le code suivant : 

```
# Certbot auto-renew
SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

0 0 1 * * root certbot -q renew --nginx
```

> Le code de renouvellement est exécuter le 1er de chaque mois.

Nous fermons et enregistrons le fichier `crontab` puis nous tapons la commande suivante pour testeer notre configuration : 

```
sudo openssl x509 -noout -dates -in /etc/letsencrypt/live/<nom.de.domaine>/cert.pem
```

Cette commande affiche la date du futur renouvellmement et nous pouvons a présent pour nous assurer que Nginx continue de fonctionner correctement en reedémarrant le service : 

```
sudo systemctl restart nginx.service
```

<br>

## Lancer l'application Javascript

Tout est prêt sur notre VPS pour configurer un nom de domaine en [**HTTPS**](https://fr.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure) qui pointee sur un port spécifique. Nous allons donc à présent utiliser [**PM2**](https://pm2.keymetrics.io) pour lancer notre application en tapant la commander suivante dans le dossier racine dee notre application :

```
pm2 start server.js --name APPname
```

---
<br><br><br><br><br><br>

# Ressources

![](https://i.imgur.com/iFcSll4.jpg)

## Liens utiles

La liste ci-dessous contient les liens utiles cité dans ce document.

- **Javascrip** https://developer.mozilla.org/fr/docs/Web/JavaScript
- **VPS** https://fr.wikipedia.org/wiki/Serveur_dédié_virtuel
- **Git** https://git-scm.com
- **GitHub** https://github.com
- **Commande sudo** https://fr.wikipedia.org/wiki/Sudo
- **Digital Ocean** https://cloud.digitalocean.com
- **GitHub Education** https://education.github.com
- **Linux** https://fr.wikipedia.org/wiki/Linux
- **Secure Shell (SSH)** https://fr.wikipedia.org/wiki/Secure_Shell
- **Nano** https://doc.ubuntu-fr.org/nano
- **PM2** https://pm2.keymetrics.io
- **LetsEncrypt** https://letsencrypt.org/fr/
- **Certbot** https://certbot.eff.org
- **MongoDB** https://www.mongodb.com/fr
- **Express.js** http://expressjs.com/fr/
- **Angular.io** https://angular.io/
- **Node.js** https://nodejs.org/en/docs/
- **NGINX** https://www.nginx.com
- **CRON** https://fr.wikipedia.org/wiki/Cron
- **reverse-proxy** https://fr.wikipedia.org/wiki/NGINX
- **HTTPS** https://fr.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure
- **SSL** https://fr.wikipedia.org/wiki/Transport_Layer_Security
- **Adresse IP** https://fr.wikipedia.org/wiki/Adresse_IP
- **Commande chmod** https://fr.wikipedia.org/wiki/Chmod
- **chmod** https://fr.wikipedia.org/wiki/Chmod