One place for hosting & domains

      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

      É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 :

      Naviguez jusqu’à lui :

      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 :

      Ajoutez les lignes suivantes :

      ~/caddy/caddy.go

      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 :

      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 :

      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 :

      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 :

      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 :

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

      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 :

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

      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 :

      /etc/caddy/Caddyfile

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

      /etc/caddy/Caddyfile

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

      Message de Caddy

      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 :

      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 :

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

      ~/caddy/caddy.go

      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 :

      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 :

      /etc/caddy/Caddyfile

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

      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 :

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

      ~/caddy/caddy.go

      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 :

      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 :

      /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 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 :

      /etc/caddy/Caddyfile

      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 :

      ~/caddy/go.mod

      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.



      Source link

      Como hospedar um site com o Caddy no Ubuntu 18.04


      O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Caddy é um servidor Web projetado em torno da simplicidade e segurança que vem com um conjunto de recursos úteis para o hospedagem de sites. Por exemplo, ele pode obter e gerenciar automaticamente os certificados TLS do Let’s Encrypt para habilitar o HTTPS e inclui o suporte para o HTTP/2. O HTTPS é um sistema criado para proteger o tráfego entre seus usuários e seu servidor, e rapidamente se tornou uma expectativa básica de qualquer site em execução na produção — sem ele, o Chrome e o Firefox alertarão que seu site “não é seguro”, caso usuários tentem enviar informações de login.

      Anteriormente, o método recomendado para a instalação do Caddy era de baixar os binários pré-compilados do site do projeto do Caddy. No entanto, devido a alterações na forma como o licenciamento do Caddy funciona, você não tem mais permissão para usar esses binários pré-compilados para fins comerciais, a menos que você pague uma taxa de licença, mesmo que esteja usando o Caddy internamente dentro de uma empresa. Felizmente, o código de origem do Caddy ainda está totalmente em código aberto e você mesmo pode compilar o Caddy para evitar problemas de licenciamento.

      Neste tutorial, você compilará o Caddy a partir da fonte e o utilizará para hospedar um site protegido com o HTTPS. Isso implica compilá-lo, configurá-lo usando um Caddyfile e instalar plug-ins. No final, você aprenderá como atualizar sua instalação quando uma nova versão for liberada.

      Pré-requisitos

      Passo 1 — Compilação do Caddy

      Neste passo, você compilará o Caddy a partir da fonte com a habilidade de adicionar plug-ins mais tarde, tudo sem alterar o código-fonte do Caddy.

      Para fins deste tutorial, você armazenará o código-fonte em ~/caddy. Crie o diretório executando o seguinte comando:

      Navegue até ele:

      Você armazenará o código-fonte para executar e personalizar o Caddy em um arquivo chamado caddy.go. Crie-o usando o seguinte comando:

      Adicione as linhas a seguir:

      ~/caddy/caddy.go

      package main
      
      import (
          "github.com/caddyserver/caddy/caddy/caddymain"
      )
      
      func main() {
          // caddymain.EnableTelemetry = false
          caddymain.Run()
      }
      

      Este código importa o Caddy diretamente do Github (usando o Git) e o inicia a partir da função main de entrada. Caso queira habilitar a telemetria, descomente a linha caddymain.EnableTelemetry e configure o valor para true. Quando terminar, salve e feche o arquivo.

      Para que o caddy.go consiga utilizar as dependências importadas, será necessário inicializá-lo como um módulo:

      Output

      go: creating new go.mod: module caddy

      Neste ponto, você está pronto para compilar a versão de estoque do Caddy a partir do código-fonte acima, executando:

      Haverá várias saídas, detalhando quais bibliotecas o Go baixou como dependências necessárias para a compilação. O executável resultante é armazenado em $GOPATH/bin, como explicado nos pré-requisitos.

      Quando terminar, tente executar o Caddy:

      Você verá um resultado similar ao seguinte:

      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`.

      Isso significa que o Caddy foi iniciado com sucesso e está disponível na porta 2015. Você pode ignorar a mensagem de aviso, pois isso será ajustado em passos mais adiante sem sua intervenção. Para sair, pressione CTRL + C.

      Você compilou e executou o Caddy. Nos próximo passo, você instalará o Caddy como um serviço para que ele seja iniciado automaticamente ao inicializar o sistema e ajustará suas configurações de propriedade e de permissão para garantir a segurança do servidor.

      Passo 2 — Instalando o Caddy

      Agora que você viu que consegue compilar e executar o Caddy, é hora de configurar um serviço systemd para que o Caddy seja iniciado automaticamente na inicialização do sistema. Para entender melhor a respeito do systemd, visite nosso tutorial Essenciais do Systemd.

      Para começar, mova o binário do Caddy para /usr/local/bin, o local padrão para os binários que não são gerenciados pelo gerenciador de pacotes do Ubuntu e não são chaves para a operação do sistema:

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

      Em seguida, mude a propriedade do binário do Caddy para o usuário root:

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

      Isso impedirá que outras contas modifiquem o executável. No entanto, embora o usuário root seja proprietário do Caddy, é recomendável executá-lo apenas usando outras contas não raiz presentes no sistema. Isso garante que, em um evento do Caddy (ou outro programa) ficar comprometido, o invasor não conseguirá modificar o binário ou executar comandos como root.

      Em seguida, defina as permissões do arquivo binário para 755 — isso dá ao root permissões totais de leitura/escrita/execução para o arquivo, enquanto outros usuários poderão apenas ler e executá-lo.

      • sudo chmod 755 /usr/local/bin/caddy

      Como o processo do Caddy não está em execução como root, o Lunix impedirá que ele se vincule às portas 80 e 443 (as portas padrão para o HTTP e o HTTPS, respectivamente), pois estas são operações privilegiadas. Para seu domínio ficar mais acessível, o Caddy precisa ficar ligado a uma dessas portas, dependendo do protocolo. Caso contrário, seria necessário adicionar um número de porta específico à URL do domínio em seu navegador para visualizar o conteúdo que será exibido.

      Execute o seguinte comando para permitir que o Caddy se associe a portas inferiores sem ser executado como root:

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

      O utilitário setcap define as capacidades do arquivo. Neste comando, ele atribui a capacidade CAP_NET_BIND_SERVICE ao binário do Caddy, que permite que um executável se associe a uma porta menor que 1024.

      Agora, você acabou de configurar o binário do Caddy e está pronto para começar a escrever a configuração do Caddy Crie um diretório onde você armazenará os arquivos de configuração do Caddy executando o seguinte comando:

      Em seguida, defina as permissões do usuário e do grupo corretos para ele:

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

      Definir o usuário como root e o grupo como www-data garante que o Caddy terá o acesso de leitura e escrita à pasta (via grupo www-data) e que apenas a conta do superuser terá os mesmos direitos de ler e modificar. O www-data é o usuário e o grupo padrão para os servidores Web no Ubuntu.

      Em um passo mais adiante, você habilitará o fornecimento automático do certificado TLS do Let’s Encrypt. Para nos prepararmos para isso, crie um diretório para armazenar todos os certificados TLS que o Caddy receberá e dê a ele as mesmas regras de propriedade do diretório /etc/caddy:

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

      O Caddy deve conseguir escrever certificados para este diretório e ler a partir dele para criptografar solicitações. Por este motivo, modifique as permissões do diretório /etc/ssl/caddy, para que ele seja acessível apenas pelo root e pelo www-data:

      • sudo chmod 0770 /etc/ssl/caddy

      Em seguida, crie um diretório para armazenar os arquivos que o Caddy hospedará:

      Então, defina o proprietário e o grupo do diretório para www-data:

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

      O Caddy lê suas configurações a partir de um arquivo chamado Caddyfile, armazenado em /etc/caddy. Crie o arquivo no disco executando:

      • sudo touch /etc/caddy/Caddyfile

      Para instalar o serviço Caddy, baixe o arquivo de unidade do systemd no repositório Caddy Github para /etc/systemd/system, executando:

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

      Modifique as permissões do arquivo de serviço para que ele só possa ser modificado pelo seu proprietário, o root:

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

      Então, recarregue o systemd para detectar o serviço do Caddy:

      • sudo systemctl daemon-reload

      Verifique se o systemd detectou o serviço Caddy executando systemctl status:

      • sudo systemctl status caddy

      Você verá um resultado parecido com este:

      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

      Caso veja este mesmo resultado, então o novo serviço foi detectado corretamente pelo systemd.

      Como parte do pré-requisito da configuração inicial do servidor, você habilitou o ufw, um firewall descomplicado e permitiu conexões do tipo SSH. Para que o Caddy possa exibir tráfegos HTTP e HTTPS de seu servidor, será necessário permiti-los no ufw, executando o seguinte comando:

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

      O resultado será:

      Output

      Rule added Rule added (v6)

      Utilize o ufw status para verificar se suas alterações funcionaram:

      Você verá o seguinte resultado:

      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)

      Sua instalação do Caddy está completa, mas ela não está configurada para exibição. No próximo passo, você configurará o Caddy para exibir arquivos a partir do diretório /var/www.

      Passo 3 — Configurando o Caddy

      Nesta seção, você escreverá a configuração básica do Caddy para exibir arquivos estáticos do seu servidor.

      Comece criando um arquivo HTML básico em /var/www, chamado index.html:

      • sudo nano /var/www/index.html

      Adicione as linhas a seguir:

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

      Este arquivo, quando for mostrado em um navegador Web, exibirá um cabeçalho com o texto This page is being served via Caddy. Salve e feche o arquivo.

      Abra o arquivo de configuração Caddyfile que você criou mais cedo para a edição:

      • sudo nano /etc/caddy/Caddyfile

      Adicione as linhas a seguir:

      /etc/caddy/Caddyfile

      :80 {
        root /var/www
        gzip
      }
      

      Esta é uma configuração básica do Caddy, e ela declara que a porta 80 do seu servidor deve ser exibida com os arquivos da /var/www e eles devem ser compactados usando o gzip, para reduzir o tempo de carregamento da página no lado do cliente.

      Na maioria dos casos, o Caddy permite que você personalize as diretivas de configuração ainda mais. Por exemplo, você pode limitar a compactação do gzip apenas para os arquivos HTML e PHP e definir o nível de compactação para 6 (1 sendo o mais baixo e 9 sendo o mais alto), estendendo a diretiva com chaves e listando as sub-diretivas abaixo:

      /etc/caddy/Caddyfile

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

      Quando terminar, salve e feche o arquivo.

      O Caddy possui um grande número de diretivas diferentes para muitos casos de uso. Por exemplo, a diretiva fastcgi poderia ser útil para habilitar o PHP. A diretiva markdown poderia ser usada para converter automaticamente os arquivos Markdown para HTML antes de exibi-los. Isso poderia ser útil para a criação de um blog simples.

      Para testar se tudo está funcionando corretamente, inicie o serviço Caddy:

      • sudo systemctl start caddy

      Em seguida, execute systemctl status para encontrar informações sobre o status do serviço do Caddy:

      • sudo systemctl status caddy

      Você verá o seguinte:

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

      Agora, você pode ir para o IP do seu servidor em um navegador Web. Sua página de amostra Web exibirá:

      Mensagem do Caddy

      Você configurou o Caddy para exibir arquivos estáticos do seu servidor. No próximo passo, você ampliará a funcionalidade do Caddy através do uso de plug-ins.

      Passo 4 — Usando plug-ins

      Os plug-ins oferecem uma maneira de alterar e ampliar o comportamento do Caddy. Geralmente, eles oferecem mais diretivas de configuração para você usar, de acordo com seu caso de uso. Nesta seção, você adicionará e utilizará plug-ins instalando o plug-in minify, que remove o excesso de espaços em branco e arruma o código que será enviado para o cliente, reduzindo ainda mais o volume e o tempo de carregamento.

      O repositório GitHub do plug-in minify é o hacdias/caddy-minify.

      Vá até o diretório com o código-fonte que você criou no passo um:

      Para adicionar um plug-in ao Caddy, será necessário importá-lo no arquivo caddy.go que você usou para compilar o Caddy. Abra o caddy.go​​​ para edição:

      Importe o plug-in minify, adicionando a linha destacada, desta forma:

      ~/caddy/caddy.go

      package main
      
      import (
          "github.com/caddyserver/caddy/caddy/caddymain"
      
          _ "github.com/hacdias/caddy-minify"
      )
      
      func main() {
          // caddymain.EnableTelemetry = false
          caddymain.Run()
      }
      

      Salve e feche o arquivo.

      Alguns plug-ins podem precisar de pequenos ajustes de configuração. Certifique-se de ler a documentação dos plug-ins que instalar. É possível encontrar uma lista dos plug-ins mais populares no painel esquerdo da documentação do Caddy, embaixo de Plugins.

      Sempre que adicionar um novo plug-in, você terá que compilar o Caddy novamente. Isso acontece porque o Go é uma linguagem de programação compilada, o que significa que o código-fonte é transformado em código de máquina antes da execução. Sua mudança para a declaração de importação alterou o código-fonte, mas não afetará o binário até que ele seja compilado.

      Use o comando go install para compilar o Caddy:

      Quando ele terminar de compilar, mova o binário gerado para /usr/local/bin e configure as permissões para o binário como você fez anteriormente. Você deve executar esses passos sempre que você for compilar o Caddy novamente, para garantir sua funcionalidade e segurança:

      • 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

      Para começar a utilizar o plug-in minify, será necessário adicionar a diretiva minify para seu Caddyfile. Abra o Caddyfile​​​ para edição:

      • sudo nano /etc/caddy/Caddyfile

      Habilite o plug-in adicionando a seguinte linha ao bloco de configuração:

      /etc/caddy/Caddyfile

      :80 {
        root /var/www
        gzip
        minify
      }
      

      Agora, reinicie seu servidor usando systemctl:

      • sudo systemctl restart caddy

      O Caddy está agora em execução e diminuirá todos os arquivos que ele exibir, incluindo o arquivo index.html que você criou mais cedo. Você pode observar a ‘diminuição’ em trabalho buscando o conteúdo do seu domínio usando o curl:

      Você verá o seguinte resultado: Note que todo o espaço em branco desnecessário foi removido, mostrando que o plug-in minify está funcionando.

      Output

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

      Neste passo, você aprendeu como estender o Caddy com plug-ins. Em seguida, você habilitará o HTTPS instalando o plug-in tls.dns.digitalocean.

      Nesta seção, você habilitará o fornecimento e renovação automáticos de certificados do Let’s Encrypt usando registros DNS TXT para verificação.

      Para verificar o uso de registro TXT DNS, será necessário instalar um plug-in para interagir com a API da Digital Ocean chamado tls.dns.digitalocean. O processo de instalação dele é quase idêntico ao modo como você instalou o plug-in minify no passo anterior. Para começar, abra o caddy.go:

      Adicione o repositório do plug-in às importações:

      ~/caddy/caddy.go

      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()
      }
      

      Compile-o executando:

      Certifique-se de que o Caddy está parado através do systemctl e, em seguida, termine de instalar o plug-in copiando o binário do Caddy recém compilado e, mais uma vez, configure a propriedade e permissões dele:

      • 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

      Em seguida, configure o Caddy para trabalhar com a API da DigitalOcean para definir registros de DNS. O Caddy precisa acessar este token como uma variável de ambiente para configurar o DNS da DigitalOcean. Assim sendo, você editará o arquivo de unidade systemd:

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

      Encontre a linha que começa com o Environment= na seção [Service]. Essa linha define as variáveis de ambiente que devem ser enviadas para o processo do Caddy. Adicione um espaço no final desta linha e então, adicione uma variável DO_AUTH_TOKEN, seguida pelo token que acabou de gerar:

      /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
      

      Salve e feche este arquivo e, em seguida, recarregue o daemon do systemd como fez anteriormente para garantir que a configuração esteja atualizada:

      • sudo systemctl daemon-reload

      Execute o systemctl status para verificar que suas alterações de configuração estavam OK:

      • sudo systemctl status caddy

      O resultado deve ficar parecido com este:

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

      Será necessário fazer algumas pequenas alterações no seu Caddyfile, então abra-o para edição:

      • sudo nano /etc/caddy/Caddyfile

      Adicione as linhas destacadas ao Caddyfile, certificando-se de substituir o your_domain pelo seu domínio (em vez de apenas a porta :80) e de comentar o gzip:

      /etc/caddy/Caddyfile

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

      Usar um domínio em vez de apenas uma porta para o nome do host fará com que o Caddy atenda solicitações por HTTPS. A diretiva tls configura o comportamento do Caddy ao usar o TLS, e a sub-diretiva dns especifica que o Caddy deve usar o sistema DNS-01, em vez de HTTP-01.

      Com isso, seu site está pronto para ser implantado. Inicie o Caddy com o systemctl e, em seguida, use enable para habilitá-lo para que ele seja executado na inicialização do sistema:

      • sudo systemctl start caddy
      • sudo systemctl enable caddy

      Se você for para seu domínio, será automaticamente redirecionado para o HTTPS, com a mesma mensagem mostrada.

      Sua instalação do Caddy está completa e protegida, e você pode personalizar ainda mais de acordo com seu caso de uso.

      Caso queira atualizar o Caddy quando uma nova versão sair, será necessário atualizar o arquivo go.mod (armazenado no mesmo diretório), que se parece com isto:

      ~/caddy/go.mod

      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
      )
      

      A parte destacada é a versão do Caddy que você está usando. Quando uma nova versão for lançada no Github (veja a página de lançamentos de tags), você pode substituir a versão existente no go.mod por ela e compilar o Caddy, de acordo com os dois primeiros passos. Faça o mesmo em todos os plug-ins importados.

      Conclusão

      Agora, você tem o Caddy instalado e configurado em seu servidor, atendendo páginas estáticas em seu domínio desejado, protegido com certificados do Let’s Encrypt gratuitos.

      Um bom próximo passo seria encontrar uma maneira de ser notificado quando novas versões do Caddy fossem liberadas. Por exemplo, você pode utilizar o feed do Atom para lançamentos do Caddy, ou um serviço dedicado, como o dependencies.io.

      Explore a documentação do Caddy para obter maiores informações a respeito da configuração do Caddy.



      Source link

      How to Deploy a Static Site on Linode Kubernetes Engine


      Updated by Linode Contributed by Linode

      Note

      Linode Kubernetes Engine (LKE) is currently in Private Beta, and you may not have access to LKE through the Cloud Manager or other tools. To request access to the Private Beta, sign up here. Beta access awards you $100/month in free credits for the duration of the beta, which is automatically applied to your account when an LKE cluster is in use. Additionally, you will have access to the Linode Green Light community, a new program connecting beta users with our product and engineering teams.

      Because LKE is in Beta, there may be breaking changes to how you access and manage LKE. This guide will be updated to reflect these changes if and when they occur.

      Linode Kubernetes Engine (LKE) allows you to easily create, scale, and manage Kubernetes clusters to meet your application’s demands, reducing the often complicated cluster set-up process to just a few clicks. Linode manages your Kubernetes master node, and you select how many Linodes you want to add as worker nodes to your cluster.

      Deploying a static site using an LKE cluster is a great example to follow when learning Kubernetes. A container image for a static site can be written in less than ten lines, and only one container image is needed, so it’s less complicated to deploy a static site on Kubernetes than some other applications that require multiple components.

      Caution

      Following the instructions in this guide will create billable resources on your account in the form of Linodes and NodeBalancers. You will be billed an hourly rate for the time that these resources exist on your account. Be sure to follow the tear-down section at the end of this guide if you do not wish to continue using these resources.

      In this Guide

      This guide will show you how to:

      Before You Begin

      • You should have a working knowledge of Kubernetes’ key concepts, including master and worker nodes, Pods, Deployments, and Services. For more information on Kubernetes, see our Beginner’s Guide to Kubernetes series.

      • You will also need to prepare your workstation with some prerequisite software:

      • Finally, you will need to create a cluster on LKE, if you do not already have one:

      Install kubectl

      You should have kubectl installed on your local workstation. kubectl is the command line interface for Kubernetes, and allows you to remotely connect to your Kubernetes cluster to perform tasks.

      macOS:

      Install via Homebrew:

      brew install kubernetes-cli
      

      If you don’t have Homebrew installed, visit the Homebrew home page for instructions. Alternatively, you can manually install the binary; visit the Kubernetes documentation for instructions.

      Linux:

      1. Download the latest kubectl release:

        curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
        
      2. Make the downloaded file executable:

        chmod +x ./kubectl
        
      3. Move the command into your PATH:

        sudo mv ./kubectl /usr/local/bin/kubectl
        

      Note

      Windows:

      Visit the Kubernetes documentation for a link to the most recent Windows release.

      Install Git

      To perform some of the commands in this guide you will need to have Git installed on your workstation. Git is a version control system that allows you to save your codebase in various states to ease development and deployment. Follow our How to Install Git on Linux, Mac or Windows guide for instructions on how to install Git.

      Install Docker

      These steps install Docker Community Edition (CE) using the official Ubuntu repositories. To install on another distribution, or to install on Mac or Windows, see the official installation page.

      1. Remove any older installations of Docker that may be on your system:

        sudo apt remove docker docker-engine docker.io
        
      2. Make sure you have the necessary packages to allow the use of Docker’s repository:

        sudo apt install apt-transport-https ca-certificates curl software-properties-common
        
      3. Add Docker’s GPG key:

        curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
        
      4. Verify the fingerprint of the GPG key:

        sudo apt-key fingerprint 0EBFCD88
        

        You should see output similar to the following:

          
        pub   4096R/0EBFCD88 2017-02-22
                Key fingerprint = 9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
        uid                  Docker Release (CE deb) 
        sub   4096R/F273FCD8 2017-02-22
        
        
      5. Add the stable Docker repository:

        sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
        

        Note

        For Ubuntu 19.04, if you get an E: Package 'docker-ce' has no installation candidate error, this is because the stable version of docker is not yet available. Therefore, you will need to use the edge / test repository.

        sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable edge test"
        
      6. Update your package index and install Docker CE:

        sudo apt update
        sudo apt install docker-ce
        
      7. Add your limited Linux user account to the docker group:

        sudo usermod -aG docker $USER
        

        Note

        After entering the usermod command, you will need to close your SSH session and open a new one for this change to take effect.

      8. Check that the installation was successful by running the built-in “Hello World” program:

        docker run hello-world
        

      Sign up for a Docker Hub Account

      You will use Docker Hub to store your Docker image. If you don’t already have a Docker Hub account, create one now.

      Install Hugo

      A static site generator (SSG) is usually a command line tool that takes text files written in a markup language like Markdown, applies a stylized template to the content, and produces valid HTML, CSS, and JavaScript files. Static sites are prized for their simplicity and speed, as they do not generally have to interact with a database.

      The Linode documentation website, and this guide, employ Hugo. Hugo is a powerful and fast SSG written in the Go programming language, but you can choose one that best suits your needs by reading our How to Choose a Static Site Generator guide.

      The steps in this guide are generally the same across SSGs: install a static site generator, create some content in a text file, and then generate your site’s HTML through a build process.

      To download and install Hugo, you can use a package manager.

      • For Debian and Ubuntu:

        sudo apt-get install hugo
        
      • For Red Hat, Fedora, and CentOS:

        sudo dnf install hugo
        
      • For macOS, use Homebrew:

        brew install hugo
        
      • For Windows, use Chocolatey:

        choco install hugo
        

      For more information on downloading Hugo, you can visit the official Hugo website.

      Create a Static Site Using Hugo

      In this section you will create a static site on your workstation using Hugo.

      1. Use Hugo to scaffold a new site. This command will create a new directory with the name you provide, and inside that directory it will create the default Hugo directory structure and configuration files:

        hugo new site lke-example
        
      2. Move into the new directory:

        cd lke-example
        
      3. Initialize the directory as a Git repository. This will allow you to track changes to your website and save it in version control.

        git init
        
      4. Hugo allows for custom themes. For the sake of this example, you will install the Ananke theme as a Git submodule.

        git submodule add https://github.com/budparr/gohugo-theme-ananke.git themes/ananke
        

        Note

        Git submodules allow you to include one Git repository within another, each maintaining their own version history. To view a collection of Hugo themes, visit the Hugo theme collection.
      5. In the text editor of your choice, open the config.toml file and add the following line to the end:

        theme = "ananke"
        

        This line instructs Hugo to search for a folder named ananke in the themes directory and applies the templating it finds to the static site.

      6. Add an example first post to your Hugo site:

        hugo new posts/first_post.md
        

        This will create a Markdown file in the content/posts/ directory with the name first_post.md. You will see output like the following:

          
        /Users/linode/k8s/lke/lke-example/content/posts/first_post.md created
        
        
      7. Open the first_post.md file in the text editor of your choosing. You will see a few lines of front matter, a format Hugo uses for extensible metadata, at the top of the file:

        lke-example/content/posts/first_post.md
        1
        2
        3
        4
        5
        
        ---
        title: "First_post"
        date: 2019-07-29T14:22:04-04:00
        draft: false
        ---

        Change the title to your desired value, and change draft to false. Then, add some example Markdown text to the bottom of the file, like the example below:

        lke-example/content/posts/first_post.md
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        
        ---
        title: "First Post About LKE Clusters"
        date: 2019-07-29T14:22:04-04:00
        draft: false
        ---
        
        ## LKE Clusters
        
        Linode Kubernetes Engine (LKE) clusters are:
        
        - Fast
        - Affordable
        - Scalable
      8. You can preview your changes by starting the local Hugo server:

        hugo server
        

        You should see output like the following:

          
                           | EN
        +------------------+----+
          Pages              |  8
          Paginator pages    |  0
          Non-page files     |  0
          Static files       |  3
          Processed images   |  0
          Aliases            |  0
          Sitemaps           |  1
          Cleaned            |  0
        
        Total in 6 ms
        Watching for changes in /Users/linode/k8s/lke/lke-example/{content,data,layouts,static,themes}
        Watching for config changes in /Users/linode/k8s/lke/lke-example/config.toml
        Serving pages from memory
        Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender
        Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
        Press Ctrl+C to stop
        
        
      9. Visit the URL that Hugo is running on. In the above example, the URL is http://localhost:1313. This server automatically updates whenever you make a change to a file in the Hugo site directory. To stop this server, enter CTRL-C on your keyboard in your terminal.

      10. When you are satisfied with your static site, you can generate the HTML, CSS, and JavaScript for your site by building the site:

        hugo -v
        

        Hugo creates the site’s files in the public/ directory. View the files by listing them:

        ls public
        
      11. You can build the site at any time from your source Markdown content files, so it’s common practice to keep built files out of a Git repository. This practice keeps the size of the repository to a minimum.

        You can instruct Git to ignore certain files within a repository by adding them to a .gitignore file. Add the public/ directory to your .gitignore file to exclude these files from the repository:

        echo 'public/' >> .gitignore
        
      12. Add and commit the source files to the Git repository:

        git add .
        git commit -m "Initial commit. Includes all of the source files, configuration, and first post."
        

        You are now ready to create a Docker image from the static site you’ve just created.

      Create a Docker Image

      In this section you will create a Docker container for your static site, which you will then run on your LKE cluster. Before deploying it on your cluster, you’ll test its functionality on your workstation.

      1. In your Hugo static site folder, create a new text file named Dockerfile and open it in the text editor of your choosing. A Dockerfile tells Docker how to create the container.

      2. Add the following contents to the Dockerfile. Each command has accompanying comments that describe their function:

        lke-example/Dockerfile
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        
        # Install the latest Debain operating system.
        FROM debian:latest as HUGO
        
        # Install Hugo.
        RUN apt-get update -y
        RUN apt-get install hugo -y
        
        # Copy the contents of the current working directory to the
        # static-site directory.
        COPY . /static-site
        
        # Command Hugo to build the static site from the source files,
        # setting the destination to the public directory.
        RUN hugo -v --source=/static-site --destination=/static-site/public
        
        # Install NGINX, remove the default NGINX index.html file, and
        # copy the built static site files to the NGINX html directory.
        FROM nginx:stable-alpine
        RUN mv /usr/share/nginx/html/index.html /usr/share/nginx/html/old-index.html
        COPY --from=HUGO /static-site/public/ /usr/share/nginx/html/
        
        # Instruct the container to listen for requests on port 80 (HTTP).
        EXPOSE 80

        Save the Dockerfile and return to the command prompt.

      3. Create a new text file named .dockerignore in your Hugo static site folder and add the following lines:

        lke-example/.dockerignore
        1
        2
        3
        4
        
        public/
        .git/
        .gitmodules/
        .gitignore

        Note

        This file, similar to the .gitignore file you created in the previous section, allows you to ignore certain files within the working directory that you would like to leave out of the container. Because you want the container to be the smallest size possible, the .dockerignore file will include the public/ folder and some hidden folders that Git creates.

      4. Run the Docker build command. Replace mydockerhubusername with your Docker Hub username. The period at the end of the command tells Docker to use the current directory as its build context.

        docker build -t mydockerhubusername/lke-example:v1 .
        

        Note

        In the example below, the container image is named lke-example and has been given a version tag of v1. Feel free to change these values.

      5. Docker will download the required Debian and NGINX images, as well as install Hugo into the image. Once complete, you should see output similar to the following:

          
        Successfully built 320ae416c940
        Successfully tagged mydockerhubusername/lke-example:v1
        
        
      6. You can view the image by listing all local images:

        docker images
        
          
        REPOSITORY                       TAG   IMAGE ID       CREATED             SIZE
        mydockerhubusername/lke-example  v1    320ae416c940   About an hour ago   20.8MB
        
        

      Test the Docker Image

      1. You can test your new image by creating a container with it locally. To do so, enter the following run command:

        docker run -p 8080:80 -d mydockerhubusername/lke-example:v1
        

        The -p flag instructs Docker to forward port 8080 on localhost to port 80 on the container. The -d flag instructs Docker to run in detached mode so that you are returned to the command prompt once the container initializes.

      2. Once the container has started, open your browser and navigate to localhost:8080. You should see your static site.

      3. You can stop the running container by finding the ID of the container and issuing the stop command. To find the ID of the container, use the ps command:

        docker ps
        

        You should see a list of actively running containers, similar to the following:

          
        b4a7b959a6c7        mydockerhubusername/lke-example:v1         "nginx -g 'daemon of…"   5 hours ago         Up 5 hours          0.0.0.0:8080->80/tcp        romantic_mahavira
        
        
      4. Note the random string of numbers and letters next to the image name. In the above example, the string is b4a7b959a6c7. Issue the stop command, supplying the string of numbers and letters:

        docker stop b4a7b959a6c7
        

      Upload the Image to Docker Hub

      1. Now that you have a working container image, you can push that image to Docker Hub. First, log in to Docker Hub from your workstation’s terminal:

        docker login
        
      2. Next, push the image, with version tag, to Docker Hub, using the push command:

        docker push mydockerhubusername/lke-example:v1
        

        You can now view your image on Docker Hub as a repository. To view all of your repositories, navigate to the Docker Hub repository listing page.

      3. Lastly, add the Dockerfile and .dockerignore file to your Git repository:

        git add .
        git commit -m "Add Dockerfile and .dockerignore."
        

        You are now ready to deploy the container to your LKE cluster.

      Deploying the Container to LKE

      In this section, you will create a Deployment from the container you created in the previous section, and a Service to load balance the deployment.

      1. Begin by navigating to a location outside of your static site directory. You will not need your static site directory for the remainder of this guide.

        cd ..
        
      2. Create a new directory to house your Kubernetes manifests, and move into that directory:

        mkdir manifests && cd manifests
        

      Create a Deployment

      1. In the text editor of your choice, create a new YAML manifest file for your Deployment. Name the file static-site-deployment.yaml, save it to your manifests directory, and enter the contents of this snippet:

        manifests/static-site-deployment.yaml
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        
        apiVersion: apps/v1
        kind: Deployment
        metadata:
          name: static-site-deployment
          labels:
            app: static-site
        spec:
          replicas: 3
          selector:
            matchLabels:
              app: static-site
          template:
            metadata:
              labels:
                app: static-site
            spec:
              containers:
              - name: static-site
                image: mydockerhubusername/lke-example:v1
                imagePullPolicy: Always
                ports:
                - containerPort: 80
        • In this example the number of replica Pods is set to 3 on line 8. This value can be changed to meet the needs of your website.
        • The spec.containers.image field on line 19 should be changed to match the name of the container image you pushed to Docker Hub. Be sure to include the proper version tag at the end of the container name.
        • imagePullPolicy: Always on line 20 ensures that each time a Pod is created, the most recent version of the container image will be pulled from Docker Hub.
      2. Once you have a Deployment manifest, you can apply the deployment to the LKE cluster with kubectl:

        kubectl apply -f static-site-deployment.yaml
        
      3. You can check on the progress of your Deployment by listing the available pods:

        kubectl get pods
        

        If your Deployment was successful, you should see output like the following:

          
        NAME                                    READY   STATUS   RESTARTS   AGE
        static-site-deployment-cdb88b5bb-7pbjc  1/1     Running  0          1h
        static-site-deployment-cdb88b5bb-gx9h5  1/1     Running  0          1h
        static-site-deployment-cdb88b5bb-lzdvh  1/1     Running  0          1h
        
        

      Create a Service

      1. Create a Service manifest file to provide load balancing for the deployment. Load balancing ensures that traffic is balanced efficiently across multiple backend nodes, improving site performance and ensuring that your static site will be accessible should a node go down.

        Specifically, the Service manifest that will be used in this guide will trigger the creation of a Linode NodeBalancer.

        Note

      2. Name the file static-site-service.yaml, save it to your manifests directory, and enter the contents of this snippet:

        manifests/static-site-service.yaml
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        
        apiVersion: v1
        kind: Service
        metadata:
          name: static-site-service
          annotations:
            service.beta.kubernetes.io/linode-loadbalancer-throttle: "4"
          labels:
            app: static-site
        spec:
          type: LoadBalancer
          ports:
          - name: http
            port: 80
            protocol: TCP
            targetPort: 80
          selector:
            app: static-site
          sessionAffinity: None
      3. Once you’ve created your Service manifest file, you can apply it to the LKE cluster:

        kubectl apply -f static-site-service.yaml
        
      4. You can check on the status of your Service by listing the Services currently running on your server:

        kubectl get services
        

        You should see output similar to the following:

          
        NAME                 TYPE          CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
        kubernetes           ClusterIP     10.128.0.1     <none>           443/TCP        20h
        static-site-service  LoadBalancer  10.128.99.240  192.0.2.1        80:32648/TCP   100m
        
        
      5. Note the external IP address of the Service you created. This is the IP address of the NodeBalancer, and you can use it to view your static site.

      6. In the above example, the IP address is 192.0.2.1. Navigate to the external IP address in the browser of your choice to view your static site. You should see the same content as when you tested your Docker image on your workstation.

      Next Steps

      If you’d like to continue using the static site that you created in this guide, you may want to assign a domain to it. Review the DNS Records: An Introduction and DNS Manager guides for help with setting up DNS. When setting up your DNS record, use the external IP address that you noted at the end of the previous section.

      If you would rather not continue using the cluster you just created, review the tear-down section to remove the billable Linode resources that were generated.

      Tear Down your LKE Cluster and NodeBalancer

      • To remove the NodeBalancer you created, all you need to do is delete the underlying Service. From your workstation:

        kubectl delete service static-site-service
        

        Alternatively, you can use the manifest file you created to delete the Service. From your workstation:

        kubectl delete -f static-site-service.yaml
        
      • To remove the LKE Cluster and the associated nodes from your account, navigate to the Linode Cloud Manager:

        1. Click on the Kubernetes link in the sidebar. A new page with a table which lists your clusters will appear.

        2. Click on the more options elipsis next to the cluster you would like to delete, and select Delete.

        3. You will be prompted to enter the name of the cluster to confirm the action. Enter the cluster name and click Delete.

      • Lastly, remove the KUBECONFIG line you added to your Bash profile to remove the LKE cluster from your available contexts.

      More Information

      You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

      Find answers, ask questions, and help others.

      This guide is published under a CC BY-ND 4.0 license.



      Source link