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

L’auteur a choisi le Free and Open Source Fund pour recevoir une donation dans le cadre du programme Write for DOnations.

Introduction

Caddy est un serveur Web basé sur la simplicité et la sécurité, qui est 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 le HTTPS, et il 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 il est en passe de devenir en composant indispensable de tout site Web en production. Sans lui, Chrome et Firefox avertiront les utilisateurs que votre site Web est “Non sécurisé” si ceux-ci tentent de soumettre des informations de connexion.

Auparavant, la méthode recommandée pour installer Caddy consistait à télécharger des binaires pré-construits à partir du site Web du projet Caddy. Toutefois, en raison des modifications apportées au fonctionnement de la licence de Caddy, vous n’êtes plus autorisé à utiliser ces binaires pré-construits à des fins commerciales, même si vous utilisez Caddy en interne au sein d’une entreprise, sauf si vous payez un droit de licence. Heureusement, le code source de Caddy est encore entièrement open source et vous pouvez construire Caddy vous-même pour éviter de rencontrer des problèmes de licence.

Dans ce tutoriel, vous allez construire Caddy à partir de son code source et l’utiliser pour héberger un site Web sécurisé avec HTTPS. Cela implique de le compiler, de le configurer en utilisant un Caddyfile et d’installer des plugins. Enfin, vous apprendrez à mettre à jour votre installation lorsqu’une nouvelle version est disponible.

Conditions préalables

• Un serveur Ubuntu 18.04 avec des privilèges root, et un compte secondaire non root. Vous pouvez configurer ceci en suivant notre Guide de configuration initiale du serveur pour Ubuntu 18.04. Pour ce tutoriel, l’utilisateur non root est sammy.
• Un nom de domaine entièrement enregistré. Ce tutoriel utilisera your_domain. Vous pouvez acheter un nom de domaine sur Namecheap, en obtenir un gratuitement sur Freenom, ou utiliser le bureau d’enregistrement de domaine de votre choix.
• Un enregistrement DNS A avec your_domain pointant sur l’adresse IP publique de votre serveur. Vous pouvez suivre cette introduction à DigitalOcean DNS pour savoir comment les ajouter.
• La chaîne d’outils Go language installée sur votre serveur. Suivez notre guide sur Comment installer Go et configurer un environnement de programmation local sur Ubuntu 18.04 pour configurer Go. Il n’est pas nécessaire de créer des exemples de projets.
• Un jeton d’accès personnel (clé API) avec des droits en lecture et en écriture pour votre compte DigitalOcean. Consultez Comment créer un jeton d’accès personnel pour en créer un.

Étape 1 — Construction de Caddy

Dans cette étape, vous construirez Caddy à partir de son code source avec la possibilité d’ajouter ultérieurement des plugins, le tout sans modifier le code source de Caddy.

Pour les besoins de ce tutoriel, vous stockerez le code source sous ~/caddy. Créez ce répertoire en exécutant la commande suivante :

mkdir ~/caddy

Naviguez jusqu’à lui :

cd ~/caddy

Vous stockerez le code source pour l’exécution et la personnalisation de Caddy dans un fichier nommé caddy.go. Créez-le en utilisant la commande suivante :

nano caddy.go

Ajoutez les lignes suivantes :

package main

import (
	"github.com/caddyserver/caddy/caddy/caddymain"
)

func main() {
	// caddymain.EnableTelemetry = false
	caddymain.Run()
}

Ce code importe Caddy directement de Github (en utilisant Git) et le lance à partir de la fonction d’entrée main. Si vous souhaitez activer la télémétrie, décommentez la ligne caddymain.EnableTelemetry et réglez la valeur sur true. Lorsque vous avez terminé, enregistrez et fermez le fichier.

Pour que caddy.go puisse utiliser les dépendances importées, vous devrez l’initialiser en tant que module :

go mod init caddy

Output
go: creating new go.mod: module caddy

À ce stade, vous êtes prêt à construire la version de base de Caddy à partir du code source ci-dessus en exécutant :

go install

Il y aura beaucoup de sorties, détaillant les bibliothèques téléchargées par Go comme dépendances nécessaires à la compilation. L’exécutable résultant est stocké sous $GOPATH/bin, comme expliqué dans les conditions préalables.

Lorsqu’il a terminé, essayez d’exécuter Caddy :

caddy

Vous verrez une sortie semblable à ce qui suit :

Output
Activating privacy features... done.

Serving HTTP on port 2015
http://:2015

WARNING: File descriptor limit 1024 is too low for production servers. At least 8192 is recommended. Fix with `ulimit -n 8192`.

Cela signifie que Caddy a démarré avec succès, et est disponible sur le port 2015. Vous pouvez ignorer le message d’avertissement, car cette limite sera ajustée ultérieurement sans votre intervention. Pour quitter, appuyez sur CTRL + C.

Vous avez maintenant construit et exécuté Caddy. Dans l’étape suivante, vous installerez Caddy en tant que service afin qu’il se lance automatiquement au démarrage, puis vous ajusterez ses 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 construire et d’exécuter Caddy, il est temps de configurer un service systemd afin que Caddy puisse être lancé automatiquement au démarrage du système. Pour en savoir plus sur systemd, consultez notre tutoriel Les fondamentaux de Systemd.

Pour commencer, déplacez le binaire Caddy vers /usr/local/bin, l’emplacement standard pour les binaires qui ne sont pas gérés par le gestionnaire de packages d’Ubuntu et qui ne sont pas essentiels au fonctionnement du système :

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

Ensuite, transférez la propriété du binaire Caddy à l’utilisateur root :

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

Cela empêchera d’autres comptes de modifier l’exécutable. Cependant, même si l’utilisateur root possède Caddy, il est conseillé de l’exécuter uniquement en utilisant d’autres comptes non root présents sur le système. Cela permet de s’assurer qu’en cas de compromission de Caddy (ou d’un autre programme), l’attaquant ne pourra pas modifier le binaire, ou exécuter des commandes en tant que root.

Ensuite, définissez les permissions du fichier binaire à 755 - cela donne à root des permissions complètes de lecture/écriture/exécution pour le fichier, alors que les autres utilisateurs ne pourront que le lire et l’exécuter :

sudo chmod 755 /usr/local/bin/caddy

Comme le processus Caddy ne s’exécutera pas en tant que root, Linux l’empêchera de se lier aux ports 80 et 443 (les ports standard pour HTTP et HTTPS, respectivement), car il s’agit d’opérations privilégiées. Afin d’être facilement accessible sur votre domaine, Caddy doit être relié à l’un de ces ports, selon le protocole. Sinon, il vous faudrait ajouter un numéro de port spécifique à l’URL du domaine dans votre navigateur pour visualiser le contenu qu’il servira.

Pour permettre à Caddy de se lier à des ports bas sans s’exécuter en tant que root, exécutez la commande suivante :

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

L’utilitaire setcap définit les capacités des fichiers. Dans cette commande, il attribue la capacité CAP_NET_BIND_SERVICE au binaire Caddy, ce qui permet à un exécutable de se lier à un port inférieur à 1024.

Vous avez maintenant fini de configurer le binaire Caddy, et vous êtes prêt à commencer à écrire la configuration de Caddy. Créez un répertoire dans lequel vous stockerez les fichiers de configuration de Caddy en exécutant la commande suivante :

sudo mkdir /etc/caddy

Ensuite, définissez les autorisations d’utilisateur et de groupe appropriées pour celui-ci :

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

Le fait de définir l’utilisateur comme root et le groupe comme www-data garantit que Caddy aura un accès en lecture et en écriture au dossier (via le groupe www-data) et que seul le compte du super-utilisateur aura les mêmes droits de lecture et de modification. www-data est l’utilisateur et le groupe par défaut pour les serveurs Web sur Ubuntu.

Dans une étape ultérieure, vous activerez le provisionnement automatique des certificats TLS à partir de Let’s Encrypt. Pour préparer cette étape, 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 lire à partir de celui-ci afin de chiffrer les requêtes. Pour cette raison, modifiez les permissions 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 :

sudo mkdir /var/www

Ensuite, définissez le propriétaire et le groupe du répertoire sur www-data :

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

Caddy lit sa configuration à partir d’un fichier appelé Caddyfile, stocké sous /etc/caddy. Créez le fichier sur le disque en exécutant :

sudo touch /etc/caddy/Caddyfile

Pour installer le service Caddy, téléchargez le fichier d’unité systemd du référentiel Github Caddy dans /etc/systemd/system en exécutant :

sudo sh -c 'curl https://raw.githubusercontent.com/caddyserver/caddy/master/dist/init/linux-systemd/caddy.service > /etc/systemd/system/caddy.service'

Modifiez les permissions 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

Puis, rechargez le système pour détecter le service Caddy :

sudo systemctl daemon-reload

Vérifiez si systemd a détecté le service Caddy en exécutant systemctl status :

sudo systemctl status caddy

Vous verrez une sortie semblable à :

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

Si vous voyez cette même sortie, alors le nouveau service a été correctement détecté par systemd.

Dans le cadre de la configuration initiale du serveur, vous avez activé ufw, le pare-feu non compliqué, et autorisé les connexions SSH. Pour que Caddy puisse servir le trafic HTTP et HTTPS à partir de votre serveur, vous devez les autoriser dans ufw en exécutant la commande suivante :

sudo ufw allow proto tcp from any to any port 80,443

Le résultat sera :

Output
Rule added
Rule added (v6)

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

sudo ufw status

Vous verrez la sortie suivante :

Output
Status: active

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

Votre installation de Caddy est maintenant terminée, mais elle n’est pas configurée pour servir quoi que ce soit. Dans l’étape suivante, vous allez configurer Caddy pour qu’il serve les fichiers du répertoire /var/www.

Étape 3 - Configuration de Caddy

Dans cette section, vous allez écrire la configuration de base de Caddy pour servir des fichiers statiques à partir de votre serveur.

Commencez par créer un fichier HTML de base dans /var/www, appelé index.html :

sudo nano /var/www/index.html

Ajoutez les lignes suivantes :

<!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>

Lorsqu’il est affiché dans un navigateur Web, ce fichier affichera un titre avec le texte This page is being served by Caddy (Cette page est servie par Caddy). Enregistrez et fermez le fichier.

Ouvrez le fichier de configuration Caddyfile que vous avez créé précédemment pour le modifier :

sudo nano /etc/caddy/Caddyfile

Ajoutez les lignes suivantes :

:80 {
  root /var/www
  gzip
}

Il s’agit d’une configuration de base de Caddy, qui déclare que le port 80 de votre serveur doit être servi avec des fichiers provenant de /var/www et compressés à l’aide de gzip pour réduire le temps de chargement des pages côté client.

Dans la majorité des cas, Caddy vous permet de personnaliser davantage les directives de configuration. Par exemple, vous pouvez limiter la compression gzip aux seuls fichiers HTML et PHP, et fixer le niveau de compression à 6 (1 étant le plus bas et 9 le plus élevé) en étendant la directive avec des accolades et en énumérant des sous-directives en dessous :

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

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Caddy dispose d’un grand nombre de directives différentes pour de nombreux cas d’utilisation. Par exemple, la directive fastcgi peut être utilisée pour activer PHP. La directive 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 simple blog.

Pour vérifier que tout fonctionne correctement, lancez le service Caddy :

sudo systemctl start caddy

Ensuite, lancez systemctl status pour obtenir des informations sur le statut 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 Thu 2020-03-12 11:17:49 UTC; 11s ago
     Docs: https://caddyserver.com/docs
 Main PID: 3893 (caddy)
    Tasks: 7 (limit: 1152)
   CGroup: /system.slice/caddy.service
           └─3893 /usr/local/bin/caddy -log stdout -log-timestamps=false -agree=true -conf=/etc/caddy/Caddyfile -root=/var/tmp

Mar 12 11:17:49 caddy-article-update systemd[1]: Started Caddy HTTP/2 web server.
Mar 12 11:17:49 caddy-article-update caddy[3893]: [INFO] Caddy version: v1.0.5
Mar 12 11:17:49 caddy-article-update caddy[3893]: Activating privacy features... done.
Mar 12 11:17:49 caddy-article-update caddy[3893]: Serving HTTP on port 80
Mar 12 11:17:49 caddy-article-update caddy[3893]: http://
Mar 12 11:17:49 caddy-article-update caddy[3893]: [INFO] Serving http://
Mar 12 11:17:49 caddy-article-update caddy[3893]: [INFO][cache:0xc00007a7d0] Started certificate maintenance routine
Mar 12 11:17:49 caddy-article-update caddy[3893]: [WARNING] Sending telemetry (attempt 1): Post "https://telemetry.caddyserver.com/v1/update/6a8159c4-3427-42
Mar 12 11:17:57 caddy-article-update caddy[3893]: [WARNING] Sending telemetry (attempt 2): Post "https://telemetry.caddyserver.com/v1/update/6a8159c4-3427-42
...

Vous pouvez maintenant naviguer vers l’adresse IP de votre serveur dans un navigateur Web. Votre exemple de page Web affichera :

Vous avez maintenant configuré Caddy pour servir des fichiers statiques à partir de votre serveur. Dans l’étape suivante, vous allez étendre les fonctionnalités de Caddy grâce à l’utilisation de plugins.

Étape 4 - Utilisation de plugins

Les plugins offrent un moyen de modifier et d’étendre le comportement de Caddy. En général, ils proposent davantage de directives de configuration à utiliser, en fonction de votre cas d’utilisation. Dans cette section, vous ajouterez et utiliserez des plugins en installant le plugin minify. Il supprime les espaces excédentaires et nettoie le code qui sera envoyé au client, ce qui réduit encore l’encombrement et les temps de chargement.

Le référentiel GitHub du plugin minify est hacdias/caddy-minify.

Naviguez jusqu’au répertoire avec le code source que vous avez créé à la première étape :

cd ~/caddy

Pour ajouter un plugin à Caddy, vous devez l’importer dans le fichier caddy.go que vous avez utilisé pour construire Caddy. Ouvrez caddy.go​​​ pour le modifier :

nano caddy.go

Importez le plugin minify en ajoutant la ligne surlignée, comme ceci :

package main

import (
	"github.com/caddyserver/caddy/caddy/caddymain"

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

func main() {
	// caddymain.EnableTelemetry = false
	caddymain.Run()
}

Enregistrez et fermez le fichier.

Certains plugins peuvent nécessiter quelques légers ajustements de configuration, alors assurez-vous de lire la documentation pour ceux que vous installez. Vous trouverez une liste des plugins les plus populaires dans le volet gauche de la documentation de Caddy, sous Plugins.

À 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 l’exécution. Votre modification de la déclaration d’importation a mis à jour 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

Lorsque c’est terminé, déplacez le binaire généré vers /usr/local/bin et définissez les autorisations pour le binaire comme vous l’avez fait précédemment. Vous devez suivre ces étapes à chaque fois que vous reconstruisez Caddy afin d’assurer sa fonctionnalité et sa sécurité :

sudo mv $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 commencer à utiliser le plugin minify, vous devez ajouter la directive minify à votre Caddyfile. Ouvrez-le pour le modifier :

sudo nano /etc/caddy/Caddyfile

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

:80 {
  root /var/www
  gzip
  minify
}

Maintenant, redémarrez votre serveur en utilisant systemctl :

sudo systemctl restart caddy

Caddy est maintenant lancé et va minifier tous les fichiers qu’il sert, y compris le fichier index.html que vous avez créé précédemment. Vous pouvez observer la « minification » à l’œuvre en récupérant le contenu de votre domaine à l’aide de curl :

curl http://your_domain

Vous verrez la sortie suivante. Notez que tous les espaces blancs inutiles ont été supprimés, ce qui montre que le plugin minify fonctionne.

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

Dans cette étape, vous avez appris à étendre Caddy avec des plugins. Ensuite, vous activerez HTTPS en installant le plugin tls.dns.digitalocean.

Étape 5 - Activation du TLS automatique avec Let’s Encrypt

Dans cette section, vous allez activer le provisionnement et le renouvellement automatique du certificat Let’s Encrypt, en utilisant les enregistrements DNS TXT pour la vérification.

Pour vérifier l’utilisation des enregistrements DNS TXT, vous installerez un plugin pour l’interface avec l’API DigitalOcean, appelé tls.dns.digitalocean. La procédure d’installation est presque identique à celle de l’installation du plugin minify à l’étape précédente. Pour commencer, ouvrez caddy.go :

nano caddy.go

Ajoutez le référentiel du plugin à importer :

package main

import (
	"github.com/caddyserver/caddy/caddy/caddymain"

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

	_ "github.com/caddyserver/dnsproviders/digitalocean"
)

func main() {
	// caddymain.EnableTelemetry = false
	caddymain.Run()
}

Compilez-le en exécutant :

go install

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

sudo systemctl stop caddy
sudo mv $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 DigitalOcean pour établir des enregistrements DNS. Caddy doit accéder à ce jeton en tant que variable d’environnement pour configurer le DNS de DigitalOcean, vous allez donc éditer son fichier d’unité systemd :

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

Trouvez la ligne commençant par Environment= dans la section [Service]. Cette ligne définit les variables d’environnement qui doivent être transmises 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 :

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

sudo systemctl status caddy

La sortie devrait ressembler à ceci :

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 l’éditer :

sudo nano /etc/caddy/Caddyfile

Ajoutez les lignes surlignées au Caddyfile, en veillant à remplacer your_domain par votre domaine (au lieu du seul port :80) et en commentant gzip :

your_domain {
  root /var/www
  #gzip
  minify
  tls {
      dns digitalocean
  }
}

L’utilisation d’un domaine plutôt que d’un simple port pour le nom d’hôte amènera Caddy à servir des 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.

Votre site Web est ainsi prêt à être déployé. Démarrez Caddy avec systemctl puis activez-le avec la commande enable, afin qu’il s’exécute au démarrage :

sudo systemctl start caddy
sudo systemctl enable caddy

Si vous naviguez sur votre domaine, vous serez automatiquement redirigé vers HTTPS, avec le même message affiché.

Votre installation de Caddy est maintenant complète et sécurisée, et vous pouvez la personnaliser davantage en fonction de votre cas d’utilisation.

Si vous souhaitez mettre à jour Caddy lorsqu’une nouvelle version sort, vous devrez mettre à jour le fichier go.mod (stocké dans le même répertoire), qui ressemble à ceci :

module caddy

go 1.14

require (
        github.com/caddyserver/caddy v1.0.5
        github.com/caddyserver/dnsproviders v0.4.0
        github.com/hacdias/caddy-minify v1.0.2
)

La partie surlignée est la version de Caddy que vous utilisez. Lorsqu’une nouvelle version est publiée sur Github (voir la page des balises de sortie), vous pouvez remplacer celle qui existe dans go.mod par celle-ci et compiler Caddy selon les deux premières étapes. Vous pouvez faire de même pour tous les plugins importés.

Conclusion

Caddy est maintenant installé et configuré sur votre serveur, et sert des pages statiques sur le domaine souhaité, sécurisé par des certificats TLS Let’s Encrypt gratuits.

Une bonne étape suivante consisterait à trouver un moyen d’être averti lorsque de nouvelles versions de Caddy sont publiées. Par exemple, vous pourriez utiliser le flux Atom pour les sorties Caddy, ou un service dédié tel que dependencies.io.

Vous pouvez consulter la documentation de Caddy pour plus d’informations sur la configuration de Caddy.