One place for hosting & domains

      installer

      Comment installer et sécuriser Secure phpMyAdmin sur Ubuntu 20.04


      Une version antérieure de ce tutoriel a été écrite par Brennan Bearnes.

      Introduction

      Si de nombreux utilisateurs ont besoin des fonctionnalités d’un système de gestion de base de données comme MySQL, ils peuvent ne pas se sentir à l’aise pour interagir avec le système uniquement à partir de l’invite MySQL.

      phpMyAdmin a été créé pour que les utilisateurs puissent interagir avec MySQL via une interface web. Dans ce guide, nous allons voir comment installer et sécuriser phpMyAdmin afin que vous puissiez l’utiliser en toute sécurité pour gérer vos bases de données sur un système Ubuntu 20.04.

      Conditions préalables

      Afin de compléter ce guide, il vous faudra :

      De plus, il y a des considérations de sécurité importantes lors de l’utilisation de logiciels comme phpMyAdmin, puisque celui-ci :

      • communique directement avec votre installation MySQL
      • gère l’authentification à l’aide des identifiants MySQL
      • exécute et renvoie des résultats pour des requêtes SQL arbitraires

      Pour ces raisons, et parce qu’il s’agit d’une application PHP largement déployée qui est fréquemment la cible d’attaques, vous ne devriez jamais exécuter phpMyAdmin sur des systèmes distants via une simple connexion HTTP.

      Si vous n’avez pas de domaine existant configuré avec un certificat SSL/TLS, vous pouvez suivre ce guide sur la sécurisation d’Apache avec Let’s Encrypt sur Ubuntu 20.04. Pour cela, vous devrez enregistrer un nom de domaine, créer des enregistrements DNS pour votre serveur et mettre en place un hôte virtuel Apache. 

      Étape 1 — Installer Django

      Vous pouvez utiliser APT pour installer phpMyAdmin à partir des dépôts Ubuntu par défaut.

      En tant qu’utilisateur non root sudo, mettez à jour l’index des paquets de votre serveur :

      Ensuite, vous pouvez installer le paquet phpmyadmin. Parallèlement à ce paquet, la documentation officielle recommande également d’installer quelques extensions PHP sur votre serveur afin d’activer certaines fonctionnalités et d’améliorer les performances.

      Si vous avez suivi le tutoriel préalable sur la pile LAMP, plusieurs de ces modules auront été installés en même temps que le paquet php.   Toutefois, il est recommandé d’installer également ces paquets :

      • php-mbstring : Un module pour gérer les chaînes non ASCII et convertir les chaînes en différents encodages
      • php-zip : Cette extension permet de télécharger des fichiers .zip vers phpMyAdmin
      • php-gd : Permet de prendre en charge la bibliothèque graphique GD
      • php-json : Fournit à PHP un support pour la sérialisation JSON
      • php-curl : Permet à PHP d’interagir avec différents types de serveurs utilisant différents protocoles

      Exécutez la commande suivante pour installer ces paquets sur votre système. Veuillez noter, cependant, que le processus d’installation nécessite que vous fassiez certains choix pour configurer correctement phpMyAdmin. Nous allons bientôt passer en revue ces options :

      • sudo apt install phpmyadmin php-mbstring php-zip php-gd php-json php-curl

      Voici les options que vous devez choisir lorsque vous y êtes invité afin de configurer correctement votre installation :

      • Pour la sélection du serveur, choisissez apache2

        Warning: Lorsque l’invite apparaît, « apache2 » est mis en évidence, mais n’est pas sélectionné. Si vous ne tapez pas sur SPACE pour sélectionner Apache, l’installateur ne déplacera* pas *les fichiers nécessaires pendant l’installation. Appuyez sur SPACE, TAB, puis ENTER pour sélectionner Apache.
      • Sélectionnez Yes quand il est demandé s’il faut utiliser dbconfig-common pour créer la base de données
      • Il vous sera ensuite demandé de choisir et de confirmer un mot de passe d’application MySQL pour phpMyAdmin

      Note : En supposant que vous ayez installé MySQL en suivant l’étape 2 du tutoriel préalable sur la pile LAMP, vous avez peut-être décidé d’activer le plugin Validate Password plugin. A partir de ce moment, l’activation de ce composant déclenchera une erreur lorsque vous tenterez de définir un mot de passe pour l’utilisateur phpmyadmin :

      Erreur de validation du mot de passe phpMyAdmin

      Pour résoudre ce problème, sélectionnez l’option d’annulation pour arrêter le processus d’installation. Ensuite, ouvrez votre prompt MySQL :

      Ou, si vous avez activé l’authentification par mot de passe pour l’utilisateur MySQL root, exécutez cette commande et entrez ensuite votre mot de passe lorsque vous y êtes invité :

      À l’invite, exécutez la commande suivante pour désactiver le composant Validate Password. Notez que cela ne le désinstallera pas réellement, mais empêchera simplement le composant d’être lancé sur votre serveur MySQL :

      • UNINSTALL COMPONENT "file://component_validate_password";

      Ensuite, vous pouvez fermer le client MySQL :

      Essayez ensuite d’installer le paquet phpmyadmin et il fonctionnera comme prévu :

      • sudo apt install phpmyadmin

      Une fois que phpMyAdmin est installé, vous pouvez ouvrir l’invite MySQL une nouvelle fois avec sudo mysql ou mysql -u root -p et ensuite exécuter la commande suivante pour réactiver le composant Validate Password : 

      • INSTALL COMPONENT "file://component_validate_password";

      Le processus d’installation ajoute le fichier de configuration Apache de phpMyAdmin dans le répertoire /etc/apache2/conf-enabled/, où il est lu automatiquement. Pour finir de configurer Apache et PHP afin qu’ils fonctionnent avec phpMyAdmin, la seule tâche qui reste à accomplir dans cette section du tutoriel est d’activer explicitement l’extension PHP mbstring, ce que vous pouvez faire en tapant :

      Ensuite, redémarrez Apache pour que vos modifications soient reconnues :

      • sudo systemctl restart apache2

      phpMyAdmin est maintenant installé et configuré pour fonctionner avec Apache. Toutefois, avant de pouvoir vous connecter et de commencer à interagir avec vos bases de données MySQL, vous devrez vous assurer que vos utilisateurs MySQL disposent des privilèges requis pour interagir avec le programme.

      Étape 2 – Ajustement de l’authentification et des privilèges des utilisateurs

      Lorsque vous avez installé phpMyAdmin sur votre serveur, il a automatiquement créé un utilisateur de base de données appelé phpmyadmin qui effectue certains processus sous-jacents pour le programme. Plutôt que de vous connecter en tant qu’utilisateur avec le mot de passe administratif que vous avez défini lors de l’installation, il est recommandé de vous connecter soit en tant que root user MySQL, soit en tant qu’dedicated user à la gestion des bases de données via l’interface phpMyAdmin.

      Configuration du mot de passe d’accès au compte root MySQL

      Dans les systèmes Ubuntu fonctionnant sous MySQL 5.7 (et versions ultérieures), l’utilisateur MySQL root est configuré pour s’authentifier en utilisant le plugin auth_socket par défaut plutôt qu’avec un mot de passe. Cela permet une plus grande sécurité et facilité d’utilisation dans de nombreux cas, mais cela peut également compliquer les choses lorsque vous devez autoriser un programme externe – comme phpMyAdmin – pour accéder à l’utilisateur.

      Afin de vous connecter à phpMyAdmin en tant qu’utilisateur MySQL root, vous devrez changer sa méthode d’authentification de auth_socket à une méthode qui utilise un mot de passe, si vous ne l’avez pas déjà fait. Pour ce faire, ouvrez l’invite MySQL depuis votre terminal :

      Ensuite, vérifiez la méthode d’authentification utilisée par chacun de vos comptes utilisateurs MySQL à l’aide de la commande suivante :

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | | auth_socket | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Dans cet exemple, vous pouvez voir que l’utilisateur root s’authentifie effectivement en utilisant le plugin auth_socket. Pour configurer le compte root afin qu’il s’authentifie avec un mot de passe, exécutez la commande ALTER USER suivante.   Assurez-vous de changer password par un mot de passe fort de votre choix :

      • ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Remarque : L’instruction ALTER USER précédente définit l’utilisateur MySQL root pour s’authentifier avec le plugin caching_sha2_password. Selon la documentation officielle de MySQL, caching_sha2_password est le plugin d’authentification préféré de MySQL, car il fournit un cryptage de mot de passe plus sûr que l’ancien, mais encore largement utilisé, mysql_native_password.

      Cependant, certaines versions de PHP ne fonctionnent pas de manière fiable avec caching_sha2_password. PHP a signalé que ce problème a été corrigé à partir de PHP 7.4, mais si vous rencontrez une erreur en essayant de vous connecter à phpMyAdmin plus tard, vous pourriez vouloir définir root pour vous authentifier avec mysql_native_password à la place :

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

      Ensuite, vérifiez à nouveau les méthodes d’authentification employées par chacun de vos utilisateurs pour confirmer que le root ne s’authentifie plus à l’aide du plugin auth_socket :

      • SELECT user,authentication_string,plugin,host FROM mysql.user;

      Output

      +------------------+-------------------------------------------+-----------------------+-----------+ | user | authentication_string | plugin | host | +------------------+-------------------------------------------+-----------------------+-----------+ | root | *DE06E242B88EFB1FE4B5083587C260BACB2A6158 | caching_sha2_password | localhost | | mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | caching_sha2_password | localhost | | debian-sys-maint | *8486437DE5F65ADC4A4B001CA591363B64746D4C | caching_sha2_password | localhost | | phpmyadmin | *5FD2B7524254B7F81B32873B1EA6D681503A5CA9 | caching_sha2_password | localhost | +------------------+-------------------------------------------+-----------------------+-----------+ 5 rows in set (0.00 sec)

      Vous pouvez voir à partir de cette sortie que le root user s’authentifiera à l’aide d’un mot de passe. Vous pouvez maintenant vous connecter à l’interface phpMyAdmin en tant que root user avec le mot de passe que vous lui avez attribué ici.

      Configuration de l’accès par mot de passe pour un utilisateur MySQL dédié

      Alternativement, certains peuvent trouver qu’il est plus adapté à leur travail de se connecter à phpMyAdmin avec un dedicated user. Pour ce faire, ouvrez à nouveau le shell MySQL :

      Si vous avez activé l’authentification par mot de passe pour votre root user, comme décrit dans la section précédente, vous devrez exécuter la commande suivante et saisir votre mot de passe lorsque vous y serez invité afin de vous connecter :

      De là, créez un nouvel utilisateur et attribuez-lui un mot de passe fort :

      • CREATE USER 'sammy'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';

      Note : Encore une fois, selon la version de PHP que vous avez installée, vous voudrez peut-être configurer votre nouvel utilisateur pour qu’il s’authentifie avec le mot de passe mysql_native_password au lieu du mot de passe caching_sha2_password :

      • ALTER USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

      Ensuite, accordez à votre nouvel utilisateur les privilèges appropriés. Par exemple, vous pourriez accorder les privilèges d’utilisateur à toutes les tables de la base de données, ainsi que le pouvoir d’ajouter, de modifier et de supprimer des privilèges d’utilisateur, avec cette commande :

      • GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'localhost' WITH GRANT OPTION;

      Ensuite, quittez le shell MySQL :

      Vous pouvez maintenant accéder à l’interface web en visitant le nom de domaine ou l’adresse IP publique de votre serveur suivi de /phpmyadmin :

      https://your_domain_or_IP/phpmyadmin
      

      Écran de connexion à phpMyAdmin

      Connectez-vous à l’interface, soit commeroot ou avec le nouveau nom d’utilisateur et le nouveau mot de passe que vous venez de configurer. 

      Lorsque vous vous connecterez, vous verrez l’interface utilisateur, qui ressemblera à ceci :

      Interface utilisateur de phpMyAdmin

      Maintenant que vous êtes capable de vous connecter et d’interagir avec phpMyAdmin, il ne vous reste plus qu’à renforcer la sécurité de votre système pour le protéger des attaques.

      Étape 3 – Sécuriser votre instance phpMyAdmin

      En raison de son ubiquité, phpMyAdmin est une cible populaire pour les attaquants, et vous devriez faire très attention à empêcher tout accès non autorisé. Une façon de procéder consiste à placer une passerelle devant l’ensemble de l’application en utilisant les fonctionnalités d’authentification et d’autorisation .htaccess intégrées à Apache.

      Pour ce faire, vous devez d’abord activer l’utilisation des fichiers .htaccess en modifiant le fichier de configuration Apache de votre installation de phpMyAdmin.

      Utilisez votre éditeur de texte favori pour modifier le fichier phpmyadmin.conf qui a été placé dans votre répertoire de configuration Apache. Ici, nous utiliserons nano :

      • sudo nano /etc/apache2/conf-available/phpmyadmin.conf

      Ajoutez une directive AllowOverride All dans la section <Directory /usr/share/phpmyadmin> du fichier de configuration, comme ceci :

      /etc/apache2/conf-available/phpmyadmin.conf

      <Directory /usr/share/phpmyadmin>
          Options FollowSymLinks
          DirectoryIndex index.php
          AllowOverride All
          . . .
      

      Lorsque vous avez ajouté cette ligne, enregistrez et fermez le fichier. Si vous avez utilisé nano pour éditer le fichier, faites-le en appuyant sur CTRL + X, Y, puis ENTER

      Pour mettre en œuvre les modifications que vous avez apportées, redémarrez Apache :

      • sudo systemctl restart apache2

      Maintenant que vous avez autorisé l’utilisation de fichiers .htaccess pour votre application, vous devez en créer un pour mettre en place une certaine sécurité. 

      Pour que cela soit possible, le fichier doit être créé dans le répertoire de l’application. Vous pouvez créer le fichier nécessaire et l’ouvrir dans votre éditeur de texte avec les privilèges root en tapant :

      • sudo nano /usr/share/phpmyadmin/.htaccess

      Dans ce fichier, entrez les informations suivantes :

      /usr/share/phpmyadmin/.htaccess

      AuthType Basic
      AuthName "Restricted Files"
      AuthUserFile /etc/phpmyadmin/.htpasswd
      Require valid-user
      

      Voici ce que signifie chacune de ces lignes :

      • AuthType Basic : Cette ligne précise le type d’authentification que vous mettez en œuvre. Ce type mettra en œuvre l’authentification par mot de passe à l’aide d’un fichier de mots de passe.
      • AuthName : Définit le message pour la boîte de dialogue d’authentification. Vous devez conserver ce générique afin que les utilisateurs non autorisés n’obtiennent aucune information sur ce qui est protégé.
      • AuthUserFile : permet de définir l’emplacement du fichier de mots de passe qui sera utilisé pour l’authentification. Cela doit se faire en dehors des répertoires qui sont desservis. Nous allons créer ce dossier prochainement.
      • Require valid-user : Ceci spécifie que seuls les utilisateurs authentifiés doivent avoir accès à cette ressource. C’est ce qui empêche en fait les utilisateurs non autorisés d’entrer.

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

      L’emplacement que vous avez choisi pour votre fichier de mots de passe était /etc/phpmyadmin/.htpasswd. Vous pouvez maintenant créer ce fichier et le transmettre à un utilisateur initial avec l’utilitaire htpasswd :

      • sudo htpasswd -c /etc/phpmyadmin/.htpasswd username

      Vous serez invité à sélectionner et à confirmer un mot de passe pour l’utilisateur que vous créez. Ensuite, le fichier est créé avec le mot de passe haché que vous avez entré.

      Si vous voulez entrer un utilisateur supplémentaire, vous devez le faire sans le drapeau -c, comme ceci :

      • sudo htpasswd /etc/phpmyadmin/.htpasswd additionaluser

      Maintenant, lorsque vous accédez à votre sous-répertoire phpMyAdmin, il vous sera demandé le nom de compte et le mot de passe supplémentaires que vous venez de configurer :

      https://domain_name_or_IP/phpmyadmin
      

      Mot de passe apache de phpMyAdmin

      Après avoir entré l’authentification Apache, vous serez dirigé vers la page d’authentification phpMyAdmin habituelle pour entrer vos identifiants MySQL. En ajoutant un ensemble supplémentaire d’identifiants non-MySQL, vous apportez à votre base de données une couche de sécurité supplémentaire. Ceci est souhaitable, puisque phpMyAdmin a été vulnérable aux menaces de sécurité par le passé.

      Conclusion

      Vous devriez maintenant avoir configuré phpMyAdmin et être prêt à l’utiliser sur votre serveur Ubuntu 20.04. Cette interface vous permet de créer des bases de données, des utilisateurs et des tableaux, ainsi que d’effectuer les opérations habituelles comme la suppression et la modification de structures et de données.



      Source link

      Comment installer et utiliser Composer sur Ubuntu 20.04


      Introduction

      Composer est un outil populaire de gestion des dépendances pour PHP, créé principalement pour faciliter l’installation et les mises à jour des dépendances des projets. Il vérifiera de quels autres paquets un projet spécifique dépend et les installera pour vous en utilisant les versions appropriées selon les exigences du projet. Composer est également couramment utilisé pour lancer de nouveaux projets basés sur des cadres PHP populaires tels que Symfony et Laravel.

      Dans ce tutoriel, vous allez installer et commencer à utiliser Composer sur un système Ubuntu 20.04.

      Conditions préalables

      Pour pouvoir suivre ce guide, vous devez avoir accès à un serveur Ubuntu 20.04 en tant que non-root sudo user, et un pare-feu activé sur votre serveur. Pour configurer cela, vous pouvez notre guide de configuration initiale du serveur pour Ubuntu 20.04.

      Étape 1 – Installer PHP et des dépendances supplémentaires

      En plus des dépendances qui devraient déjà être incluses dans votre système Ubuntu 20.04, telles que git et curl, Composer nécessite php-cli pour exécuter les scripts PHP en ligne de commande, et unzip pour extraire les archives zippées.   Nous allons maintenant installer ces dépendances.

      Tout d’abord, mettez à jour le cache du gestionnaire de paquets en exécutant :

      Ensuite, exécutez la commande suivante pour installer les paquets requis :

      • sudo apt install php-cli unzip

      Vous serez invité à confirmer l’installation en tapant Y et ensuite ENTER.

      Une fois les prérequis installés, vous pouvez procéder à l’installation de Composer.

      Étape 2 – Téléchargement et installation de Composer

      Composer fournit un script d’installation écrit en PHP. Nous allons le télécharger, vérifier qu’il n’est pas corrompu, puis l’utiliser pour installer Composer.

      Assurez-vous que vous êtes dans votre répertoire d’origine, puis récupérez l’installateur en utilisant curl : 

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      Ensuite, nous allons vérifier que l’installateur téléchargé correspond au hachage SHA-384 pour le dernier installateur trouvé sur la page des clés publiques/signatures de Composer.   Pour faciliter l’étape de vérification, vous pouvez utiliser la commande suivante pour obtenir par programmation le dernier hachage de la page de Composer et le stocker dans une variable shell :

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Si vous voulez vérifier la valeur obtenue, vous pouvez exécuter :

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Exécutez maintenant le code PHP suivant tel que fourni dans la page de téléchargement de Composer pour vérifier que le script d’installation peut être exécuté en toute sécurité : 

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Vous verrez la sortie suivante :

      Output

      Installer verified
      

      Si la sortie indique que l'installateur est corrompu, vous devrez télécharger à nouveau le script d’installation et vérifier que vous utilisez le bon hachage. Ensuite, répétez le processus de vérification. Lorsque vous avez un installateur vérifié, vous pouvez continuer.

      Pour installer Composer globalement, utilisez la commande suivante qui téléchargera et installera Composer sous la forme d’une commande système nommée composer, sous /usr/local/bin :

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Vous verrez une sortie semblable à celle-ci :

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Pour tester votre installation, exécutez :

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Cela permet de vérifier que Composer a été installé avec succès sur votre système et qu’il est disponible dans tout le système.

      Note : Si vous préférez avoir des exécutables de Composer séparés pour chaque projet que vous hébergez sur ce serveur, vous pouvez l’installer localement, par projet. Cette méthode est également utile lorsque l’utilisateur de votre système n’a pas la permission d’installer un logiciel dans tout le système.

      Pour ce faire, utilisez la commande php composer-setup.php. Cela va générer un fichier composer.phar dans votre répertoire actuel qui peut être exécuté avec php composer.phar.

      Voyons maintenant comment utiliser Composer pour gérer les dépendances.

      Étape 3 – Utilisation de Composer dans un projet PHP

      Les projets PHP dépendent souvent de bibliothèques externes, et la gestion de ces dépendances et de leurs versions peut être délicate. Composer résout ce problème en gardant la trace des versions et des dépendances du projet, tout en facilitant le processus de recherche, d’installation et de mise à jour des paquets requis par un projet.

      Pour utiliser Composer dans votre projet, vous aurez besoin d’un fichier composer.json. Le fichier composer.json indique au compositeur quelles dépendances il doit télécharger pour votre projet, et quelles versions de chaque paquet peuvent être installées. Ceci est extrêmement important pour maintenir la cohérence de votre projet et éviter d’installer des versions instables qui pourraient potentiellement causer des problèmes de rétrocompatibilité.

      Vous n’avez pas besoin de créer ce fichier manuellement – il est fréquent de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer offre un moyen interactif de créer un nouveau fichier composer.json basé sur la contribution de l’utilisateur, ce qui est un bon choix si vous prévoyez de partager votre projet plus tard en tant que paquet public sur Packagist. Composer génère aussi automatiquement un fichier barebones composer.json lorsque vous lancez une commande composer require pour inclure une dépendance dans un projet nouvellement créé.

      Le processus d’utilisation de Composer pour installer un paquet en tant que dépendance dans un projet implique les étapes suivantes :

      • Identifiez le type de bibliothèque dont la demande a besoin.
      • Recherchez une bibliothèque open source appropriée sur Packagist.org, le dépôt officiel de paquets pour Composer.
      • Choisissez le paquet dont vous voulez dépendre.
      • Exécutez composer require pour inclure la dépendance dans le fichier composer.json et installez le paquet.

      Essayons cela avec une application de démonstration.

      L’objectif de cette application est de transformer une phrase donnée en une chaîne facile à utiliser pour les URL – a slug. Cette méthode est couramment utilisée pour convertir les titres des pages en chemins d’accès URL (comme la dernière partie de l’URL pour ce tutoriel).

      Commençons par créer un répertoire pour notre projet. Nous l’appellerons slugify :

      • cd ~
      • mkdir slugify
      • cd slugify

      Bien que ce ne soit pas obligatoire, vous pouvez maintenant lancer une commande composer init pour créer un fichier composer.json détaillé pour votre projet. Comme le seul objectif de notre projet est de démontrer comment installer des dépendances avec Composer, nous utiliserons un fichier composer.json plus simple qui sera généré automatiquement lorsque nous aurons besoin de notre premier paquet.

      Il est maintenant temps de rechercher sur Packagist.org un paquet qui peut nous aider à générer des slugs. Si vous recherchez le terme slug sur Packagist, vous obtiendrez un résultat similaire à celui-ci :

      Résultats de la recherche pour le terme slug

      Vous verrez deux numéros sur le côté droit de chaque paquet dans la liste. Le chiffre du haut représente le nombre de fois que le paquet a été installé via Composer, et le chiffre du bas indique le nombre de fois qu’un paquet a été mis en vedette sur GitHub. D’une manière générale, les paquets comportant plus d’installations et plus d’étoiles ont tendance à être plus stables, puisque beaucoup de gens les utilisent. Il est également important de vérifier la pertinence de la description du paquet pour s’assurer qu’il correspond à vos besoins.

      Nous avons besoin d’un convertisseur de chaîne de caractères en slug. D’après les résultats de la recherche, le paquet cocur/slugify qui apparaît comme premier résultat dans cette page semble être une bonne correspondance avec un nombre raisonnable d’installations et d’étoiles.

      Les paquets sur Packagist ont un nom de vendeur et un nom de paquet. Chaque paquet possède un identifiant unique (un espace de noms) dans le même format que celui utilisé par GitHub pour ses dépôts : vendor/package La bibliothèque que nous voulons installer utilise l’espace de noms cocur/slugify. Vous avez besoin de l’espace de noms d’un paquet afin de l’exiger dans votre projet.

      Maintenant que vous savez exactement quel paquet vous voulez installer, vous pouvez lancer composer require pour l’inclure comme dépendance et aussi générer le fichier composer.json pour votre projet. Une chose qu’il est important de noter quand on demande des paquets, c’est que Composer suit à la fois les dépendances au niveau de l’application et celles au niveau du système. Les dépendances au niveau du système sont importantes pour indiquer sur quels modules PHP un paquet repose. Dans le cas de lacocur/slugify, il nécessite un module PHP que nous n’avons pas encore installé.

      Lorsqu’un paquet requis repose sur une bibliothèque système qui n’est actuellement pas installée sur votre serveur, vous obtenez une erreur vous indiquant quelle exigence est manquante :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Pour résoudre le problème de dépendance du système, nous pouvons rechercher le paquet manquant en utilisant la recherche apt : 

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Après avoir trouvé le nom de paquet correct, vous pouvez à nouveau utiliser apt pour installer la dépendance du système :

      • sudo apt install php-mbstring

      Une fois l’installation terminée, vous pouvez relancer la commande composer require :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Comme vous pouvez le voir sur la sortie, Composer a automatiquement décidé de la version du paquet à utiliser. Si vous vérifiez maintenant le répertoire de votre projet, il contiendra deux nouveaux fichiers : composer.json et composer.lock, ainsi qu’un répertoire vendor :

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      Le fichier composer.lock est utilisé pour stocker des informations sur les versions de chaque paquet qui sont installées, et s’assurer que les mêmes versions sont utilisées si quelqu’un d’autre clone votre projet et installe ses dépendances. Le répertoire vendor est l’endroit où se trouvent les dépendances du projet. Le dossier vendor ne doit pas être intégré dans le contrôle de version – vous devez seulement inclure les fichiers composer.json *et *composer.lock.

      Lors de l’installation d’un projet qui contient déjà un fichier composer.json, lancez composer install afin de télécharger les dépendances du projet.

      Jetons un coup d’œil rapide aux contraintes de version. Si vous vérifiez le contenu de votre fichier composer.json, vous verrez quelque chose comme ceci :

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Vous remarquerez peut-être le caractère spécial ^ avant le numéro de version dans composer.json. Composer accepte plusieurs contraintes et formats différents pour définir la version de paquet requise afin d’offrir une certaine souplesse tout en maintenant la stabilité de votre projet. L’opérateur caret (^) utilisé par le fichier composer.json généré automatiquement est l’opérateur recommandé pour une interopérabilité maximale, après le versionnage sémantique. Dans ce cas, elle définit4.0 comme version minimale compatible, et permet les mises à jour de toute version future inférieure à 5.0.

      D’une manière générale, vous n’aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Toutefois, certaines situations peuvent vous obliger à modifier manuellement les contraintes, par exemple lorsqu’une nouvelle version importante de votre bibliothèque requise est publiée et que vous souhaitez la mettre à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la sémantique des versions.

      Voici quelques exemples pour vous donner une meilleure compréhension du fonctionnement des contraintes de version de Composer :

      Contrainte Signification Exemples de versions autorisées
      ^1.0 >= 1,0 < 2,0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1,0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1,0 < 2,0 1.0.9, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Pour une vue plus approfondie des contraintes des versions de Composer, voir la documentation officielle.

      Ensuite, voyons comment charger des dépendances automatiquement avec Composer.

      Étape 4 – Inclure le script d’autochargement

      Comme PHP lui-même ne charge pas automatiquement les classes, Composer fournit un script d’autochargement que vous pouvez inclure dans votre projet afin que l’autochargement fonctionne pour votre projet. Ce fichier est automatiquement généré par Composer lorsque vous ajoutez votre première dépendance.

      La seule chose que vous devez faire est d’inclure le fichier vendor/autoload.php dans vos scripts PHP avant toute instanciation de classe.

      Essayons-le dans notre application de démonstration. Ouvrez un nouveau fichier appelé test.php dans votre éditeur de texte :

      Ajoutez le code suivant qui apporte le fichier vendor/autoload.php, lance la dépendance cocur/slugify et l’utilise pour créer un slug :

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Enregistrez le fichier et quittez votre éditeur.

      Maintenant, lancez le script :

      Cela produit le résultat "hello-world-this-is-a-long-sentence-and--i-need-to-make-a-slug-from-it.

      Les dépendances ont besoin de mises à jour lorsque de nouvelles versions sortent, alors regardons comment gérer cela.

      Étape 5 – Mettre à jour les dépendances des projets

      Chaque fois que vous souhaitez mettre à jour les dépendances de votre projet vers des versions plus récentes, lancez la commande update:

      Cela permettra de vérifier s’il existe des versions plus récentes des bibliothèques dont vous avez eu besoin dans votre projet. Si une version plus récente est trouvée et qu’elle est compatible avec la contrainte de version définie dans le fichier composer.json, Composer remplacera la version précédente installée. Le fichier composer.lock sera mis à jour pour refléter ces changements.

      Vous pouvez également mettre à jour une ou plusieurs bibliothèques spécifiques en les spécifiant comme ceci :

      • composer update vendor/package vendor2/package2

      N’oubliez pas de vérifier vos fichiers composer.json et composer.lock dans votre système de contrôle de version après avoir mis à jour vos dépendances afin que d’autres puissent également installer ces nouvelles versions. 

      Conclusion

      Composer est un outil puissant qui peut grandement faciliter le travail de gestion des dépendances dans les projets PHP. Il fournit un moyen fiable de découvrir, d’installer et de mettre à jour les paquets PHP dont dépend un projet. Dans ce guide, nous avons vu comment installer Composer, comment inclure de nouvelles dépendances dans un projet, et comment mettre à jour ces dépendances lorsque de nouvelles versions sont disponibles.



      Source link

      Comment installer Django et mettre en place un environnement de développement sur Ubuntu 20.04


      Introduction

      Django est un framework web libre et open-source écrit en Python dont les principes de base sont l’extensibilité, la réutilisation et le développement rapide. Il est également connu pour sa cohérence au niveau du framework et son couplage lâche, qui permet aux différents composants d’être indépendants les uns des autres.

      Dans ce tutoriel, nous allons mettre en place un environnement Django à des fins de développement sur un serveur Ubuntu 20.04. Pour un site web en direct, vous aurez des considérations supplémentaires, notamment la connexion à une base de données, la mise en place d’un nom de domaine et l’ajout de couches de sécurité. Nous avons une variété de tutoriels sur Django qui peuvent vous aider à construire sous notre label Django.

      Conditions préalables

      Pour pouvoir suivre ce tutoriel, vous aurez besoin de :

      Étape 1 — Installation de Django

      Il existe plusieurs façons d’installer Django, le gestionnaire de packages Python pip dans un environnement virtuel.

      Dans le répertoire d’origine du serveur, nous allons créer le répertoire qui contiendra notre application Django. Exécutez la commande suivante pour créer un répertoire appelé django-apps, ou un autre nom de votre choix.  Naviguez ensuite vers le répertoire.

      • mkdir django-apps
      • cd django-apps

      Dans le répertoire django-apps, créez votre environnement virtuel. Nous l’appellerons le générique env, mais vous devez utiliser un nom qui est significatif pour vous et votre projet.

      Maintenant, activez l’environnement virtuel avec la commande suivante :

      Vous saurez qu’il est activé dès que le préfixe sera changé en (env), ce qui ressemblera à ce qui suit, selon le répertoire dans lequel vous vous trouvez :

      Dans l’environnement, installez le package Django en utilisant pip. L’installation de Django nous permet de créer et d’exécuter des applications Django.

      Une fois installé, vérifiez votre installation Django en effectuant un contrôle de version :

      Ceci, ou quelque chose similaire, sera la sortie qui en résulte :

      Output

      3.0.6

      Une fois Django installé sur votre serveur, nous pouvons passer à la création d’un projet test pour nous assurer que tout fonctionne correctement. Nous allons créer un squelette d’application web.

      Étape 2 – Ajuster les paramètres du pare-feu

      Si vous avez suivi notre tutoriel de configuration initiale du serveur ou que vous avez un pare-feu sur votre serveur, nous devrons ouvrir le port que nous utiliserons dans le pare-feu de notre serveur. Pour le pare-feu UFW, vous pouvez ouvrir le port avec la commande suivante :

      Si vous utilisez les pare-feu DigitalOcean, vous pouvez sélectionner HTTP dans les règles d’entrée. Vous pouvez en savoir plus sur les pare-feu DigitalOcean et sur la création de règles pour ceux-ci en modifiant les règles d’entrée.

      Étape 3 — Démarrage du projet

      Nous pouvons maintenant générer une application en utilisant django-admin, un utilitaire en ligne de commande pour les tâches d’administration en Python. Ensuite, nous pouvons utiliser la commande startproject pour créer la structure du répertoire projet pour notre site web test.

      Dans le répertoire django-apps, exécutez la commande suivante :

      • django-admin startproject testsite

      Remarque : L’exécution de la commande django-admin startproject <projectname> donnera au répertoire du projet et au package du projet le nom <projectname> et créera le projet dans le répertoire dans lequel la commande a été exécutée. Si le paramètre facultatif <destination> est fourni, Django utilisera le répertoire de destination fourni comme répertoire du projet, et créera le fichier manage.py et le package du projet à l’intérieur de celui-ci.

      Nous pouvons maintenant voir quels fichiers de projet viennent d’être créés. Naviguez vers le répertoire testsite puis listez le contenu de ce répertoire pour voir quels fichiers ont été créés :

      Output

      manage.py testsite

      Vous remarquerez une sortie qui montre ce répertoire contient un fichier nommé manage.py et un dossier nommé testsite. Le fichier manage.py est similaire à django-admin et place le package du projet sur sys.path. Cela permet également de faire pointer la variable d’environnement DJANGO_SETTINGS_MODULE sur le fichier settings.py de votre projet.

      Vous pouvez visualiser le script manage.py dans votre terminal en exécutant la commande less comme ceci :

      Lorsque vous avez terminé la lecture du script, appuyez sur q, pour quitter la visualisation du fichier.

      Naviguez maintenant dans le répertoire testsite pour visualiser les autres fichiers qui ont été créés :

      Exécutez ensuite la commande suivante pour lister le contenu du répertoire :

      Vous verrez quatre fichiers :

      Output

      __init__.py asgi.py settings.py urls.py wsgi.py

      Examinons la nature de chacun de ces fichiers :

      • __init__.py agit comme point d’entrée pour votre projet Python.
      • asgi.py contient la configuration pour le déploiement optionnel à l’Asynchronous Server Gateway Interface ou ASGI, qui fournit un standard pour les applications qui sont soit synchrones soit asynchrones, et est considéré comme un successeur du WSGI (voir ci-dessous).
      • settings.py décrit la configuration de votre installation Django et permet à Django de connaître les paramètres disponibles.
      • urls.py contient une liste d’urlpatterns, qui dirige et fait correspondre les URL à leurs vues.
      • wsgi.py contient la configuration de la Web Server Gateway Interface ou WSGI, qui fournit un standard pour les applications Python synchrones.

      Remarque : Bien que les fichiers par défaut soient générés, vous avez encore la possibilité de modifier les fichiers asgi.py ou wsgi.py à tout moment pour répondre à vos besoins de déploiement.

      Étape 4 — Configuration de Django

      Nous pouvons maintenant démarrer le serveur et visualiser le site web sur un hôte et un port désignés en exécutant la commande runserver.

      Nous devrons ajouter l’adresse ip de votre serveur à la liste des ALLOWED_HOSTS dans le fichier settings.py situé dans ~/test_django_app/testsite/testsite/.

      Comme indiqué dans la documentations de Django, la variable ALLOWED_HOSTS contient « une liste des chaînes de caractères représentant les noms d’hôtes/domaines que ce site Django peut servir. Il s’agit d’une mesure de sécurité pour prévenir les attaques d’en-tête HTTP Host, qui sont possibles même dans de nombreuses configurations de serveurs web apparemment sûres. »

      Vous pouvez utiliser votre éditeur de texte préféré pour ajouter votre adresse IP. Par exemple, si vous utilisez nano, exécutez la commande suivante :

      • nano ~/django-apps/testsite/testsite/settings.py

      Une fois la commande exécutée, vous devrez vous rendre dans la section “Allowed Host du document et ajouter l’adresse IP de votre serveur entre des crochets, dans des guillemets simples ou doubles.

      settings.py

      """
      Django settings for testsite project.
      
      Generated by 'django-admin startproject' using Django 2.0.
      ...
      """
      ...
      # SECURITY WARNING: don't run with debug turned on in production!
      DEBUG = True
      
      # Edit the line below with your server IP address
      ALLOWED_HOSTS = ['your-server-ip']
      ...
      

      Vous pouvez enregistrer la modification et quitter nano en appuyant sur la touche CTRL + x, puis sur la touche y. Ensuite, nous allons accéder à notre application web via un navigateur.

      Enfin, créons un utilisateur administratif afin de pouvoir utiliser l’interface d’admin de Djano. Pour le faire, utilisons la commande createsuperuser.

      • python manage.py createsuperuser

      Vous serez invité à saisir le nom d’utilisateur, l’adresse électronique et le mot de passe de votre utilisateur.

      Étape 5 — Accès à l’application web Django

      Une fois notre configuration terminée, assurez-vous de revenir au répertoire où se trouve manage.py :

      • cd ~/django-apps/testsite/

      Maintenant, exécutez la commande suivante en remplaçant le texte your-server-ip par l’IP de votre serveur :

      • python manage.py runserver 0.0.0.0:8000

      Enfin, vous pouvez naviguer vers le lien ci-dessous pour voir à quoi ressemble votre squelette de site web, en remplaçant à nouveau le texte en surbrillance par l’IP réelle de votre serveur :

      http://your-server-ip:8000/
      

      Une fois la page chargée, vous verrez ce qui suit :

      Page par défaut de Django

      Cela confirme que Django a été correctement installé et notre projet test fonctionne correctement.

      Pour accéder à l’interface d’administration, ajoutez /admin/ à la fin de votre URL :

      http://your_server_ip:8000/admin/
      

      Cela vous amènera à un écran de connexion :

      Connexion à l'interface d'administration de Django

      Si vous entrez le nom d’utilisateur et le mot de passe admin que vous venez de créer, vous aurez accès à la section admin principale du site :

      Page d'administration de Django

      Pour plus d’informations sur l’utilisation de l’interface d’administration de Django, veuillez consulter la section Comment activer et connecter l’interface d’administration de Django.

      Lorsque vous avez fini de tester votre application, vous pouvez appuyer sur CTRL + C pour arrêter la commande runserver​​​. Cela vous renverra à votre environnement de programmation.

      Lorsque vous êtes prêt à quitter votre environnement Python, vous pouvez exécuter la commande deactivate :

      La désactivation de votre environnement de programmation vous ramènera à l’invite de commande du terminal.

      Conclusion

      Dans ce tutoriel, vous avez réussi à installer Django et à mettre en place un environnement de développement pour commencer à travailler sur votre application Django.

      Vous disposez maintenant des bases nécessaires pour commencer à construire des applications web Django.



      Source link