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

De Get Docs
Aller à :navigation, rechercher

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 USD dans le cadre du programme Write for DOnations.

Introduction

Caddy est un serveur Web conçu autour de la simplicité et de la sécurité, doté d'un certain nombre de fonctionnalités utiles pour l'hébergement de sites Web. Par exemple, il peut obtenir et gérer automatiquement les certificats TLS de 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, et devient rapidement une attente de base de tout site Web en cours d'exécution - sans lui, Chrome et Firefox avertiront que votre site Web est "non sécurisé" si les utilisateurs tentent de soumettre une connexion information.

Auparavant, la méthode recommandée pour installer Caddy consistait à télécharger des fichiers binaires prédéfinis à partir du site Web du projet Caddy. Cependant, les changements récents dans le fonctionnement des licences de Caddy signifient que vous n'êtes plus autorisé à utiliser ces fichiers binaires prédéfinis à des fins commerciales, sauf si vous payez des frais de licence, même si vous n'utilisez que Caddy en 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 de rencontrer des 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, installerez les plug-ins Caddy et apprendrez à mettre à niveau votre installation lorsqu'une nouvelle version est publiée.

Conditions préalables

Avant de commencer ce guide, vous aurez besoin des éléments suivants :

  • Un serveur Ubuntu 16.04 configuré selon notre Guide de configuration initiale du serveur. Vous devriez pouvoir vous connecter au serveur via SSH, vous connecter en tant qu'utilisateur non root avec des privilèges sudo et avoir un pare-feu fonctionnel configuré à l'aide d'UFW.
  • Un nom de domaine configuré pour utiliser la gestion DNS de DigitalOcean. Vous pouvez acheter un nom de domaine auprès de n'importe quel registraire de domaine et suivre notre guide sur Faire pointer un domaine vers des serveurs de noms DigitalOcean pour gérer votre DNS via DigitalOcean.
  • Un enregistrement « A » pointant de votre domaine vers votre serveur et, éventuellement, un enregistrement « AAAA » si vous souhaitez activer IPv6. Notre guide sur Configuration d'un nom d'hôte avec DigitalOcean explique comment procéder.
  • La chaîne d'outils Go language installée sur votre serveur. Suivez notre guide sur Comment installer Go 1.6 pour configurer Go. Vous devez également comprendre comment compiler le code Go et comment fonctionne l'outil de ligne de commande go. Suivez notre guide sur Building Go Executables pour en savoir plus à ce sujet.

Étape 1 - Caddie de construction

Dans cette étape, vous allez récupérer le code source de Caddy et vous assurer que vous êtes en mesure de le compiler. Caddy est écrit en Go, utilisez donc l'outil de ligne de commande go get pour récupérer la source de Caddy à partir de GitHub et enregistrez-la dans $GOPATH/src/github.com/mholt/caddy :

go get github.com/mholt/caddy/caddy

go get utilise Git pour cloner le code de GitHub. Git est un système de contrôle de version, ce qui signifie qu'il enregistre l'état d'un projet lorsque vous apportez des modifications et vous permet de revenir à n'importe quel état précédent dans l'historique du projet. Par défaut, la commande go get télécharge la dernière version du code source, mais ce serait une bonne idée 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 les versions. Les versions non publiées peuvent avoir des bogues ou des fonctionnalités cassées à moitié implémentées. La dernière version stable, en revanche, est plus susceptible de se compiler et de s'exécuter correctement.

Pour afficher toutes les versions précédentes, accédez d'abord au répertoire dans lequel vous avez enregistré la 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 à la suivante :

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 le signifieront dans Git en ajoutant une balise. Vous pouvez utiliser Git pour rétablir le code tel qu'il était au moment de la dernière version stable. Trouvez le numéro de version le plus élevé dans la sortie ; au moment de la rédaction, il s'agit de v0.10.12.

Puisque vous modifierez la source plus tard afin d'installer des plugins, créez une nouvelle branche ' pour stocker vos modifications. Dans Git, les branches sont des moyens 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 change de branche. L'option -b demandera à Git de créer une nouvelle branche avec le nom adding_plugins à partir de la version v0.10.12. Remplacez adding_plugins par ce que vous souhaitez nommer la branche et v0.10.12 par la dernière version stable que vous avez identifiée précédemment :

git checkout -b "adding_plugins" "v0.10.12"

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 apportées au code. Lorsque vous mettrez à jour Caddy à l'avenir, vous fusionnerez les modifications dans cette nouvelle branche.

À ce stade, vous êtes prêt à créer Caddy en utilisant l'outil go install pour compiler le code source dans un binaire. Bien que la syntaxe de la commande puisse sembler installer Caddy à partir d'un site Web (github.com), cela fait en fait référence au chemin local sur le serveur sur lequel nous venons de travailler avec le référentiel Git ([X207X ]):

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 prérequis :

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 lorsque nous configurerons les différents 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 toutes les options transmises à la commande Caddy et est l'une des premières choses exécutées lorsque vous exécutez Caddy.

Localisez la fonction Run() et ajoutez le texte en surbrillance comme première ligne entre les accolades. Cela imprimera le texte "Hello from Caddy!" avant que le serveur ne s'exécute :

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

. . .
// Run is Caddy's main() function.
func Run() {
        fmt.Println("Hello from Caddy!")

        flag.Parse()

        caddy.AppName = appName
        . . .
}

Appuyez sur CTRL + X, Y, puis ENTER pour enregistrer 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
OutputHello from Caddy!
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. Dans l'étape suivante, vous installerez Caddy en tant que service afin qu'il démarre automatiquement au démarrage, puis ajusterez ses paramètres de propriété et d'autorisations pour assurer la sécurité du serveur.

Étape 2 - Installation de Caddy

Maintenant que vous avez vérifié que vous êtes capable de construire Caddy, il est temps de configurer un service systemd afin 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 systemd peut utiliser pour gérer le service Caddy. Ce fichier de service émet certaines hypothèses sur l'environnement dans lequel Caddy s'exécutera, il y a donc quelques éléments que vous voudrez probablement modifier avant de l'installer.

Pour commencer, copiez le binaire Caddy dans /usr/local/bin, l'emplacement standard des binaires qui ne sont pas gérés par le gestionnaire de paquets d'Ubuntu et ne sont pas essentiels au fonctionnement du système :

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

Ensuite, changez la propriété du binaire Caddy en l'utilisateur root. Notez que bien que root possède Caddy, il est conseillé de ne pas exécuter Caddy avec le compte root car cela pourrait être un problème de sécurité majeur s'il y a une vulnérabilité dans Caddy. Cependant, le fait que root possède le binaire empêchera les autres comptes de le modifier avec les autorisations que nous définirons. Ceci est souhaitable car si un autre processus avec des autorisations inférieures à Caddy est compromis, il ne pourra pas modifier Caddy pour obtenir plus de contrôle sur le système :

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

Ensuite, définissez les autorisations du fichier binaire sur 755 — cela donne root des autorisations complètes de 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

Étant donné que le processus Caddy ne s'exécutera pas en tant que root, Linux l'empêchera de se lier aux ports :80 ou :443 (les ports standard pour HTTP et HTTPS, respectivement), car ce sont des 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 dans 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 root. setcap est utile pour permettre à un processus d'effectuer une opération privilégiée spécifique sans lui donner les autorisations complètes de superutilisateur. cap_net_bind_service=+ep spécifie que vous souhaitez donner au processus les autorisations CAP_NET_BIND_SERVICE, ce 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 de /etc/, qui est l'emplacement recommandé par le Filesystem Hierarchy Standard 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 et est le 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 binaire (via le compte root) et que le processus Caddy peut également y lire et y écrire (puisqu'il fonctionnera en tant que www-data), mais les autres utilisateurs n'y auront pas accès. Lorsqu'il est utilisé avec chown, le drapeau -R change la propriété de tous les sous-répertoires et fichiers dans le répertoire /etc/caddy, plutôt que simplement le répertoire lui-même :

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

Dans une étape ultérieure, ce didacticiel expliquera comment activer le 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 être capable d'écrire des certificats dans ce répertoire et de le lire afin de chiffrer les requêtes. Pour cette raison, modifiez les autorisations pour le 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, l'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 appelé Caddyfile ; il peut être utile de considérer cela comme similaire à httpd.conf dans Apache ou au répertoire de configuration Nginx sites-available. Le service systemd pour Caddy s'attendra à ce que ce fichier soit stocké dans /etc/caddy, alors créez-y Caddyfile en utilisant touch :

sudo touch /etc/caddy/Caddyfile

Pour installer le service Caddy, copiez le fichier d'unité systemd du code source Caddy vers /etc/systemd/system, l'emplacement des services systemd. Cela donnera à systemd la possibilité 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. Cela amènera systemd à détecter le service Caddy, bien que nous ne l'exécuterons pas encore :

sudo systemctl daemon-reload

Vérifiez si systemd 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, alors Caddy a été correctement détecté par systemd.

La dernière étape de ce processus d'installation, avant d'écrire la configuration de Caddy, consiste à ajuster votre pare-feu. Vous devriez déjà exécuter un pare-feu à l'aide d'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 auxquels toute partie externe peut se connecter et ceux qui sont protégés contre l'accès. S'il existe d'autres processus qui exposent un port sur votre serveur, le pare-feu empêche l'accès à ceux-ci, réduisant ainsi les possibilités pour un attaquant de compromettre un logiciel vulnérable.

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 à ce stade, il n'est pas configuré pour faire quoi que ce soit. Ensuite, nous verrons comment prendre cette nouvelle installation de Caddy et la configurer pour servir un site Web.

Étape 3 - Configuration de Caddie

Pour que votre installation Caddy soit utilisée comme serveur Web fonctionnel, quelques paramètres doivent être modifiés. Au fur et à mesure que nous apporterons ces modifications, nous examinerons la syntaxe de la configuration Caddyfile, explorerons quelques scénarios de configuration et servirons une page d'espace réservé sur HTTP.

Pour commencer à configurer Caddy, créez un fichier HTML de base pour qu'il serve. HTML est le langage qui décrit le contenu des pages Web, et ce fichier fonctionnera comme un espace réservé pour démontrer l'hébergement d'un site Web avec Caddy. Si vous décidez d'utiliser Caddy pour héberger votre propre site Web, vous remplacerez 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 naviguant sur 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 servie 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

Modifiez 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 un label. Le nom d'hôte est le nom de domaine où Caddy répondra aux demandes. Dans ce cas, réglez-le sur :80, c'est-à-dire le port :80 du serveur. Cela empêche le serveur de fonctionner sur HTTPS pour le moment, car Caddy essaiera de l'activer automatiquement, mais nous voulons le faire via un plugin.

Par défaut, Caddy tente de récupérer un certificat SSL à partir de Let's Encrypt en rendant une ressource disponible via HTTP, comme l'hébergement d'un fichier. Cependant, si vous souhaitez exécuter un service interne à l'aide de Caddy, vous ne voudrez peut-être pas exposer le serveur à l'Internet public. L'utilisation d'un plugin vous permet d'utiliser le défi Let's Encrypt DNS. Cela implique que Caddy 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 avoir à accepter des requêtes HTTP extérieures. Cela vous laisse plus d'options pour exécuter Caddy à l'avenir.

Après :80 se trouve un bloc de configuration, entre accolades, dans lequel iront les configurations du site. Sur la ligne suivante, on voit la root directive. Les directives sont les options de configuration réelles de Caddy, et leur ajout modifie le comportement de Caddy lorsqu'il sert le site Web. Les directives peuvent avoir 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 où se trouvent les fichiers que Caddy doit servir. Cependant, les directives ne sont pas obligées d'avoir des arguments. Par exemple, vous pouvez ajouter la directive gzip sans aucun argument pour compresser les pages Web avant qu'elles ne soient envoyées au client, ce qui accélère leur chargement.

/etc/caddy/Caddyfile

:80 {
    root /var/www
    gzip
}

Les directives peuvent être configurées avec des sous-directives qui fournissent des fonctionnalités supplémentaires. Ceux-ci sont placés dans leurs propres blocs de configuration, toujours à l'aide d'accolades. Par exemple, bien que la directive gzip fonctionne par elle-même, nous pourrions utiliser la sous-directive ext pour compresser uniquement certains types de fichiers, ou la sous-directive level pour contrôler le niveau de compression se produira (1 étant le plus bas et 9 étant le plus élevé).

/etc/caddy/Caddyfile

:80 {
    root /var/www
    gzip {
        ext .html .htm .php
        level 6
    }
}

Caddy a un grand nombre de directives différentes pour de nombreux cas d'utilisation. Par exemple, la directive fastcgi pourrait être utile pour activer PHP. La directive markdown pourrait être utilisée pour convertir automatiquement les fichiers Markdown en HTML avant de les servir, ce qui pourrait être utile pour créer un simple blog.

Enregistrez et fermez le Caddyfile, et testez que tout fonctionne correctement. Utilisez systemctl pour démarrer le service Caddie :

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: 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 accédez à votre domaine, vous devriez maintenant voir que Caddy est en cours d'exécution et 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 de nombreuses directives par défaut, il ne peut pas répondre à tous les cas d'utilisation possibles et vous souhaiterez peut-être ajouter plus 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 grâce à l'utilisation de plugins.

Étape 4 - Utilisation des plugins

Les plugins sont un moyen de changer le comportement de Caddy. Ce sont généralement de petits extraits de code que nous pouvons insérer dans Caddy pour ajouter plus de directives pour des cas d'utilisation spécifiques. Le moyen le plus simple de comprendre les plugins est de se lancer directement et d'en essayer un, nous allons donc installer le plugin minify. Ce plugin supprime l'excès d'espace blanc et le code redondant de certains fichiers, réduisant la taille de chacun, et encore une fois, aidant à accélérer les temps de chargement.

Commencez par retourner à l'endroit où Go a enregistré le code source de Caddy, car vous devrez le modifier pour installer le plugin :

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

Ouvrez à nouveau le fichier run.go de Caddy. Comme nous l'avons dit plus tôt, c'est l'une des premières parties de Caddy à être exécutée, et c'est l'endroit où les plugins sont installés.

nano caddy/caddymain/run.go

Dans ce fichier, vous verrez une déclaration import qui ressemble à ceci :

$GOPATH/src/github.com/mholt/caddy/caddy/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 de légers ajustements de configuration, alors assurez-vous de lire la documentation de ceux que vous installez. Vous pouvez trouver une liste des plugins populaires dans le volet gauche de la Caddy documentation, sous Plugins.

Le référentiel GitHub du plug-in minify est hacdias/caddy-minify. Ajoutez donc ce qui suit 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)

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

Vous devez valider votre code lorsque vous y apportez des modifications afin que lorsque vous fusionnez de nouvelles mises à jour, ces modifications ne soient pas perdues. Si vous n'avez pas validé de code sur ce serveur auparavant, vous devrez définir un nom et une adresse e-mail 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 travaillerez à l'avenir. À moins que vous ne poussiez le code vers un référentiel public tel que GitHub, ces détails ne seront pas rendus publics.

git config --global user.email "[email protected]"
git config --global user.name "Sammy"

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

git add -A .

Exécutez maintenant git commit pour enregistrer vos modifications dans la branche actuelle. 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 d'accès au plugin dans votre code, mais vous devez toujours télécharger le plugin localement pour que Go puisse réellement 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 terminera sans résultat. 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 garantir sa fonctionnalité et sa 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
    minify
}

Démarrez maintenant votre serveur en utilisant systemctl :

sudo systemctl start caddy

Caddy est maintenant en cours d'exécution et réduira tous 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 à l'aide de cURL, un outil en ligne de commande pour effectuer des requêtes Web. L'exécution de curl sans options ni drapeaux récupère le contenu d'une page Web et l'affiche dans le terminal. Exécutez la commande suivante pour demander le fichier index.html à Caddy, en remplaçant example.com par votre domaine.

curl http://example.com

Vous verrez la sortie suivante. Notez que tout l'espace inutile a été supprimé, montrant 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 les autres plugins Caddy. Vous vous entraînerez davantage à ajouter des plugins en installant le plugin tls.dns.digitalocean pour activer automatiquement le trafic HTTPS sécurisé.

Étape 5 - Activation de 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 de se tromper sur les détails de HTTPS. L'approche HTTPS de Caddy 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's Encrypt que vous possédez réellement votre domaine. Cette méthode consiste à publier un fichier spécial (contenant une réponse à un défi envoyé par Let's Encrypt) à un emplacement spécifique sur le site Web. Bien que cette méthode fonctionne, elle nécessite que votre site Web soit 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.

Comme alternative, vous pouvez installer le plug-in tls.dns.digitalocean Caddy, qui utilisera à la place la méthode de vérification DNS-01. Ce plugin s'authentifie auprès de 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 le DNS, ce qui vous donne la possibilité de récupérer un certificat même si votre serveur n'est pas accessible au public. Pour plus d'informations sur les différents types d'enregistrements DNS, lisez notre Introduction au DNS DigitalOcean.

La méthode d'installation du plugin tls.dns.digitalocean Caddy est presque identique à la façon dont vous avez installé le 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 plug-in :

$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"
    _ "github.com/caddyserver/dnsproviders/digitalocean"
)

Pour mettre à jour Caddy, accédez au référentiel source de Caddy et validez les modifications dans 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 compilez 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 construit et en définissant à nouveau 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 :

Donnez à votre token un nom descriptif (caddy-dns, par exemple) et assurez-vous que Write (optional) est sélectionné. Ensuite, appuyez sur Générer un jeton :

Cliquez sur le jeton généré pour le copier et enregistrez-le quelque part 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 valider 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 qui doivent être passées 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 DO_AUTH_TOKEN=your_token_here

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 étaient correctes :

sudo systemctl status caddy

Cela produira une sortie similaire à la suivante. Portez une attention particulière à la ligne commençant par Loaded:. L'état loaded indique que vos modifications de la configuration du service ont réussi. Si une erreur se produit lors de la configuration d'un service systemd, cette ligne affichera à la place un état error 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. Lorsque Caddy est exécuté, cela affichera enabled ou running.

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

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

sudo nano /etc/caddy/Caddyfile

Ajoutez les lignes en surbrillance au Caddyfile, en veillant à remplacer example.com par votre domaine. L'utilisation d'un domaine plutôt que d'un simple port pour le nom d'hôte obligera Caddy à traiter les requêtes via HTTPS. La directive tls configure le comportement de Caddy lors de l'utilisation de TLS, et la sous-directive dns spécifie que Caddy doit utiliser le système DNS-01, plutôt que HTTP-01 ] :

/etc/caddy/Caddyfile

example.com {
    root /var/www
    gzip
    minify
    tls {
        dns digitalocean
    }
}

Votre site web est prêt à être déployé. Commencez par démarrer le serveur avec systemctl puis enable. Cela 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. Ensuite, nous verrons comment mettre à jour Caddy lorsqu'une nouvelle version est publiée. Lorsque vous installez un logiciel à l'aide d'un gestionnaire de packages, sa mise à jour est généralement aussi simple que l'exécution d'une seule commande et, souvent, le système d'exploitation peut souvent installer automatiquement les mises à jour de sécurité. Cependant, puisque vous avez construit Caddy à partir de la source, le processus est un peu plus compliqué ; vous devrez reconstruire Caddy à partir d'une version mise à jour du code source, puis le configurer à nouveau.

É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 présentent souvent des vulnérabilités. L'exécution de la dernière version de Caddy vous évitera que la sécurité de votre serveur ne soit compromise par des vulnérabilités pouvant exister dans une version plus ancienne. Dans cette étape, nous verrons comment mettre à jour votre installation de Caddy lorsqu'une nouvelle version sort. Cette étape ne doit être suivie que si une nouvelle version de Caddy est poussée vers le référentiel Caddy GitHub.

Nous utiliserons Git pour mettre à jour l'état de notre code source. Tout d'abord, accédez au répertoire source caddy :

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

Assurez-vous que vous êtes sur la branche que vous avez créée à l'étape 1 en utilisant git checkout :

git checkout adding_plugins

Ensuite, utilisez git fetch pour extraire les modifications du référentiel distant. Lorsque Git clone le dépôt Caddy, il maintient un lien vers le dépôt en amont — l'emplacement central d'où proviennent les modifications. Git fait référence au référentiel en amont sous le nom origin, vous devez donc récupérer depuis 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 branche différente. 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 pour 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 de travail. Assurez-vous de remplacer adding_plugins par le nom de votre succursale et le numéro de version par le dernier que vous venez d'identifier :

git merge adding_plugins v0.10.13

Un éditeur apparaîtra que vous pourrez enregistrer et fermer pour terminer la fusion. Cependant, il est possible que des conflits de fusion se produisent lorsque Git est incapable de déterminer comment les deux versions différentes du code doivent s'emboîter. 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'y ait pas de conflits de fusion, réinstallez Caddy via le même processus que vous avez suivi tout au long de ce didacticiel. Tout d'abord, 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 relancer le service Caddy :

sudo systemctl start caddy

Caddy continuera à démarrer au démarrage à l'avenir, car il n'a pas été désactivé. Avec cela, Caddy 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 tutoriel, vous avez réussi à déployer un site Web à l'aide de Caddy. Une bonne prochaine étape serait de trouver un moyen d'être averti lorsque de nouvelles versions de Caddy sont publiées. Par exemple, vous pouvez utiliser le flux Atom pour les versions de 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'il y a une nouvelle version. Sinon, vous pouvez explorer la documentation de Caddy et découvrir comment le personnaliser au mieux en fonction de vos besoins.