One place for hosting & domains

      Comment installer WordPress sur Ubuntu 20.04 avec un LAMP Stack


      Introduction

      WordPress est une technologie open-source extrêmement populaire pour la création de sites web et de blogs sur l’internet aujourd’hui. Utilisés par 63 % des sites web qui utilisent un système de gestion de contenu (CMS), les sites WordPress représentent 36 % de tous les sites web qui sont actuellement en ligne.

      Il existe de nombreuses approches différentes pour accéder à WordPress et certains processus de configuration sont plus complexes que d’autres. Ce tutoriel est destiné à ceux qui souhaitent installer et administrer une instance de WordPress sur un serveur en nuage non géré via la ligne de commande. Bien que cette approche nécessite plus d’étapes qu’une installation WordPress toute faite, elle offre aux administrateurs un plus grand contrôle sur leur environnement WordPress.

      Si vous cherchez à accéder à une installation WordPress prête à l’emploi, DigitalOcean Marketplace propose une app en un clic pour vous aider à démarrer avec WordPress, jusqu’à l’installation lors de la mise en route de votre serveur.

      En fonction de vos besoins et de vos objectifs, vous pouvez trouver d’autres options plus adaptées. En tant que logiciel open-source, WordPress peut être téléchargé et installé gratuitement, mais pour être disponible sur le web, vous devrez probablement acheter une infrastructure en nuage et un nom de domaine. Continuez à suivre ce guide si vous êtes intéressé par l’installation côté serveur et par la mise en place d’un site WordPress.

      Ce tutoriel utilisera un LAMP (Linux, Apache, MySQL et PHP) stack qui est une option pour une architecture de serveur qui supporte WordPress en fournissant le système d’exploitation Linux, le serveur web Apache, la base de données MySQL et le langage de programmation PHP. Nous installerons et configurerons WordPress via LAMP sur un serveur Linux Ubuntu 20.04.

      Conditions préalables

      Pour pouvoir suivre ce tutoriel, vous devez avoir accès à un serveur Ubuntu 20.04 et effectuer les étapes suivantes avant de commencer ce guide :

      • Configurez votre serveur en suivant notre guide de configuration initiale du serveur Ubuntu 20.04 et assurez-vous d’avoir un non-root sudo user. 
      • Installez un LAMP stack en suivant notre guide LAMP pour installer et configurer ce logiciel.
      • Sécurisez votre site : WordPress prend en compte les entrées de l’utilisateur et stocke ses données, il est donc important pour lui d’avoir une couche de sécurité. TLS/SSL est la technologie qui vous permet de crypter le trafic de votre site afin que votre connexion et celle de vos utilisateurs soient sécurisées. Voici deux options qui s’offrent à vous pour répondre à cette exigence :
        • Si vous avez un nom de domaine… vous pouvez sécuriser votre site avec Let’s Encrypt, qui fournit des certificats gratuits et fiables. Suivez notre guide Let’s Encrypt pour Apache afin de configurer cela.
        • Si vous n’avez pas de domaine… et que vous utilisez cette configuration à des fins de test ou pour un usage personnel, vous pouvez à la place utiliser un certificat auto-signé. Cela permet d’obtenir le même type de chiffrement, mais sans la validation du domaine. Suivez notre guide SSL auto-signé pour Apache afin de le mettre en place.

      Une fois les étapes de préparation terminées, connectez-vous à votre serveur en tant qu’utilisateur sudo et continuez ci-dessous.

      Étape 1 – Créer une base de données MySQL et un utilisateur pour WordPress

      La première étape que nous allons suivre est une étape préparatoire. WordPress utilise MySQL pour gérer et stocker les informations du site et des utilisateurs. Nous avons déjà installé MySQL, mais nous devons créer une base de données et un utilisateur pour WordPress.

      Pour commencer, connectez-vous au compte MySQL root (administratif) en exécutant cette commande (notez que ce n’est pas le root user de votre serveur) :

      Le mot de passe que vous avez défini pour le compte root MySQL lors de son installation vous sera demandé.

      Note : Si vous ne pouvez pas accéder à votre base de données MySQL via le root, en tant que sudo user, vous pouvez mettre à jour le mot de passe de votre root user en vous connectant à la base de données de cette manière : 

      Une fois que vous recevez l’invite MySQL, vous pouvez mettre à jour le mot de passe du root user. Ici, remplacez new_password par un mot de passe fort de votre choix.

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'new_password';

      Vous pouvez maintenant taper EXIT ; et vous pouvez vous reconnecter à la base de données via un mot de passe avec la commande suivante :

      Dans la base de données, nous pouvons créer une base de données exclusive que WordPress peut contrôler. Vous pouvez l’appeler comme vous le souhaitez, mais nous utiliserons le nom wordpress dans ce guide. Créez la base de données pour WordPress en tapant :

      • CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

      Remarque : chaque instruction MySQL doit se terminer par un point-virgule (;). Vérifiez qu’il est bien présent si vous rencontrez des problèmes.

      Ensuite, nous allons créer un compte utilisateur MySQL distinct que nous utiliserons exclusivement pour exploiter notre nouvelle base de données. La création de bases de données et de comptes spécifiques peut nous aider du point de vue de la gestion et de la sécurité. Nous utiliserons le nom wordpressuser dans ce guide, mais n’hésitez pas à utiliser le nom qui vous convient le mieux.

      Nous allons créer ce compte, définir un mot de passe et lui donner accès à la base de données que nous avons créée. Nous pouvons le faire en tapant la commande ci-dessous. N’oubliez pas de choisir un mot de passe fort ici pour l’utilisateur de votre base de données où nous avons password :

      • CREATE USER 'wordpressuser'@'%' IDENTIFIED WITH mysql_native_password BY 'password';

      Ensuite, faites savoir à la base de données que notre wordpressuser devrait avoir un accès complet à la base de données que nous avons mise en place : 

      • GRANT ALL ON wordpress.* TO 'wordpressuser'@'%';

      Vous disposez désormais d’une base de données et d’un compte d’utilisateur, chacun spécialement conçu pour WordPress. Nous devons supprimer les privilèges afin que l’instance actuelle de MySQL soit informée des récents changements que nous avons apportés :

      Sortez de MySQL en tapant :

      Dans la prochaine étape, nous poserons quelques bases pour les plugins WordPress en téléchargeant des extensions PHP pour notre serveur.

      Étape 2 – Installez des extensions PHP supplémentaires

      Lors de la mise en place de notre pile LAMP, nous n’avons eu besoin que d’un ensemble très limité d’extensions pour que PHP puisse communiquer avec MySQL. WordPress et beaucoup de ses plugins utilisent des extensions PHP supplémentaires.

      Nous pouvons télécharger et installer certaines des extensions PHP les plus populaires pour WordPress en tapant :

      • sudo apt update
      • sudo apt install php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip

      Cela permettra de préparer le terrain pour l’installation de plugins supplémentaires sur notre site WordPress.

      Remarque : chaque plugin WordPress a ses propres exigences. Certains peuvent nécessiter l’installation de packages PHP supplémentaires. Consultez la documentation de votre plugin pour connaître ses besoins en matière de PHP. S’ils sont disponibles, ils peuvent être installés avec apt comme illustré ci-dessus.

      Nous devrons redémarrer Apache pour charger ces nouvelles extensions, nous ferons d’autres configurations sur Apache dans la prochaine section, vous pouvez donc attendre jusque-là, ou redémarrer maintenant pour terminer le processus d’extension PHP.

      • sudo systemctl restart apache2

      Étape 3 – Ajuster la configuration d’Apache pour autoriser .htaccess à remplacer et réécrire

      Nous allons maintenant procéder à quelques ajustements mineurs de notre configuration Apache. Après avoir suivi les tutoriaux préalables, vous devez disposer d’un fichier de configuration pour votre site dans le répertoire /etc/apache2/sites-available/.

      Dans ce guide, nous utiliserons ici /etc/apache2/sites-available/wordpress.conf comme exemple, mais vous devez substituer le chemin d’accès à votre fichier de configuration le cas échéant. De plus, nous utiliserons /var/www/wordpress comme répertoire root de notre installation WordPress. Vous devez utiliser la racine Web spécifiée dans votre propre configuration. Si vous avez suivi notre tutoriel LAMP, il se peut que ce soit votre nom de domaine au lieu de wordpress dans ces deux cas.

      Remarque : il est possible que vous utilisiez la configuration par défaut 000-default.conf (avec /var/www/html comme racine Web). C’est une bonne solution si vous n’hébergez qu’un seul site web sur ce serveur. Sinon, il est préférable de diviser la configuration nécessaire en morceaux logiques, un fichier par site.

      Une fois nos chemins identifiés, nous pouvons passer à la collaboration avec htaccess afin qu’Apache puisse gérer les changements de configuration par répertoire. 

      Autoriser les remplacements .htaccess

      Actuellement, l’utilisation des fichiers .htaccess est désactivée. WordPress et de nombreux plugins WordPress utilisent ces fichiers de manière intensive pour des ajustements dans les répertoires du comportement du serveur web.

      Ouvrez le fichier de configuration Apache pour votre site web avec un éditeur de texte comme nano.

      • sudo nano /etc/apache2/sites-available/wordpress.conf

      Pour autoriser les fichiers .htaccess, nous devons paramétrer la directive AllowOverride dans un bloc Directory pointant vers la racine de notre document. Ajoutez le bloc de texte suivant dans le bloc VirtualHost de votre fichier de configuration, en veillant à utiliser le bon répertoire web root :

      /etc/apache2/sites-available/wordpress.conf

      <Directory /var/www/wordpress/>
          AllowOverride All
      </Directory>
      

      Lorsque vous avez terminé, enregistrez et fermez le fichier. Dans nano, vous pouvez le faire en appuyant sur CTRL et X ensemble, puis Y, puis ENTER.

      Activer le module de réécriture

      Ensuite, nous pouvons activer mod_rewrite afin de pouvoir utiliser la fonction de permalien de WordPress :

      Cela vous permet d’avoir des permaliens plus lisibles à l’oeil humain pour vos messages, comme les deux exemples suivants :

      http://example.com/2012/post-name/
      http://example.com/2012/12/30/post-name
      

      La commande a2enmod appelle un script qui active le module spécifié dans la configuration d’Apache.

      Activer les modifications

      Avant de mettre en œuvre les modifications que nous avons apportées, vérifiez que nous n’avons pas fait d’erreurs de syntaxe en effectuant le test suivant.

      • sudo apache2ctl configtest

      Vous pouvez recevoir des résultats comme ceux qui suivent :

      Output

      AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message Syntax OK

      Si vous souhaitez supprimer la première ligne, ajoutez simplement une directive ServerName à votre fichier de configuration principal (global) d’Apache à l’emplacement /etc/apache2/apache2.conf. Le ServerName peut être le domaine ou l’adresse IP de votre serveur. Il s’agit toutefois d’un simple message qui n’affecte pas la fonctionnalité de votre site. Tant que la sortie contient Syntax OK, vous êtes prêt à continuer.

      Redémarrez Apache pour mettre en œuvre les changements. Veillez à redémarrer maintenant même si vous avez redémarré plus tôt dans ce tutoriel.

      • sudo systemctl restart apache2

      Nous allons ensuite télécharger et mettre en place WordPress lui-même.

      Étape 4 – Téléchargement de WordPress

      Maintenant que le logiciel de notre serveur est configuré, nous pouvons télécharger et installer WordPress. Pour des raisons de sécurité notamment, il est toujours recommandé de se procurer la dernière version de WordPress sur leur site.

      Passez dans un répertoire inscriptible (nous recommandons un répertoire temporaire comme /tmp) et téléchargez la version compressée.

      • cd /tmp
      • curl -O https://wordpress.org/latest.tar.gz

      Extrayez le fichier compressé pour créer la structure de répertoire de WordPress :

      Nous allons déplacer ces fichiers à la racine de notre document dans un instant. Avant cela, nous pouvons ajouter un fichier .htaccess factice afin qu’il soit disponible pour une utilisation ultérieure par WordPress.

      Créez le fichier en tapant :

      • touch /tmp/wordpress/.htaccess

      Nous allons également copier l’exemple du fichier de configuration vers le nom de fichier que WordPress lit :

      • cp /tmp/wordpress/wp-config-sample.php /tmp/wordpress/wp-config.php

      Nous pouvons également créer le répertoire des upgrade, afin que WordPress ne rencontre pas de problèmes de permissions lorsqu’il essaie de le faire seul après une mise à jour de son logiciel :

      • mkdir /tmp/wordpress/wp-content/upgrade

      Nous pouvons maintenant copier l’intégralité du contenu du répertoire à la racine de notre document. Nous ajoutons un point à la fin de notre répertoire source pour indiquer que tout ce qui se trouve dans le répertoire doit être copié, y compris les fichiers cachés (tels que le fichier .htaccess que nous avons créé) :

      • sudo cp -a /tmp/wordpress/. /var/www/wordpress

      Veillez à remplacer le /var/www/wordpress avec le répertoire que vous avez configuré sur votre serveur. 

      Étape 5 – Configurer le répertoire WordPress

      Avant de procéder à la configuration Web de WordPress, nous devons ajuster certains éléments de notre répertoire WordPress.

      Ajuster la propriété et les autorisations

      Une étape importante que nous devons accomplir consiste à établir des autorisations et des droits de propriété raisonnables sur les fichiers.

      Nous commencerons par donner la propriété de tous les fichiers à www-data user et group. C’est l’utilisateur sous lequel le serveur web Apache fonctionne, et Apache devra être capable de lire et d’écrire des fichiers WordPress afin de servir le site web et d’effectuer des mises à jour automatiques.

      Mettez à jour la propriété avec la commande chown qui vous permet de modifier la propriété du fichier. Veillez à pointer vers le répertoire pertinent de votre serveur.

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

      Ensuite, nous allons en faire deux find pour définir les autorisations correctes sur les répertoires et les fichiers WordPress :

      • sudo find /var/www/wordpress/ -type d -exec chmod 750 {} ;
      • sudo find /var/www/wordpress/ -type f -exec chmod 640 {} ;

      Ces autorisations devraient vous permettre de travailler efficacement avec WordPress, mais notez que certains plugins et procédures peuvent nécessiter des ajustements supplémentaires.

      Modifier le fichier de configuration WordPress

      Maintenant, nous devons apporter quelques modifications au fichier de configuration principal de WordPress.

      Lorsque nous ouvrirons le fichier, notre première tâche sera d’ajuster certaines clés secrètes afin d’assurer un niveau de sécurité pour notre installation. WordPress fournit un générateur sécurisé pour ces valeurs, afin que vous n’ayez pas à essayer de trouver de bonnes valeurs par vous-même. Elles ne sont utilisées qu’en interne, de sorte qu’il ne sera pas préjudiciable à la facilité d’utilisation d’avoir des valeurs complexes et sûres ici.

      Pour récupérer des valeurs sécurisées du générateur de clés secrètes de WordPress, tapez :

      • curl -s https://api.wordpress.org/secret-key/1.1/salt/

      Vous obtiendrez des valeurs uniques qui ressemblent à des sorties similaires à celles du bloc ci-dessous.

      Attention ! Il est important que vous demandiez des valeurs uniques à chaque fois. Ne copiez PAS les valeurs ci-dessous !

      Output

      define('AUTH_KEY', '1jl/vqfs<XhdXoAPz9 DO NOT COPY THESE VALUES c_j{iwqD^<+c9.k<J@4H'); define('SECURE_AUTH_KEY', 'E2N-h2]Dcvp+aS/p7X DO NOT COPY THESE VALUES {Ka(f;rv?Pxf})CgLi-3'); define('LOGGED_IN_KEY', 'W(50,{W^,OPB%PB<JF DO NOT COPY THESE VALUES 2;y&,2m%3]R6DUth[;88'); define('NONCE_KEY', 'll,4UC)7ua+8<!4VM+ DO NOT COPY THESE VALUES #`DXF+[$atzM7 o^-C7g'); define('AUTH_SALT', 'koMrurzOA+|L_lG}kf DO NOT COPY THESE VALUES 07VC*Lj*lD&?3w!BT#-'); define('SECURE_AUTH_SALT', 'p32*p,]z%LZ+pAu:VY DO NOT COPY THESE VALUES C-?y+K0DK_+F|0h{!_xY'); define('LOGGED_IN_SALT', 'i^/G2W7!-1H2OQ+t$3 DO NOT COPY THESE VALUES t6**bRVFSD[Hi])-qS`|'); define('NONCE_SALT', 'Q6]U:K?j4L%Z]}h^q7 DO NOT COPY THESE VALUES 1% ^qUswWgn+6&xqHN&%');

      Il s’agit de lignes de configuration que nous pouvons coller directement dans notre fichier de configuration pour définir des clés sécurisées. Copiez la sortie que vous venez d’obtenir.

      Ensuite, ouvrez le fichier de configuration de WordPress :

      • sudo nano /var/www/wordpress/wp-config.php

      Trouvez la section qui contient les exemples de valeurs pour ces paramètres.

      /var/www/wordpress/wp-config.php

      . . .
      
      define('AUTH_KEY',         'put your unique phrase here');
      define('SECURE_AUTH_KEY',  'put your unique phrase here');
      define('LOGGED_IN_KEY',    'put your unique phrase here');
      define('NONCE_KEY',        'put your unique phrase here');
      define('AUTH_SALT',        'put your unique phrase here');
      define('SECURE_AUTH_SALT', 'put your unique phrase here');
      define('LOGGED_IN_SALT',   'put your unique phrase here');
      define('NONCE_SALT',       'put your unique phrase here');
      
      . . .
      

      Supprimez ces lignes et collez les valeurs que vous avez copiées depuis la ligne de commande :

      /var/www/wordpress/wp-config.php

      . . .
      
      define('AUTH_KEY',         'VALUES COPIED FROM THE COMMAND LINE');
      define('SECURE_AUTH_KEY',  'VALUES COPIED FROM THE COMMAND LINE');
      define('LOGGED_IN_KEY',    'VALUES COPIED FROM THE COMMAND LINE');
      define('NONCE_KEY',        'VALUES COPIED FROM THE COMMAND LINE');
      define('AUTH_SALT',        'VALUES COPIED FROM THE COMMAND LINE');
      define('SECURE_AUTH_SALT', 'VALUES COPIED FROM THE COMMAND LINE');
      define('LOGGED_IN_SALT',   'VALUES COPIED FROM THE COMMAND LINE');
      define('NONCE_SALT',       'VALUES COPIED FROM THE COMMAND LINE');
      
      . . .
      

      Ensuite, nous allons modifier certains des paramètres de connexion à la base de données au début du fichier. Vous devez ajuster le nom de la base de données, l’utilisateur de la base de données et le mot de passe associé que vous avez configuré dans MySQL.

      L’autre modification que nous devons apporter est de définir la méthode que WordPress doit utiliser pour écrire dans le système de fichiers. Comme nous avons donné au serveur web la permission d’écrire là où il faut, nous pouvons explicitement définir la méthode du système de fichiers sur « direct ». Si nous ne configurons pas la méthode avec nos paramètres actuels, WordPress demandera les informations d’identification FTP lorsque nous effectuerons certaines actions.

      Ce paramètre peut être ajouté sous les paramètres de connexion à la base de données ou n’importe où ailleurs dans le fichier :

      /var/www/wordpress/wp-config.php

      . . .
      
      // ** MySQL settings - You can get this info from your web host ** //
      /** The name of the database for WordPress */
      define( 'DB_NAME', 'wordpress' );
      
      /** MySQL database username */
      define( 'DB_USER', 'wordpressuser' );
      
      /** MySQL database password */
      define( 'DB_PASSWORD', 'password' );
      
      /** MySQL hostname */
      define( 'DB_HOST', 'localhost' );
      
      /** Database Charset to use in creating database tables. */
      define( 'DB_CHARSET', 'utf8' );
      
      /** The Database Collate type. Don't change this if in doubt. */
      define( 'DB_COLLATE', '' );
      
      
      . . .
      
      define('FS_METHOD', 'direct');
      

      Enregistrez et fermez le fichier lorsque vous avez terminé.

      Étape 6 — Finalisation de l’installation via l’interface Web

      Maintenant que la configuration du serveur est terminée, nous pouvons finaliser l’installation via l’interface Web.

      Dans votre navigateur web, naviguez vers le nom de domaine ou l’adresse IP publique de votre serveur :

      https://server_domain_or_IP
      

      Sélectionnez la langue que vous souhaitez utiliser :

      WordPress language selection

      Ensuite, vous arriverez à la page de configuration principale.

      Choisissez un nom pour votre site WordPress et choisissez un nom d’utilisateur. Il est recommandé de choisir quelque chose d’unique et d’éviter les noms d’utilisateur courants comme « admin » pour des raisons de sécurité. Un mot de passe fort est généré automatiquement. Enregistrez ce mot de passe ou choisissez un autre mot de passe fort.

      Entrez votre adresse e-mail et choisissez si vous voulez demander aux moteurs de recherche de ne pas indexer votre site :

      WordPress setup installation

      Lorsque vous cliquez, vous accédez à une page qui vous invite à vous connecter :

      WordPress login prompt

      Une fois connecté, vous serez redirigé vers le tableau de bord d’administration de WordPress :

      WordPress login prompt

      A ce stade, vous pouvez commencer à concevoir votre site WordPress ! Si c’est la première fois que vous utilisez WordPress, explorez un peu l’interface pour vous familiariser avec votre nouveau CMS.

      Conclusion

      Félicitations, WordPress est maintenant installé et prêt à être utilisé !

      À ce stade, vous voudrez peut-être commencer à faire ce qui suit :

      • Choisissez vos paramètres de permaliens pour les messages WordPress, qui se trouvent dans Settings > Permalinks.
      • Sélectionnez un nouveau thème dans Appearance > Themes. 
      • Installez de nouveaux plugins pour augmenter les fonctionnalités de votre site sous Plugins > Add New. 
      • Si vous comptez collaborer avec d’autres personnes, vous pouvez également ajouter des utilisateurs supplémentaires à ce moment sous Users > Add New. 

      Vous pouvez trouver des ressources supplémentaires pour d’autres façons d’installer WordPress, apprendre comment installer WordPress sur différentes distributions de serveurs, automatiser vos installations WordPress, et faire évoluer vos sites WordPress en consultant notre balise communautaire WordPress. 



      Source link

      Comment installer et configurer Laravel avec Docker Compose sur Ubuntu 20.04


      Introduction

      Conteneuriser une application fait référence au processus d’adaptation d’une application et de ses composants afin de pouvoir l’exécuter dans des environnements légers appelés conteneurs. Ces environnements sont isolés et remplaçables et peuvent être exploités pour développer, tester et déployer des apps en production.

      Dans ce guide, nous utiliserons Docker Compose pour conteneuriser une application Laravel pour le développement. Lorsque vous aurez terminé, vous aurez une application Laravel de démonstration fonctionnant sur trois conteneurs de service distincts :

      • Un service app fonctionnant sous PHP7.4-FPM ;
      • Un service db fonctionnant sous MySQL 5.7 ;
      • Un service nginx qui utilise le service app pour analyser le code PHP avant de servir l’application Laravel à l’utilisateur final.

      Pour permettre un processus de développement simplifié et faciliter le débogage des apps, nous maintiendrons la synchronisation des fichiers d’application en utilisant des volumes partagés. Nous verrons également comment utiliser les commandes docker-compose exec pour exécuter Composer et Artisan sur le conteneur de l’application.

      Conditions préalables

      Étape 1 – Obtenez l’application de démonstration

      Pour commencer, nous irons chercher l’application de démonstration Laravel dans son répertoire Github. Nous sommes intéressés par la branche tutorial-01, qui contient l’application Laravel de base que nous avons créée dans le premier guide de cette série.

      Pour obtenir le code d’application compatible avec ce tutoriel, téléchargez la version tutorial-1.0.1 dans votre répertoire de base avec :

      • cd ~
      • curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

      Nous aurons besoin de la commande unzip pour décompresser le code d’application. Si vous n’avez pas encore installé ce package, faites-le maintenant avec :

      • sudo apt update
      • sudo apt install unzip

      Maintenant, décompressez le contenu de l’application et renommez le répertoire décompressé pour un accès plus facile :

      • unzip travellist.zip
      • mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

      Naviguez vers le répertoire travellist-demo :

      Au cours de la prochaine étape, nous allons créer un fichier de configuration .env pour configurer l’application.

      Étape 2 – Configurez le fichier .env de l’application

      Les fichiers de configuration Laravel sont situés dans un répertoire appelé config, dans le répertoire root de l’application. En outre, un fichier .env est utilisé pour configurer environment-dependent configuration, telles que les références et toute information pouvant varier d’un déploiement à l’autre. Ce fichier n’est pas inclus dans la gestion de versions.

      Attention : le fichier de configuration de l’environnement contient des informations sensibles sur votre serveur, notamment les informations d’identification de la base de données et les clés de sécurité. Par conséquent, ne partagez jamais ce fichier en public.

      Les valeurs contenues dans le fichier .env auront la priorité sur les valeurs fixées dans les fichiers de configuration habituels situés dans le répertoire config. Chaque installation sur un nouvel environnement nécessite un fichier d’environnement personnalisé pour définir des éléments tels que les paramètres de connexion à la base de données, les options de débogage, l’URL de l’application, entre autres, qui peuvent varier en fonction de l’environnement dans lequel l’application est exécutée.

      Nous allons maintenant créer un nouveau fichier .env afin de personnaliser les options de configuration pour l’environnement de développement que nous configurons. Laravel contient un exemple de fichier .env que nous pouvons copier pour créer le nôtre :

      Ouvrez ce fichier en utilisant nano ou votre éditeur de texte préféré :

      Le fichier .env provenant de l’application de démonstration travellist contient des paramètres pour utiliser une base de données MySQL locale, avec 127.0.0.1 comme hôte de base de données. Nous devons mettre à jour la variable DB_HOST afin qu’il pointe vers le service de base de données que nous allons créer dans notre environnement Docker. Dans ce guide, nous appellerons notre service de base de données db. Commencez et remplacez la valeur listée de DB_HOST par le nom du service de base de données :

      .env

      APP_NAME=Travellist
      APP_ENV=dev
      APP_KEY=
      APP_DEBUG=true
      APP_URL=http://localhost:8000
      
      LOG_CHANNEL=stack
      
      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=travellist
      DB_USERNAME=travellist_user
      DB_PASSWORD=password
      ...
      

      N’hésitez pas à modifier également le nom de la base de données, le nom d’utilisateur et le mot de passe, si vous le souhaitez. Ces variables seront exploitées lors d’une étape ultérieure où nous mettrons en place le fichier docker-compose.yml pour configurer nos services.

      Enregistrez le fichier lorsque vous avez fini de le modifier. Si vous avez utilisé nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

      Étape 3 – Configurez le Dockerfile de l’application

      Bien que nos services MySQL et Nginx seront basés sur des images par défaut obtenues à partir de Docker Hub, nous devons encore construire une image personnalisée pour le conteneur de l’application. Bien que nos services MySQL et Nginx soient basés sur des images par défaut obtenues à partir de Docker Hub, nous devons malgré tout construire une image personnalisée pour le conteneur de l’application.

      Notre image travellist sera basée sur l’image PHP officielle php:7.4-fpm de Docker Hub. En plus de cet environnement PHP-FPM de base, nous allons installer quelques modules PHP supplémentaires et l’outil de gestion des dépendances Composer.

      Nous allons également créer un nouvel utilisateur système ; c’est nécessaire pour exécuter les commandes artisan et composer lors du développement de l’application. Le paramètre uid garantit que l’utilisateur à l’intérieur du conteneur a le même uid que l’utilisateur de votre système sur votre machine hôte, où vous exécutez Docker. Ainsi, tous les fichiers créés par ces commandes sont répliqués dans l’hôte avec les bonnes permissions. Cela signifie également que vous pourrez utiliser l’éditeur de code de votre choix dans la machine hôte pour développer l’application qui s’exécute dans les conteneurs.

      Créez un nouveau Dockerfile avec :

      Copiez le contenu suivant dans votre Dockerfile :

      Dockerfile

      FROM php:7.4-fpm
      
      # Arguments defined in docker-compose.yml
      ARG user
      ARG uid
      
      # Install system dependencies
      RUN apt-get update && apt-get install -y 
          git 
          curl 
          libpng-dev 
          libonig-dev 
          libxml2-dev 
          zip 
          unzip
      
      # Clear cache
      RUN apt-get clean && rm -rf /var/lib/apt/lists/*
      
      # Install PHP extensions
      RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
      
      # Get latest Composer
      COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
      
      # Create system user to run Composer and Artisan Commands
      RUN useradd -G www-data,root -u $uid -d /home/$user $user
      RUN mkdir -p /home/$user/.composer && 
          chown -R $user:$user /home/$user
      
      # Set working directory
      WORKDIR /var/www
      
      USER $user
      
      

      N’oubliez pas d’enregistrer le fichier lorsque vous avez terminé.

      Notre Dockerfile commence par définir l’image de base que nous utilisons : php:7.4-fpm.

      Après avoir installé les packages système et les extensions PHP, nous installons Composer en copiant le fichier exécutable composer depuis sa dernière image officielle vers notre propre image d’application.

      Un nouvel utilisateur système est alors créé et configuré en utilisant les arguments user et uid qui ont été déclarés au début du Dockerfile. Ces valeurs seront injectées par Docker Compose au moment de la construction.

      Enfin, nous avons défini le répertoire de travail par défaut comme /var/www et changé pour l’utilisateur nouvellement créé. Cela vous permettra de vous connecter comme un utilisateur régulier et de vous assurer que vous êtes dans le bon répertoire lorsque vous exécutez les commandes composer et artisan sur le conteneur de l’application.

      Étape 4 – Implémentez la configuration Nginx et les fichiers Dump de la base de données

      Lors de la création d’environnements de développement avec Docker Compose, il est souvent nécessaire de partager des fichiers de configuration ou d’initialisation avec des conteneurs de services, afin de mettre en place ou de démarrer ces services. Cette pratique facilite la modification des fichiers de configuration pour affiner votre environnement pendant que vous développez l’application.

      Nous allons maintenant créer un dossier avec des fichiers qui serviront à configurer et à initialiser nos conteneurs de services.

      Pour configurer Nginx, nous allons partager un fichier travellist.conf qui configurera la façon dont l’application est servie. Créez le dossier docker-compose/nginx avec :

      • mkdir -p docker-compose/nginx

      Ouvrez un nouveau fichier appelé travellist.conf dans ce répertoire :

      • nano docker-compose/nginx/travellist.conf

      Copiez la configuration Nginx suivante dans ce fichier :

      docker-compose/nginx/travellist.conf

      
      server {
          listen 80;
          index index.php index.html;
          error_log  /var/log/nginx/error.log;
          access_log /var/log/nginx/access.log;
          root /var/www/public;
          location ~ .php$ {
              try_files $uri =404;
              fastcgi_split_path_info ^(.+.php)(/.+)$;
              fastcgi_pass app:9000;
              fastcgi_index index.php;
              include fastcgi_params;
              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
              fastcgi_param PATH_INFO $fastcgi_path_info;
          }
          location / {
              try_files $uri $uri/ /index.php?$query_string;
              gzip_static on;
          }
      }
      

      Ce fichier configurera Nginx pour écouter sur le port 80 et utilisera index.php comme page d’index par défaut. Il définira le document root comme /var/www/public, et configurera ensuite Nginx pour utiliser le service de l’application sur le port 9000 pour traiter les fichiers *.php.

      Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

      Pour mettre en place la base de données MySQL, nous allons partager un dump de base de données qui sera importé lors de l’initialisation du conteneur. C’est une fonctionnalité fournie par l’image MySQL 5.7 que nous utiliserons sur ce conteneur.

      Créez un nouveau dossier pour vos fichiers d’initialisation MySQL dans le dossier docker-compose :

      • mkdir docker-compose/mysql

      Ouvrez un nouveau fichier .sql :

      • nano docker-compose/mysql/init_db.sql

      La sauvegarde Dump MySQL suivante est basée sur la base de données que nous avons mise en place dans notre guide Laravel sur LEMP. Elle créera un nouveau tableau appelé places. Ensuite, elle remplira le tableau avec un ensemble de lieux d’échantillonnage.

      Ajoutez le code suivant au fichier :

      docker-compose/mysql/db_init.sql

      DROP TABLE IF EXISTS `places`;
      
      CREATE TABLE `places` (
        `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
        `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
        `visited` tinyint(1) NOT NULL DEFAULT '0',
        PRIMARY KEY (`id`)
      ) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
      
      INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);
      

      La table places contient trois champs : id, name, et visited. Le champ visited est un drapeau utilisé pour identifier les lieux qui doivent encore être visités. N’hésitez pas à modifier les échantillons de lieux ou à en inclure de nouveaux. Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

      Nous avons fini de mettre en place le Dockerfile de l’application et les fichiers de configuration du service. Ensuite, nous allons mettre en place Docker Compose pour utiliser ces fichiers lors de la création de nos services.

      Étape 5 – Créez un environnement multi-conteneurs avec Docker Compose

      Docker Compose permet de créer des environnements multi-conteneurs pour les apps s’exécutant sur Docker. Il utilise les définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs qui peuvent échanger des réseaux et des volumes de données. Cela permet une intégration harmonieuse entre les composants de l’application.

      Pour configurer nos définitions de service, nous créerons un nouveau fichier appelé docker-compose.yml. Généralement, ce fichier est situé à la racine du dossier d’application et définit votre environnement conteneurisé, y compris les images de base que vous utiliserez pour construire vos conteneurs et la manière dont vos services interagiront.

      Nous définirons trois services différents dans notre fichiers docker-compose.yml : application, db et nginx.

      Le service application construira une image appelée travellist basée sur le Dockerfile que nous avons précédemment créé. Le conteneur défini par ce service exécutera un serveur php-fpm pour analyser le code PHP et renvoyer les résultats au service nginx, qui fonctionnera sur un conteneur séparé. Le service mysql définit un conteneur exécutant un serveur MySQL 5.7. Nos services partageront un pont de réseau appelé travellist.

      Les fichiers de l'application seront synchronisés à la fois sur l’application et sur le service nginx via bind mounts. Les bind mounts sont utiles dans les environnements de développement car ils permettent une synchronisation bidirectionnelle performante entre la machine hôte et les conteneurs.

      Créez un nouveau fichier docker-compose.yml à la racine du dossier de l’application :

      Un fichier docker-compose.yml classique débute par une définition de la version, suivie par un noeud de services qui définit l’ensemble des services. Les réseaux partagés sont généralement définis au bas de ce fichier.

      Pour commencer, copiez ce code standard dans votre fichier docker-compose.yml :

      docker-compose.yml

      version: "3.7"
      services:
      
      
      networks:
        travellist:
          driver: bridge
      

      Nous allons maintenant modifier le nœud de services pour inclure les services application, db et nginx.

      Le service application

      Le service application configurera un conteneur nommé travellist-application. Il construira une nouvelle image Docker basée sur un Dockerfile situé sur le même itinéraire que le fichier docker-compose.yml. La nouvelles image sera enregistrée localement sous le nom de travellist.

      Même si la racine du document qui sert d’application est située dans le conteneur nginx, nous avons également besoin des fichiers de l’application quelque part dans le conteneur application afin d’exécuter des tâches en ligne de commande avec l’outil Laravel Artisan.

      Copiez la définition de service suivante sous votre noeud de services, à l’intérieur du fichier docker-compose.yml :

      docker-compose.yml

        app:
          build:
            args:
              user: sammy
              uid: 1000
            context: ./
            dockerfile: Dockerfile
          image: travellist
          container_name: travellist-app
          restart: unless-stopped
          working_dir: /var/www/
          volumes:
            - ./:/var/www
          networks:
            - travellist
      

      Ces paramètres sont les suivants :

      • build : cette configuration indique à Docker Compose de construire une image locale pour le service application, en utilisant le chemin spécifié (contexte) et Dockerfile pour les instructions. Les arguments user et uid sont injectés dans le Dockerfile pour personnaliser les commandes de création utilisateurs lors de la construction.
      • image : le nom qui sera utilisé pour l’image en cours de construction.
      • container_name : définit le nom du conteneur pour ce service.
      • restart :indique qu’il faut toujours redémarrer, sauf si le service est arrêté.
      • working_dir : définit le répertoire par défaut pour ce service comme /var/www.
      • volumes : crée un volume partagé qui synchronisera le contenu du répertoire actuel avec /var/www dans le conteneur. Notez qu’il ne s’agit pas de la racine de votre document, puisqu’elle se trouve dans le conteneur nginx.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Le service db

      Le service db utilise une image MySQL 5.7 préalablement construite depuis Docker Hub. Étant donné que Docker Compose charge automatiquement les fichiers variables .env situés dans le même répertoire que le fichier docker-compose.yml, nous pouvons obtenir nos paramètres de base de données depuis le fichier Laravel .env que nous avons créé dans une étape précédente.

      Incluez la définition de service suivante dans votre noeud de services, juste après le service application :

      docker-compose.yml

        db:
          image: mysql:5.7
          container_name: travellist-db
          restart: unless-stopped
          environment:
            MYSQL_DATABASE: ${DB_DATABASE}
            MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
            MYSQL_PASSWORD: ${DB_PASSWORD}
            MYSQL_USER: ${DB_USERNAME}
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          volumes:
            - ./docker-compose/mysql:/docker-entrypoint-initdb.d
          networks:
            - travellist
      

      Ces paramètres sont les suivants :

      • image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image MySQL 5.7 de Docker Hub.
      • container_name : définit le nom du conteneur pour ce service : travellist-db.
      • restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
      • environment : définit les variables d’environnement dans le nouveau conteneur. Nous utilisons des valeurs obtenues par le fichier Laravel .env pour configurer notre service MySQL, qui créera automatiquement une nouvelle base de données et un nouvel utilisateur en fonction des variables d’environnement fournies.
      • volumes : crée un volume pour partager un dump de base de données .sql qui sera utilisé pour initialiser la base de données de l’application. L’image MySQL importera automatiquement les fichiers .sql placés dans le répertoire /docker-entrypoint-initdb.d dans le conteneur.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Le service nginx

      Le service nginx utilise une image Nginx pré-construite sur Alpine, une distribution Linux légère. Il crée un conteneur nommé travellist-nginx et utilise la définition des ports pour créer une redirection depuis le port 8000 sur le système hôte jusqu’au port 80 dans le conteneur.

      Incluez la définition de service suivante dans votre noeud de services, juste après le service db :

      docker-compose.yml

        nginx:
          image: nginx:1.17-alpine
          container_name: travellist-nginx
          restart: unless-stopped
          ports:
            - 8000:80
          volumes:
            - ./:/var/www
            - ./docker-compose/nginx:/etc/nginx/conf.d
          networks:
            - travellist
      

      Ces paramètres sont les suivants :

      • image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image Alpine Nginx 1.17.
      • container_name : définit le nom du conteneur pour ce service : travellist-nginx.
      • restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
      • ports : configure une redirection des ports qui permettra un accès externe via le port 8000 au serveur web fonctionnant sur le port 80 dans le conteneur.
      • volumes : crée deux volumes partagés. Le premier synchronisera le contenu du répertoire actuel avec /var/www à l’intérieur du conteneur. Ainsi, lorsque vous apportez des modifications locales aux fichiers d’application, elles seront rapidement répercutées dans la demande servie par Nginx à l’intérieur du conteneur. Le deuxième volume s’assurera que notre fichier de configuration Nginx, situé à l'adresse docker-compose/nginx/travellist.conf, est copié dans le dossier de configuration Nginx du conteneur.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Fichier docker-compose.yml terminé

      Notre fichier docker-compose.yml terminé ressemble à ça :

      docker-compose.yml

      version: "3.7"
      services:
        app:
          build:
            args:
              user: sammy
              uid: 1000
            context: ./
            dockerfile: Dockerfile
          image: travellist
          container_name: travellist-app
          restart: unless-stopped
          working_dir: /var/www/
          volumes:
            - ./:/var/www
          networks:
            - travellist
      
        db:
          image: mysql:5.7
          container_name: travellist-db
          restart: unless-stopped
          environment:
            MYSQL_DATABASE: ${DB_DATABASE}
            MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
            MYSQL_PASSWORD: ${DB_PASSWORD}
            MYSQL_USER: ${DB_USERNAME}
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          volumes:
            - ./docker-compose/mysql:/docker-entrypoint-initdb.d
          networks:
            - travellist
      
        nginx:
          image: nginx:alpine
          container_name: travellist-nginx
          restart: unless-stopped
          ports:
            - 8000:80
          volumes:
            - ./:/var/www
            - ./docker-compose/nginx:/etc/nginx/conf.d/
          networks:
            - travellist
      
      networks:
        travellist:
          driver: bridge
      

      Assurez-vous d’enregistrer le fichier lorsque vous avez terminé.

      Étape 6 – Exécutez l’application avec Docker Compose

      Nous allons maintenant utiliser les commandes docker-compose pour construire l’image de l’application et exécuter les services que nous avons spécifiés dans notre configuration.

      Construisez l’image de l'application avec la commande suivante :

      Cette commande peut prendre quelques minutes. Vous verrez une sortie similaire à celle-ci :

      Output

      Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

      Lorsque la construction est terminée, vous pouvez exécuter l’environnement en mode arrière-plan avec :

      Output

      Creating travellist-db ... done Creating travellist-app ... done Creating travellist-nginx ... done

      Cela fera tourner vos conteneurs en arrière-plan. Pour afficher des informations sur l’état de vos services actifs, exécutez :

      Vous verrez une sortie de ce type :

      Output

      Name Command State Ports -------------------------------------------------------------------------------- travellist-app docker-php-entrypoint php-fpm Up 9000/tcp travellist-db docker-entrypoint.sh mysqld Up 3306/tcp, 33060/tcp travellist-nginx /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Votre environnement est maintenant opérationnel, mais nous devons encore exécuter quelques commandes pour terminer la configuration de l’application. Vous pouvez utiliser la commande docker-compose exec pour exécuter les commandes dans les conteneurs de services, tels qu’un ls -l pour afficher les informations détaillées sur les fichiers dans le répertoire de l’application :

      • docker-compose exec app ls -l

      Output

      total 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 538 Jan 7 08:05 webpack.mix.js

      Nous allons maintenant exécuter composer install pour installer les dépendances de l’application :

      • docker-compose exec app composer install

      Vous verrez une sortie de ce type :

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … Generating optimized autoload files > IlluminateFoundationComposerScripts::postAutoloadDump > @php artisan package:discover --ansi Discovered Package: facade/ignition Discovered Package: fideloper/proxy Discovered Package: laravel/tinker Discovered Package: nesbot/carbon Discovered Package: nunomaduro/collision Package manifest generated successfully.

      La dernière chose que nous devons faire avant de tester l’application est de générer une clé d’application unique avec l’outil de ligne de commande Laravel, artisan. Cette clé est utilisée pour chiffrer les sessions des utilisateurs et d’autres données sensibles :

      • docker-compose exec app php artisan key:generate

      Output

      Application key set successfully.

      Ouvrez maintenant votre navigateur et accédez au nom de domaine ou à l’adresse IP de votre serveur sur le port 8000 :

      http://server_domain_or_IP:8000
      

      Note : Si vous exécutez cette démo sur votre machine locale, utilisez http://localhost:8000 pour accéder à l’application à partir de votre navigateur.

      Vous verrez une page comme celle-ci :

      application de démonstration Laravel

      Vous pouvez utiliser la commande logs pour consultez les journaux générés par vos services :

      • docker-compose logs nginx
      Attaching to travellist-nginx
      …
      travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
      travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      

      Si vous voulez mettre en pause votre environnement Docker Compose tout en conservant l’état de tous ses services, exécutez :

      Output

      Pausing travellist-db ... done Pausing travellist-nginx ... done Pausing travellist-app ... done

      Vous pouvez alors reprendre vos services avec :

      Output

      Unpausing travellist-app ... done Unpausing travellist-nginx ... done Unpausing travellist-db ... done

      Pour fermer votre environnement Docker Compose et retirer tous ses conteneurs, réseaux et volumes, exécutez :

      Output

      Stopping travellist-nginx ... done Stopping travellist-db ... done Stopping travellist-app ... done Removing travellist-nginx ... done Removing travellist-db ... done Removing travellist-app ... done Removing network travellist-laravel-demo_travellist

      Pour un aperçu de toutes les commandes Docker Compose, veuillez consulter la référence de la ligne de commande Docker Compose.

      Conclusion

      Dans ce guide, nous avons mis en place un environnement Docker avec trois conteneurs en utilisant Docker Compose pour définir notre infrastructure dans un fichier YAML.

      À partir de ce moment, vous pouvez travailler sur votre application Laravel sans avoir besoin d’installer et de configurer un serveur web local pour le développement et les tests. De plus, vous travaillerez avec un environnement jetable qui peut être facilement reproduit et distribué, ce qui peut être utile lors du développement de votre application et aussi lors de la transition vers un environnement de production.



      Source link

      Comment sécuriser Nginx avec Let’s Encrypt sur Ubuntu 20.04


      Introduction

      Let’s Encrypt est une autorité de certification (CA) qui fournit un moyen facile d’obtenir et d’installer des certificats TLS/SSL gratuits, permettant ainsi le cryptage HTTPS sur les serveurs web. Il simplifie le processus en fournissant un logiciel client, Certbot, qui tente d’automatiser la plupart (sinon la totalité) des étapes requises. Actuellement, l’ensemble du processus d’obtention et d’installation d’un certificat est entièrement automatisé sur Apache et Nginx.

      Dans ce tutoriel, vous allez utiliser Certbot pour obtenir un certificat SSL gratuit pour Nginx sur Ubuntu 20.04 et configurer votre certificat pour qu’il se renouvelle automatiquement.

      Ce tutoriel utilisera un fichier de configuration de serveur Nginx séparé au lieu du fichier par défaut. Nous recommandons de créer de nouveaux fichiers de blocage de serveur Nginx pour chaque domaine, car cela permet d’éviter les erreurs courantes et de conserver les fichiers par défaut comme configuration de repli.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin de :

      • Un serveur Ubuntu 20.04 configuré en suivant ce tutoriel de configuration initiale du serveur pour Ubuntu 20.04, comprenant un utilisateur sudo non root et un pare-feu.

      • Un nom de domaine enregistré. Ce tutoriel utilisera example.com tout du long. Vous pouvez acheter un nom de domaine sur Namecheap, en obtenir un gratuitement avec Freenom, ou utiliser le bureau d’enregistrement de domaine de votre choix.

      • Les deux enregistrements DNS suivants ont été configurés pour votre serveur. Si vous utilisez DigitalOcean, veuillez consulter notre documentation DNS pour plus de détails sur la façon de les ajouter.

        • Un enregistrement A avec example.com​​​ pointant sur l’adresse IP publique de votre serveur.
        • Un enregistrement A avec www.example.com​​​ pointant sur l’adresse IP publique de votre serveur.
      • Nginx installé en suivant le guide Comment installer Nginx sur Ubuntu 20.04. Assurez-vous que vous disposez d’un bloc serveur pour votre domaine. Ce tutoriel utilisera /etc/nginx/sites-available/example.com à titre d’exemple.

      Étape 1 — Installation de Certbot

      La première étape de l’utilisation de Let’s Encrypt pour obtenir un certificat SSL consiste à installer le logiciel Certbot sur votre serveur.

      Installez Certbot et son plugin Nginx avec apt :

      • sudo apt install certbot python3-certbot-nginx

      Certbot est maintenant prêt à l’emploi, mais pour qu’il configure automatiquement le SSL pour Nginx, nous devons vérifier une partie de la configuration de Nginx.

      Étape 2 — Confirmation de la configuration de Nginx

      Certbot doit être capable de trouver le bon bloc serveur dans votre configuration Nginx pour pouvoir configurer automatiquement le SSL. Plus précisément, il recherche une directive server_name qui correspond au domaine pour lequel vous demandez un certificat.

      Si vous avez suivi l’étape de configuration du bloc serveur dans le tutoriel d’installation de Nginx, vous devriez avoir un bloc serveur pour votre domaine dans /etc/nginx/sites-available/example.com avec la directive server_name déjà définie de manière appropriée.

      Pour vérifier, ouvrez le fichier de configuration de votre domaine en utilisant nano ou votre éditeur de texte préféré :

      • sudo nano /etc/nginx/sites-available/example.com

      Recherchez la ligne server_name existante. Cela devrait ressembler à ceci :

      /etc/nginx/sites-available/example.com

      ...
      server_name example.com www.example.com;
      ...
      

      Si c’est le cas, quittez votre éditeur et passez à l’étape suivante.

      Si ce n’est pas le cas, mettez-le à jour pour qu’il corresponde. Ensuite, enregistrez le fichier, quittez votre éditeur et vérifiez la syntaxe de vos modifications de configuration :

      Si vous obtenez une erreur, rouvrez le fichier du bloc serveur et vérifiez s’il y a des fautes de frappe ou des caractères manquants. Une fois que la syntaxe de votre fichier de configuration est correcte, rechargez Nginx pour charger la nouvelle configuration :

      • sudo systemctl reload nginx

      Certbot peut maintenant trouver le bon bloc serveur et le mettre à jour automatiquement.

      Ensuite, mettons à jour le pare-feu pour autoriser le trafic HTTPS.

      Étape 3 — Autorisation du HTTPS à travers le pare-feu

      Si vous avez activé le pare-feu UFW, comme le recommandent les guides des conditions préalables, vous devrez ajuster les paramètres pour autoriser le trafic HTTPS. Heureusement, Nginx enregistre quelques profils avec ufw lors de l’installation.

      Vous pouvez voir les paramètres actuels en tapant :

      Il ressemblera probablement à ceci, ce qui signifie que seul le trafic HTTP est autorisé sur le serveur web :

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere Nginx HTTP ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) Nginx HTTP (v6) ALLOW Anywhere (v6)

      Pour laisser entrer en plus le trafic HTTPS, autorisez le profil Nginx Full et supprimez l’autorisation de profil HTTP Nginx redondant :

      • sudo ufw allow 'Nginx Full'
      • sudo ufw delete allow 'Nginx HTTP'

      Votre statut devrait désormais ressembler à ceci :

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere Nginx Full ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) Nginx Full (v6) ALLOW Anywhere (v6)

      Ensuite, exécutons Certbot et récupérons nos certificats.

      Étape 4 — Obtention d’un certificat SSL

      Certbot propose différents moyens d’obtenir des certificats SSL par le biais de plugins. Le plugin Nginx se chargera de reconfigurer Nginx et de recharger la configuration chaque fois que nécessaire. Pour utiliser ce plugin, tapez ce qui suit :

      • sudo certbot --nginx -d example.com -d www.example.com

      Cela exécute certbot avec le plugin --nginx, en utilisant -d pour spécifier les noms de domaine pour lesquels nous aimerions que le certificat soit valide.

      Si vous utilisez certbot pour la première fois, vous serez invité à saisir une adresse électronique et à accepter les conditions de service. Après avoir fait cela, certbot communiquera avec le serveur Let’s Encrypt, puis exécutera un défi pour vérifier que vous contrôlez le domaine pour lequel vous demandez un certificat.

      Si cela réussit, certbot demandera comment vous souhaitez configurer vos paramètres HTTPS.

      Output

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

      Faites votre choix, puis appuyez sur ENTER. La configuration sera mise à jour, et Nginx se rechargera pour récupérer les nouveaux paramètres. certbot terminera par un message vous indiquant que le processus a réussi et précisant l’emplacement de stockage de vos certificats :

      Output

      IMPORTANT NOTES: - Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/example.com/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/example.com/privkey.pem Your cert will expire on 2020-08-18. To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option. To non-interactively renew *all* of your certificates, run "certbot renew" - If you like Certbot, please consider supporting our work by: Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

      Vos certificats sont téléchargés, installés et chargés. Essayez de recharger votre site web en utilisant https:// et remarquez l’indicateur de sécurité de votre navigateur. Il devrait indiquer que le site est correctement sécurisé, généralement par une icône de cadenas. Si vous testez votre serveur en utilisant le SSL Labs Server Test​​​1​​​, il obtiendra la note A.

      Pour finir, testons le processus de renouvellement.

      Étape 5 — Verification du renouvellement automatique de Certbot

      Les certificats Let’s Encrypt ne sont valables que quatre-vingt-dix jours. Cette mesure vise à encourager les utilisateurs à automatiser le processus de renouvellement de leur certificat. Le paquet certbot que nous avons installé s’en charge pour nous en ajoutant une minuterie système qui s’exécute deux fois par jour et renouvelle automatiquement tout certificat qui se trouve dans les trente jours avant son expiration.

      Vous pouvez consulter le statut de la minuterie avec systemctl :

      • sudo systemctl status certbot.timer

      Output

      ● certbot.timer - Run certbot twice daily Loaded: loaded (/lib/systemd/system/certbot.timer; enabled; vendor preset: enabled) Active: active (waiting) since Mon 2020-05-04 20:04:36 UTC; 2 weeks 1 days ago Trigger: Thu 2020-05-21 05:22:32 UTC; 9h left Triggers: ● certbot.service

      Pour tester le processus de renouvellement, vous pouvez faire un essai avec certbot :

      • sudo certbot renew --dry-run

      Si vous ne voyez pas d’erreurs, tout est prêt. Si nécessaire, Certbot renouvellera vos certificats et rechargera Nginx pour récupérer les modifications. Si le processus de renouvellement automatisé échoue, Let’s Encrypt enverra un message à l’adresse électronique que vous avez indiquée, vous avertissant de l’expiration prochaine de votre certificat.

      Conclusion

      Dans ce tutoriel, vous avez installé le client Let’s Encrypt certbot, téléchargé les certificats SSL pour votre domaine, configuré Nginx pour utiliser ces certificats et mis en place le renouvellement automatique des certificats. Si vous avez d’autres questions sur l’utilisation de Certbot, la documentation officielle est un bon point de départ.



      Source link