Comment héberger un site web avec Caddy sur Ubuntu 16.04

Une version antérieure de ce didacticiel a été écrite par Mateusz Papiernik .

L’auteur a sélectionné la Wikimedia Foundation pour recevoir un don de 200 $ dans le cadre du Write for DOnations programme.

introduction

Caddy est un serveur Web conçu autour de la simplicité et de la sécurité, doté de nombreuses fonctionnalités utiles pour l’hébergement de sites Web. Par exemple, il peut automatiquement obtenir et gérer les certificats TLS à l’adresse Let’s Encrypt pour activer HTTPS, et inclut la prise en charge de HTTP / 2. HTTPS est un système de sécurisation du trafic entre vos utilisateurs et votre serveur. Il devient rapidement l’attente de base de tout site Web en production. Sans cela, Chrome et Firefox vous avertiront que votre site Web n’est pas sécurisé si les utilisateurs tentent de se connecter. information.

Auparavant, la méthode recommandée pour installer Caddy était de télécharger des fichiers binaires pré-construits à partir du site Web du projet Caddy. Cependant, les récents changements intervenus dans le fonctionnement des licences de Caddy font que vous n’êtes plus autorisé à utiliser ces binaires pré-construits à des fins commerciales, sauf si vous payez des frais de licence, même si vous utilisez uniquement Caddy à l’interne au sein d’une entreprise. Heureusement, le code source de Caddy est toujours entièrement open-source et vous pouvez créer Caddy vous-même pour éviter les problèmes de licence.

Dans ce didacticiel, vous allez créer Caddy à partir de la source et l’utiliser pour héberger un site Web sécurisé avec HTTPS. Ensuite, vous configurerez Caddy à l’aide d’un + Caddyfile +, vous installerez les plugins Caddy et vous apprendrez à mettre à niveau votre installation lorsqu’une nouvelle version est publiée.

Conditions préalables

Avant de commencer ce guide, vous devez disposer des éléments suivants:

Étape 1 - Caddy de construction

Au cours de cette étape, vous allez récupérer le code source de Caddy et vous assurer de pouvoir le compiler. Caddy est écrit dans Go, utilisez donc l’outil de ligne de commande + go get pour récupérer le code source de Caddy à partir de GitHub et enregistrez-le dans` + $ GOPATH / src / github.com / mholt / caddy`:

go get github.com/mholt/caddy/caddy

+ go get + utilise Git pour cloner le code à partir de GitHub. Git est un système de contrôle de version, ce qui signifie qu’il enregistre l’état du projet lorsque vous apportez des modifications et vous permet de revenir à n’importe quel état précédent de l’historique du projet. Par défaut, la commande + go get + télécharge la dernière version du code source, mais il serait judicieux d’utiliser la dernière version stable de Caddy plutôt que l’ajout le plus récent au référentiel, qui sera probablement à mi-chemin entre communiqués. Les versions non publiées peuvent avoir des bugs ou des fonctionnalités cassées à moitié implémentées. En revanche, la dernière version stable est plus susceptible de se compiler et de fonctionner correctement.

Pour afficher toutes les versions précédentes, naviguez d’abord dans le répertoire dans lequel vous avez enregistré le code source de Caddy:

cd $GOPATH/src/github.com/mholt/caddy

Ensuite, affichez toutes les versions précédentes de Caddy à l’aide de la commande + git tag +:

git tag

Vous verrez une sortie semblable à celle-ci:

Outputv0.10.0
v0.10.1
v0.10.10
v0.10.11
v0.10.12
v0.10.2
v0.10.3
v0.10.4
v0.10.5
. . .

Chaque fois qu’une version stable de Caddy est publiée, les auteurs l’indiquent dans Git en ajoutant une balise. Vous pouvez utiliser Git pour rétablir le code tel qu’il était lors de la dernière version stable. Recherchez le numéro de version le plus élevé dans la sortie. Au moment de la rédaction de ce document, il s’agit de «+ v0.10.12 +».

Puisque vous modifierez la source ultérieurement pour installer certains plugins, créez un nouveau branch pour stocker vos modifications. Dans Git, les branches permettent de travailler simultanément sur différentes versions de code. Ils vous permettent de basculer entre une version du code avec vos modifications personnelles et la version «officielle» du code. Pour créer une nouvelle branche, utilisez la commande + git checkout +, qui permet de changer de branche. L’option + -b + demandera à Git de créer une nouvelle branche avec le nom ` à partir de la version `. Remplacez «» par le nom de votre choix et «» par la dernière version stable identifiée précédemment:

git checkout -b "" ""

Cela ramènera votre version du code source de Caddy à la dernière version stable et vous serez dans une nouvelle branche où vous pourrez conserver vos modifications dans le code. Lors de la prochaine mise à jour de Caddy, vous fusionnerez les modifications dans cette nouvelle branche.

À ce stade, vous êtes tous prêts à construire Caddy en utilisant l’outil + go install pour compiler le code source en binaire. Même si la syntaxe de la commande peut sembler vouloir installer Caddy à partir d’un site Web (github.com), il s’agit en fait du chemin d’accès local sur le serveur sur lequel nous venons de travailler avec le référentiel Git (`+ $ GOPATH / src / github .com / mholt / caddy + `):

go install github.com/mholt/caddy/caddy

Après avoir compilé le code source, exécutez la commande + caddy + pour démarrer le serveur. Notez que pour que cela fonctionne correctement, votre chemin Go doit être défini sur + $ GOPATH / bin +, comme décrit dans les conditions préalables:

caddy

Cette commande produira la sortie suivante:

OutputActivating privacy features... done.
http://:2015
WARNING: File descriptor limit 1024 is too low for production servers. At least 8192 is recommended. Fix with "ulimit -n 8192".

L’avertissement peut être ignoré pour le moment, car nous le résoudrons lors de la configuration des divers fichiers de configuration requis par Caddy. Appuyez sur + CTRL + C + pour quitter cette commande.

Pour démontrer que Caddy est construit à partir de votre source, ajoutez une ligne au code source de Caddy pour imprimer du texte lorsque Caddy est exécuté. Utilisez + nano + ou votre éditeur préféré pour ouvrir + $ GOPATH / src / github.com / mholt / caddy / caddy / caddymain / run.go +:

nano $GOPATH/src/github.com/mholt/caddy/caddy/caddymain/run.go

Ce fichier traite les options transmises à la commande Caddy et constitue l’une des premières opérations exécutées lors de l’exécution de Caddy.

Localisez la fonction + Run () +, et ajoutez le texte en surbrillance en tant que première ligne entre les accolades. Cela imprimera le texte «Bonjour de Caddy!» Avant que le serveur ne s’exécute:

$ GOPATH / src / github.com / mholt / caddie / caddie / caddymain / run.go

. . .
// Run is Caddy's main() function.
func Run() {


       flag.Parse()

       caddy.AppName = appName
       . . .
}

Appuyez sur + CTRL + X +, + Y +, puis + ENTER + pour sauvegarder et fermer le fichier. Si vous exécutez à nouveau les commandes + go install + 'et + caddy + , vous verrez le message que vous avez ajouté à la fonction + Run () + `en haut de la sortie:

go install github.com/mholt/caddy/caddy
caddy
Output
Activating privacy features... done.
http://:2015
WARNING: File descriptor limit 1024 is too low for production servers. At least 8192 is recommended. Fix with "ulimit -n 8192".

Avec cela, vous avez réussi à construire Caddy à partir de la source. Vous pouvez supprimer la ligne ajoutée de + $ GOPATH / src / github.com / mholt / caddy / caddy / caddymain / run.go + si vous le souhaitez, mais si vous le faites, vous devrez recompiler le code. À l’étape suivante, vous installerez Caddy en tant que service afin qu’il se lance automatiquement au démarrage, puis vous en ajusterez les paramètres de propriété et d’autorisation pour assurer la sécurité du serveur.

Étape 2 - Installation de Caddy

Maintenant que vous avez vérifié que vous êtes capable de créer Caddy, il est temps de configure un systemd service pour que Caddy puisse être lancé automatiquement au démarrage du système. Systemd est une solution complète de gestion des processus sous Linux. Caddy est installé avec un fichier + caddy.service que les systèmes peuvent utiliser pour gérer le service Caddy. Ce fichier de service émet certaines hypothèses sur l’environnement dans lequel Caddy s’exécutera. Par conséquent, il est probable que vous souhaiterez modifier certaines choses avant de l’installer.

Pour commencer, copiez le fichier binaire Caddy dans + / usr / local / bin +, l’emplacement standard pour les fichiers binaires non gérés par le gestionnaire de paquets d’Ubuntu et ne constituant pas la clé du fonctionnement du système:

sudo cp $GOPATH/bin/caddy /usr/local/bin/

Ensuite, changez la propriété du binaire Caddy en utilisateur * root *. Notez que bien que * root * appartienne à Caddy, il est conseillé de ne pas l’exécuter avec le compte * root * car cela pourrait constituer un problème de sécurité majeur en cas de vulnérabilité de Caddy. Cependant, le fait de posséder le fichier binaire avec * root * empêchera d’autres comptes de le modifier avec les autorisations que nous définirons. Ceci est souhaitable car si un autre processus avec des autorisations plus basses que Caddy est compromis, il ne sera pas en mesure de modifier Caddy pour obtenir plus de contrôle du système:

sudo chown root:root /usr/local/bin/caddy

Ensuite, définissez les autorisations du fichier binaire sur + 755 + - ceci donne à * root * des autorisations complètes en lecture / écriture / exécution pour le fichier, tandis que les autres utilisateurs ne pourront que le lire et l’exécuter:

sudo chmod 755 /usr/local/bin/caddy

Etant donné que le processus Caddy ne fonctionnera pas en tant que * racine *, Linux l’empêchera de se lier aux ports +: 80 + ou +: 443 + (les ports standard pour HTTP et HTTPS, respectivement), car il s’agit d’un opérations privilégiées. Pour être visible sur le Web, Caddy doit être lié à l’un de ces ports. Sinon, les utilisateurs devront ajouter un numéro de port spécifique à l’URL du serveur de leur navigateur pour afficher le contenu qu’il servira.

L’utilisation de la commande + setcap + peut permettre au processus Caddy de se lier à des ports bas sans s’exécuter en tant que * racine *. + setcap + est utile pour permettre à un processus d’effectuer une opération privilégiée spécifique sans lui donner les pleines autorisations de superutilisateur. + cap_net_bind_service = + ep + indique que vous souhaitez attribuer au processus les autorisations + CAP_NET_BIND_SERVICE +, qui permet la liaison aux ports privilégiés:

sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/caddy

Après avoir défini les autorisations pour le binaire Caddy, créez un répertoire dans lequel vous stockerez les fichiers de configuration de Caddy. Ceux-ci doivent être conservés dans un sous-répertoire + / etc / +, qui est l’emplacement recommandé par le système de hiérarchie de systèmes de fichiers pour les fichiers de configuration:

sudo mkdir /etc/caddy

Définissez le propriétaire de ce répertoire sur * root * et son groupe sur * www-data *. * www-data * est un compte d’utilisateur standard pour l’exécution de serveurs Web. Il s’agit du compte qui exécutera Caddy. Définir la propriété de cette manière garantira que vous avez un accès en lecture et en écriture au fichier binaire (via le compte * root *) et que le processus Caddy peut également lire et écrire dessus (car il fonctionnera sous la forme * www-data *), mais les autres utilisateurs n’y auront pas accès. Lorsqu’il est utilisé avec + chown +, l’indicateur + -R + modifie la propriété de tous les sous-répertoires et fichiers du répertoire + / etc / caddy +, plutôt que du seul répertoire:

sudo chown -R root:www-data /etc/caddy

Dans une étape ultérieure, ce didacticiel expliquera comment activer TLS automatique avec Let’s Encrypt. En prévision de cela, créez un répertoire pour stocker tous les certificats TLS que Caddy obtiendra et donnez-lui les mêmes règles de propriété que le répertoire + / etc / caddy +:

sudo mkdir /etc/ssl/caddy
sudo chown -R root:www-data /etc/ssl/caddy

Caddy doit pouvoir écrire des certificats dans ce répertoire et en lire un extrait afin de chiffrer les demandes. Pour cette raison, modifiez les autorisations du répertoire + / etc / ssl / caddy + afin qu’il ne soit accessible que par * root * et * www-data *:

sudo chmod 0770 /etc/ssl/caddy

Ensuite, créez un répertoire pour stocker les fichiers que Caddy hébergera. + / var / www / + est l’emplacement standard de facto pour stocker les fichiers servis via HTTP:

sudo mkdir /var/www

Définissez ensuite le propriétaire et le groupe du répertoire sur * www-data *, utilisateur par défaut pour les opérations de serveur Web sur Ubuntu:

sudo chown www-data:www-data /var/www

Caddy est configuré via un fichier nommé + Caddyfile +; il peut être utile de penser que cela ressemble à + ​​httpd.conf + dans Apache ou au répertoire de configuration + sites-available + de Nginx. Le service systemd pour Caddy s’attend à ce que ce fichier soit stocké dans + / etc / caddy +, donc créez + Caddyfile + en utilisant + touch +:

sudo touch /etc/caddy/Caddyfile

Pour installer le service Caddy, copiez le fichier d’unité systemd du code source de Caddy dans + / etc / systemd / system +, l’emplacement des services systemd. Cela permettra à systemd de découvrir et de contrôler le service Caddy:

sudo cp $GOPATH/src/github.com/mholt/caddy/dist/init/linux-systemd/caddy.service /etc/systemd/system/

Modifiez les autorisations du fichier de service afin qu’il ne puisse être modifié que par son propriétaire, * root *:

sudo chmod 644 /etc/systemd/system/caddy.service

Ensuite, utilisez l’outil de ligne de commande + systemctl + pour recharger systemd. Ceci va permettre à systemd de détecter le service Caddy, bien que nous ne l’exécutons pas encore:

sudo systemctl daemon-reload

Vérifiez si le système a détecté le service Caddy en exécutant + systemctl status:

sudo systemctl status caddy
Output● caddy.service - Caddy HTTP/2 web server
  Loaded: loaded (/etc/systemd/system/caddy.service; disabled; vendor preset: enabled)
  Active: inactive (dead)
    Docs: https://caddyserver.com/docs

Si vous voyez cette même sortie, Caddd a été correctement détecté par systemd.

La dernière étape de ce processus d’installation, avant d’écrire la configuration pour Caddy, consiste à ajuster votre pare-feu. Vous devriez déjà exécuter un pare-feu utilisant UFW, comme indiqué dans le guide de configuration initiale du serveur. Un pare-feu est un outil important pour protéger la sécurité de votre serveur, car il vous permet de configurer les ports accessibles au public pour toute personne externe à laquelle se connecter et ceux dont l’accès est protégé. Si d’autres processus exposent un port sur votre serveur, le pare-feu empêche tout accès à ceux-ci, ce qui réduit les possibilités pour un attaquant de compromettre des logiciels vulnérables.

Utilisez l’outil de ligne de commande + ufw + pour désactiver le pare-feu pour les ports +: 80 + et +: 443 +, ce qui permettra à Caddy de communiquer via HTTP et HTTPS, respectivement:

sudo ufw allow 80
sudo ufw allow 443

Utilisez + ufw status + pour vérifier si vos modifications ont fonctionné:

sudo ufw status
OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80                         ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80 (v6)                    ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Votre installation de Caddy est terminée, mais pour le moment, il n’est pas configuré pour faire quoi que ce soit. Nous verrons ensuite comment utiliser cette nouvelle installation de Caddy et la configurer pour servir un site Web.

Étape 3 - Configuration du caddy

Pour que votre installation de Caddy soit utilisée comme serveur Web fonctionnel, vous devez modifier quelques paramètres. Au fur et à mesure de ces modifications, nous examinerons la syntaxe de la configuration + Caddyfile +, explorerons quelques scénarios de configuration et servirons une page d’espace réservé via HTTP.

Pour commencer la configuration de Caddy, créez un fichier HTML de base à diffuser. HTML est le langage qui décrit le contenu des pages Web. Ce fichier servira d’espace réservé pour illustrer l’hébergement d’un site Web avec Caddy. Si vous décidez d’utiliser Caddy pour héberger votre propre site Web, vous remplacez ce fichier par le contenu que vous souhaitez héberger. Placez ce fichier dans le répertoire + / var / www / + que vous avez configuré précédemment. Le nom + index.html + est significatif, car il fait référence à la page «par défaut» de la plupart des serveurs Web et les utilisateurs accédant à votre domaine recevront ce fichier en premier:

sudo touch /var/www/index.html

Ouvrez le nouveau fichier avec votre éditeur préféré:

sudo nano /var/www/index.html

Ajoutez le contenu suivant au fichier:

/var/www/index.html

<!DOCTYPE html>
<html>
 <head>
   <title>Hello from Caddy!</title>
 </head>
 <body>
   <h1 style="font-family: sans-serif">This page is being served via Caddy</h1>
 </body>
</html>

Cela affichera un en-tête avec le texte "* Cette page est en cours de traitement via Caddy *".

Enregistrez et fermez le fichier, puis ouvrez le fichier de configuration + Caddyfile + que vous avez créé précédemment:

sudo nano /etc/caddy/Caddyfile

Editez le fichier pour inclure le contenu suivant:

/ etc / caddy / Caddyfile

:80 {
   root /var/www
}

Sur la première ligne, +: 80 + définit le nom d’hôte du serveur - dans Caddy, cela s’appelle une étiquette. Le nom d’hôte est le nom de domaine où Caddy répondra aux demandes. Dans ce cas, réglez-le sur +: 80 +, ce qui signifie le port +: 80 + du serveur. Cela empêche le serveur de fonctionner sur HTTPS pour le moment, puisque Caddy essaiera de l’activer automatiquement, mais nous souhaitons le faire via un plugin.

Par défaut, Caddie tente d’extraire un certificat SSL de Let’s Encrypt en rendant une ressource disponible sur HTTP, telle que l’hébergement d’un fichier. Toutefois, si vous souhaitez exécuter un service interne à l’aide de Caddy, vous pouvez ne pas vouloir exposer le serveur à Internet public. L’utilisation d’un plugin vous permet d’utiliser le défi Let’s Encrypt DNS. Cela implique que Caddie crée un enregistrement DNS «TXT» pour prouver le contrôle du serveur et vous permet de récupérer des certificats sans nécessairement accepter les demandes HTTP extérieures. Cela vous laisse plus d’options pour exécuter Caddy à l’avenir.

Après +: 80 + se trouve un bloc de configuration, placé entre accolades, dans lequel iront les configurations pour le site. Sur la ligne suivante, nous voyons le + root + directive. Les directives sont les options de configuration réelles de Caddy, et leur ajout modifie le comportement de Caddy lors de la consultation du site Web. Les directives peuvent avoir des arguments, qui sont des options sur la manière dont la directive doit prendre effet. Dans ce cas, la directive + root + a un argument: + / var / www +. Cette directive définit le répertoire dans lequel les fichiers que Caddy doit servir sont situés. Cependant, les directives ne sont pas nécessaires pour avoir des arguments. Par exemple, vous pouvez ajouter la directive + gzip + sans aucun argument pour compresser les pages Web avant leur envoi au client, accélérant ainsi leur chargement.

/ etc / caddy / Caddyfile

:80 {
   root /var/www

}

Les directives peuvent être configurées avec des sous-directives offrant des fonctionnalités supplémentaires. Ceux-ci sont placés dans leurs propres blocs de configuration, en utilisant à nouveau des accolades. Par exemple, bien que la directive + gzip + fonctionne seule, nous pourrions utiliser la sous-directive + ext + pour ne compresser que certains types de fichiers, ou la sous-directive + niveau + pour contrôler le niveau de compression qui sera appliqué (1 étant le le plus bas et 9 étant le plus élevé).

/ etc / caddy / Caddyfile

:80 {
   root /var/www
   gzip



}

Caddy a un grand nombre de directives différentes pour de nombreux cas d’utilisation. Par exemple, la directive https://caddyserver.com/docs/fastcgi [+ fastcgi +] pourrait être utile pour activer PHP. La directive https://caddyserver.com/docs/markdown [+ markdown +] peut être utilisée pour convertir automatiquement les fichiers Markdown en HTML avant de les servir, ce qui peut être utile pour créer un blog simple.

Enregistrez et fermez le + Caddyfile +, et vérifiez que tout fonctionne correctement. Utilisez + systemctl + pour démarrer le service Caddy:

sudo systemctl start caddy

Ensuite, exécutez + systemctl status + pour trouver des informations sur l’état du service Caddy:

sudo systemctl status caddy

Vous verrez ce qui suit:

Output● caddy.service - Caddy HTTP/2 web server
  Loaded: loaded (/etc/systemd/system/caddy.service; disabled; vendor preset: enabled)
  Active:  (running) since Sat 2018-01-27 11:37:06 UTC; 7min ago
    Docs: https://caddyserver.com/docs
Main PID: 2973 (caddy)
   Tasks: 6
  Memory: 3.2M
     CPU: 24ms
  CGroup: /system.slice/caddy.service
          └─2973 /usr/local/bin/caddy -log stdout -agree=true -conf=/etc/caddy/Caddyfile -root=/var/tmp

Jan 27 11:37:06 caddy-tutorial-testing-0 systemd[1]: Started Caddy HTTP/2 web server.
Jan 27 11:37:06 caddy-tutorial-testing-0 caddy[2973]: Activating privacy features... done.
Jan 27 11:37:06 caddy-tutorial-testing-0 caddy[2973]: http://
Jan 27 11:37:06 caddy-tutorial-testing-0 caddy[2973]: 2018/01/27 11:37:06 http://

Si vous naviguez sur votre domaine, vous devriez maintenant voir que Caddy est en cours d’exécution et que votre exemple de page Web devrait s’afficher. Après confirmation, utilisez + systemctl + pour arrêter le service Caddy, car il reste encore quelques modifications à apporter:

sudo systemctl stop caddy

Bien que Caddy inclue un grand nombre de directives par défaut, il ne peut pas répondre à tous les cas d’utilisation possibles et vous souhaiterez peut-être ajouter davantage de fonctionnalités au serveur. Maintenant que nous savons que Caddy diffuse le contenu comme prévu, nous verrons comment étendre les fonctionnalités de Caddy à l’aide de plugins.

Étape 4 - Utiliser les plugins

Les plugins sont un moyen de changer le comportement de Caddy. Ce sont généralement de petits fragments de code que nous pouvons insérer dans Caddy pour ajouter plus de directives à des cas d’utilisation spécifiques. Le moyen le plus simple de comprendre les plugins est d’intervenir directement et d’en essayer un, nous allons donc installer le plugin + minify +. Ce plugin supprime les excès d’espace et le code redondant de certains fichiers, en réduisant la taille de chacun d’entre eux, contribuant ainsi à accélérer les temps de chargement.

Commencez par revenir à l’emplacement où Go a enregistré le code source de Caddy, car vous devrez le modifier pour installer le plug-in:

cd $GOPATH/src/github.com/mholt/caddy

Ouvrez à nouveau le fichier + run.go + de Caddy. Comme nous l’avons dit précédemment, c’est l’une des premières parties de Caddy à être exécutée et c’est l’emplacement où les plugins sont installés.

nano caddy/caddymain/run.go

Dans ce fichier, vous verrez une déclaration + import ressemblant à ceci:

$ GOPATH / src / github.com / mholt / caddie / caddie / caddymain / run.go

. . .
import (
   "errors"
   "flag"
   "fmt"
   "io/ioutil"
   "log"
   "os"
   "runtime"
   "strconv"
   "strings"

   "gopkg.in/natefinch/lumberjack.v2"

   "github.com/xenolf/lego/acmev2"

   "github.com/mholt/caddy"
   // plug in the HTTP server type
   _ "github.com/mholt/caddy/caddyhttp"

   "github.com/mholt/caddy/caddytls"
   // This is where other plugins get plugged in (imported)
)
. . .

Pour installer un plugin, ajoutez + _" github.com/path/to/plugin "+ à cette directive + import +. Certains plugins peuvent nécessiter quelques légères modifications de la configuration. Assurez-vous donc de lire la documentation correspondant à ceux que vous installez. Vous pouvez trouver une liste des plugins populaires dans le volet gauche de la documentation Caddy, sous * Plugins *.

Le référentiel GitHub du plugin + minify + est hacdias/caddy-minify, ajoutez donc le texte suivant au bas de la déclaration d’importation:

$ GOPATH / github.com / mholt / caddy / caddy / caddymain / run.go

. . .
import (
   . . .
   "github.com/mholt/caddy/caddytls"
   // This is where other plugins get plugged in (imported)


)

Vous devez valider votre code lorsque vous le modifiez afin que, lors de la fusion de nouvelles mises à jour, ces modifications ne soient pas perdues. Si vous n’avez jamais validé de code sur ce serveur, vous devez définir un nom et un courrier électronique afin que Git puisse vous identifier dans les journaux. La commande + git config vous permet de définir ces options, et l’indicateur` + - global` les applique à tous les référentiels sur lesquels vous pourrez travailler à l’avenir. Sauf si vous poussez du code dans un référentiel public tel que GitHub, ces détails ne seront pas rendus publics.

git config --global user.email ""
git config --global user.name ""

Maintenant que vous avez défini votre nom d’utilisateur et votre adresse e-mail, ajoutez les fichiers que vous avez modifiés à stage de Git (un cache utilisé pour stocker l’état du code avant la validation) en exécutant ce qui suit:

git add -A .

Maintenant, lancez + git commit + pour sauvegarder vos modifications dans la branche courante. L’option + -m + vous permet de définir un message de validation afin que vous puissiez noter ce que vous avez modifié. Ce message peut être trouvé en consultant les journaux de Git:

git commit -m "Added minify plugin"

Vous avez maintenant le chemin du plug-in dans votre code, mais vous devez toujours télécharger le plug-in localement pour que Go puisse y accéder. Cette commande récupérera automatiquement toutes les dépendances de Caddy lorsqu’elle sera exécutée à partir du répertoire + $ GOPATH / src / github.com / mholt / caddy +:

go get ./...

Chaque fois que vous ajoutez un nouveau plugin, vous devez reconstruire Caddy. En effet, Go est un langage de programmation compilé, ce qui signifie que le code source est transformé en code machine avant exécution. Votre modification de la déclaration d’importation a modifié le code source, mais n’affectera pas le binaire tant qu’il n’aura pas été compilé.

Utilisez la commande + go install pour compiler Caddy:

go install github.com/mholt/caddy/caddy

Si Caddy a été construit avec succès, cette commande se fermera sans sortie. Copiez le binaire généré dans + / usr / local / bin + et configurez les autorisations pour le binaire comme vous l’avez fait précédemment - vous devez suivre ces étapes à chaque fois que vous reconstruisez Caddy pour en assurer la fonctionnalité et la sécurité.

sudo cp $GOPATH/bin/caddy /usr/local/bin/
sudo chown root:root /usr/local/bin/caddy
sudo chmod 755 /usr/local/bin/caddy
sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/caddy

Pour démontrer que le plug-in a été installé avec succès, ouvrez votre + Caddyfile +.

sudo nano /etc/caddy/Caddyfile

Activez le plugin en ajoutant la ligne suivante au bloc de configuration:

/ etc / caddy / Caddyfile

:80 {
   root /var/www
   gzip

}

Maintenant démarrez votre serveur en utilisant + systemctl +:

sudo systemctl start caddy

Caddy est maintenant en cours d’exécution et réduira au minimum les fichiers qu’il sert, y compris le fichier + index.html + que vous avez créé précédemment. Vous pouvez observer la "minification" au travail en utilisant cURL, un outil de ligne de commande pour effectuer des requêtes Web. Si vous exécutez + curl + sans options ni indicateurs, le contenu d’une page Web sera récupéré et affiché dans le terminal. Exécutez la commande suivante pour demander le fichier + index.html à Caddy, en remplaçant` ++ `par votre domaine.

curl http://

Vous verrez la sortie suivante. Notez que tout l’espace inutile a été supprimé, ce qui montre que le plugin + minify + a fonctionné.

Output<!doctype html><title>Hello from Caddy!</title><h1 style=font-family:sans-serif>This page is being served via Caddy</h1>

Cette même méthode d’installation fonctionnera pour d’autres plugins Caddy. Pour vous familiariser davantage avec l’ajout de plugins, installez le plugin + tls.dns.digitalocean + afin d’activer automatiquement le trafic HTTPS sécurisé.

Étape 5 - Activer TLS automatique avec Let’s Encrypt

Caddy active HTTPS par défaut en utilisant Let’s Encrypt, ce qui est utile car il est facile d’obtenir les détails de HTTPS erronés. L’approche de Caddy en HTTPS est sécurisée et ne vous oblige pas à approfondir la configuration pour chiffrer votre trafic. Cependant, Caddy utilise par défaut la méthode + HTTP-01 + pour vérifier avec Let Encrypt que vous êtes bien le propriétaire de votre domaine. Cette méthode implique la publication d’un fichier spécial (contenant une réponse à un défi envoyé par Let’s Encrypt) à un emplacement spécifique du site Web. Bien que cette méthode fonctionne, votre site Web doit être accessible au public. Cela peut être un problème avec certaines configurations de pare-feu ou si vous utilisez Caddy en tant que service interne pour votre entreprise.

Alternativement, vous pouvez installer le plugin Caddy + tls.dns.digitalocean +, qui utilisera la méthode de vérification + DNS-01 +. Ce plugin s’authentifie avec Let’s Encrypt en ajoutant un nouvel enregistrement DNS «TXT» pour votre domaine, qui n’affectera pas le fonctionnement de votre site Web. Il utilise l’API de DigitalOcean pour contrôler DNS, ce qui vous donne la possibilité d’extraire un certificat même si votre serveur n’est pas accessible publiquement. Pour plus d’informations sur les différents types d’enregistrements DNS, consultez notre Introduction vers DigitalOcean DNS.

La méthode d’installation du plugin Caddy + tls.dns.digitalocean + est presque identique à celle utilisée pour l’installation du plugin + minify +. Pour commencer, ouvrez + $ GOPATH / src / github.com / mholt / caddy / caddy / caddymain / run.go +:

nano $GOPATH/src/github.com/mholt/caddy/caddy/caddymain/run.go

Ajoutez l’emplacement du plugin:

$ GOPATH / github.com / mholt / caddy / caddy / caddymain / run.go

. . .
import (
   . . .
   "github.com/mholt/caddy/caddytls"
   // This is where other plugins get plugged in (imported)

   _ "github.com/hacdias/caddy-minify"

)

Pour mettre à jour Caddy, accédez au référentiel source de Caddy et validez les modifications apportées à Git:

cd $GOPATH/src/github.com/mholt/caddy
git add -A .
git commit -m "Add DigitalOcean DNS provider"

Ensuite, installez toutes les dépendances et construisez Caddy, comme vous l’avez fait précédemment:

go get ./...
go install github.com/mholt/caddy/caddy

Assurez-vous que Caddy est arrêté via + systemctl +, puis terminez l’installation du plug-in en copiant le binaire Caddy nouvellement créé et en définissant une fois de plus sa propriété et ses autorisations:

sudo systemctl stop caddy
sudo cp $GOPATH/bin/caddy /usr/local/bin/
sudo chown root:root /usr/local/bin/caddy
sudo chmod 755 /usr/local/bin/caddy
sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/caddy

Ensuite, configurez Caddy pour qu’il fonctionne avec l’API de DigitalOcean afin de définir des enregistrements DNS. Accédez à l’onglet API de votre compte DigitalOcean et sélectionnez * Générer un nouveau jeton *:

image: https: //assets.digitalocean.com/articles/securely_deploy_caddy_ubuntu_16_04/caddy_spaces_api.png [La page DigitalOcean Applications & API]

Donnez à votre jeton un nom descriptif (++, par exemple) et assurez-vous que * Écriture (facultatif) * est sélectionné. Ensuite, appuyez sur * Generate Token *:

image: https: //assets.digitalocean.com/articles/securely_deploy_caddy_ubuntu_16_04/caddy_personal_token.png [Création d’un jeton d’accès personnel]

Cliquez sur le jeton généré pour le copier et enregistrez-le dans un endroit où vous ne le perdrez pas. Caddy doit accéder à ce jeton en tant que variable d’environnement pour configurer le DNS de DigitalOcean. Les fichiers de service de systemd vous permettent de définir des variables d’environnement à inclure dans l’environnement du processus. Modifiez le fichier de service Caddy dans le répertoire + / etc / systemd / system / +, plutôt que la version dans le référentiel Caddy Git. Ajoutez votre clé API à la version du fichier en dehors du référentiel Git pour éviter de commettre accidentellement le jeton privé dans le référentiel public Caddy:

sudo nano /etc/systemd/system/caddy.service

Recherchez la ligne commençant par + Environment = + dans la section + [Service] +. Cette ligne définit les variables d’environnement à transmettre au processus Caddy. Ajoutez un espace à la fin de cette ligne, puis ajoutez une variable + DO_AUTH_TOKEN +, suivie du jeton que vous venez de générer:

/etc/systemd/system/caddy.service

[Service]
Restart=on-abnormal

; User and group the process will run as.
User=www-data
Group=www-data

; Letsencrypt-issued certificates will be written to this directory.
Environment=CADDYPATH=/etc/ssl/caddy

Enregistrez et fermez ce fichier, puis rechargez le démon systemd comme vous l’avez fait précédemment pour vous assurer que la configuration est mise à jour:

sudo systemctl daemon-reload

Exécutez + systemctl status + pour vérifier que vos modifications de configuration ont bien fonctionné:

sudo systemctl status caddy

Cela produira une sortie similaire à la suivante. Portez une attention particulière à la ligne commençant par + Loaded: +. Le statut + chargé + indique que vos modifications de la configuration du service ont abouti. Si une erreur se produit lors de la configuration d’un service systemd, cette ligne affiche à la place un statut + erreur + ainsi qu’une explication de la raison pour laquelle systemd n’a pas pu interpréter le fichier de service. La ligne suivante, commençant par + Active: +, indique si le service est en cours d’exécution ou non. Parce que vous avez arrêté Caddy plus tôt dans cette étape, ceci affiche + inactive +. Quand papa est lancé, cela affichera + enabled ou` + running`.

Output● caddy.service - Caddy HTTP/2 web server
  Loaded:  (/etc/systemd/system/caddy.service; disabled; vendor preset: enabled)
  Active: inactive (dead)
    Docs: https://caddyserver.com/docs

Vous devrez apporter quelques légères modifications à votre + Caddyfile +, alors ouvrez-le pour édition:

sudo nano /etc/caddy/Caddyfile

Ajoutez les lignes en surbrillance au + Caddyfile +, en veillant à remplacer ++ par votre domaine. L’utilisation d’un domaine plutôt que d’un simple port pour le nom d’hôte amènera Caddy à répondre aux demandes via HTTPS. La directive + tls + configure le comportement de Caddy lorsqu’il utilise + TLS +, et la sous-directive + dns + indique que Caddy doit utiliser le système + DNS-01 +, plutôt que + HTTP-01 +:

/ etc / caddy / Caddyfile

{
   root /var/www
   gzip
   minify



}

Votre site Web est prêt à être déployé. Commencez par démarrer le serveur avec + systemctl + puis + enable + it. Ceci configurera Caddy pour qu’il démarre au démarrage:

sudo systemctl start caddy
sudo systemctl enable caddy

Si vous naviguez sur votre domaine, vous devriez être automatiquement redirigé vers HTTPS.

Votre installation de Caddy est complète et sécurisée. Nous verrons ensuite comment mettre à jour Caddy lors de la publication d’une nouvelle version. Lorsque vous installez un logiciel à l’aide d’un gestionnaire de paquets, sa mise à jour est généralement aussi simple que d’exécuter une seule commande et souvent, le système d’exploitation peut souvent installer les mises à jour de sécurité automatiquement. Cependant, puisque vous avez construit Caddy à partir de la source, le processus est un peu plus complexe. vous devrez reconstruire Caddy à partir d’une version mise à jour du code source, puis le reconfigurer.

Étape 6 - Mise à jour de votre installation Caddy

La mise à jour des logiciels est une pratique de sécurité importante, car les logiciels obsolètes comportent souvent des vulnérabilités. L’exécution de la dernière version de Caddy vous évitera de compromettre la sécurité de votre serveur via les vulnérabilités pouvant exister dans une version antérieure. Dans cette étape, nous verrons comment mettre à jour votre installation de Caddy lors de la sortie d’une nouvelle version. Cette étape ne devrait être suivie que si une nouvelle version de Caddy est placée dans le référentiel Caddy GitHub.

Nous allons utiliser Git pour mettre à jour l’état de notre code source. Premièrement, allez dans le répertoire source + caddy +:

cd $GOPATH/src/github.com/mholt/caddy

Assurez-vous d’être sur la branche que vous avez créée à l’étape 1 en utilisant + git checkout +:

git checkout

Ensuite, utilisez + git fetch + pour extraire les modifications du référentiel distant. Lorsque Git clone le référentiel Caddy, il maintient un lien vers le référentiel amont, l’emplacement central d’où proviennent les modifications. Git fait référence au référentiel amont sous le nom + origine +, vous devez donc extraire de l’origine:

git fetch origin

Les modifications apportées au référentiel sont maintenant présentes sur votre système, stockées sous une autre branche. Utilisez + git tag + pour voir la version la plus récente, car vous devez toujours utiliser les versions publiées de Caddy, plutôt que le code entre les versions:

git tag

Comme précédemment, parcourez la liste jusqu’à ce que vous trouviez la version la plus récente. Git inclut un outil permettant de fusionner deux branches de code différentes - + git merge. Tapez ce qui suit pour fusionner les modifications de la dernière version dans votre branche active. Assurez-vous de remplacer ++ par le nom de votre branche et le numéro de version par le dernier que vous venez d’identifier:

git merge

Un éditeur apparaîtra que vous pouvez sauvegarder et fermer pour terminer la fusion. Cependant, il est possible que des conflits de fusion surviennent lorsque Git est incapable de déterminer la façon dont les deux versions différentes du code devraient s’intégrer. Git vous avertira si cela se produit et vous devrez modifier manuellement les fichiers en conflit, puis valider pour résoudre le conflit.

En supposant qu’il n’ya pas de conflit de fusion, réinstallez Caddy en suivant le processus que vous avez suivi tout au long de ce didacticiel. Premièrement, utilisez + go install pour reconstruire le binaire:

go install github.com/mholt/caddy/caddy

Ensuite, arrêtez le service Caddy et copiez le nouveau binaire:

sudo systemctl stop caddy
sudo cp $GOPATH/bin/caddy /usr/local/bin/

Définissez les autorisations du binaire:

sudo chown root:root /usr/local/bin/caddy
sudo chmod 755 /usr/local/bin/caddy
sudo setcap 'cap_net_bind_service=+ep' /usr/local/bin/caddy

Enfin, utilisez + systemctl + pour redémarrer le service Caddy:

sudo systemctl start caddy

Caddy continuera à démarrer au démarrage, car il n’a pas été désactivé. Avec cela, Caddie a été mis à jour avec succès vers la dernière version et devrait continuer à fonctionner sans interruption, au moins jusqu’à la prochaine version.

Conclusion

En suivant ce didacticiel, vous avez réussi à déployer un site Web à l’aide de Caddy. Une bonne étape suivante serait de trouver un moyen d’être averti lorsque de nouvelles versions de Caddy seront publiées. Par exemple, vous pouvez utiliser le flux Atom pour les éditions Caddy ou un service dédié tel que Sibbell. Créer un script pour automatiser le processus de mise à jour du serveur serait également une bonne idée - vous pouvez même combiner les deux et créer un outil de construction qui reconstruit automatiquement Caddy lorsqu’une nouvelle version est disponible. Sinon, vous pouvez explorer Caddy ’documentation et découvrir la meilleure façon de la personnaliser pour répondre à vos besoins.