One place for hosting & domains

      Comment installer et configurer SimpleSAMLphp pour l’authentification SAML sur Ubuntu 18.04


      Introduction

      SimpleSAMLphp est une application d’authentification PHP open-source qui prend en charge SAML 2.0 en tant que fournisseur de services (SP) ou fournisseur d’identité (IdP).

      SAML (Security Assertion Markup Language – Langue de balisage des assertions de sécurité) est un mécanisme de communication sécurisé basé sur XML pour l’échange de données d’authentification et d’autorisation entre les organisations et les applications. Il est souvent utilisé pour mettre en œuvre le Web SSO (Single Sign On). Il n’est donc plus nécessaire de conserver plusieurs justificatifs d’authentification dans plusieurs organisations. En termes simples, vous pouvez utiliser une seule identité, comme un nom d’utilisateur et un mot de passe, pour accéder à plusieurs demandes.

      Une instance de SimpleSAMLphp se connecte à une source d’authentification, qui est un fournisseur d’identité comme LDAP ou une base de données d’utilisateurs. Il authentifie les utilisateurs par rapport à cette source d’authentification avant d’accorder l’accès aux ressources mises à disposition par les fournisseurs de services liés.

      Dans ce tutoriel, vous allez installer SimpleSamlPHP et le configurer pour utiliser une base de données MySQL comme source d’authentification. Vous stockerez les utilisateurs et les mots de passe cryptés dans la base de données MySQL et vérifierez que vous pouvez utiliser ces utilisateurs pour vous connecter.

      Conditions préalables

      Étape 1 – Téléchargement et installation de SimpleSAMLphp

      Installer SimpleSAMLphp se fait en quelques étapes. Nous devons télécharger le logiciel lui-même ainsi que quelques composants et conditions préalables supplémentaires. Nous devrons également apporter quelques modifications à la configuration de notre hôte virtuel.

      Connectez-vous à votre serveur si vous n’êtes pas déjà connecté.

      Téléchargez SimpleSAMLphp sur le site web du projet. SimpleSAMLphp lie toujours la dernière version stable de leur logiciel à la même URL. Cela signifie que nous pouvons obtenir la dernière version en tapant ceci :

      • wget https://simplesamlphp.org/download?latest

      Cela permettra de télécharger un fichier compressé appelé download?latest qui contient SimpleSAMLphp. Extrayez le contenu avec la commande tar : 

      Les fichiers seront extraits dans un nouveau répertoire intitulé simpleamlphp-1.x.yx.y est le numéro de la version actuelle. Utilisez la commande ls pour identifier le fichier :

      Vous verrez le nom du fichier s’afficher :

      Ouptut

      simplesamlphp-1.18.5

      Maintenant, copiez le contenu du répertoire dans /var/simplesamlphp en utilisant la commande cp. Veillez à remplacer le numéro de version par la version que vous avez :

      • sudo cp -a simplesamlphp-1.x.y/. /var/simplesamlphp/

      Le commutateur -a garantit que les autorisations de fichiers sont copiées avec les fichiers et les dossiers. Le point à la fin du fichier source garantit que tout ce qui se trouve dans le répertoire source, y compris les fichiers cachés, est copié dans le répertoire de destination.

      Remarque : Si vous devez installer les fichiers dans un autre endroit, vous devrez mettre à jour plusieurs fichiers. Pour plus de détails, consultez la documentation officielle d’installation de SimpleSAMLphp.

      Il existe quelques logiciels supplémentaires dont SimpleSAMLphp a besoin, notamment des extensions PHP pour travailler avec XML, des chaînes de caractères à plusieurs octets, curl et LDAP.  Elle exige également memcached. Installez-les à l’aide de votre gestionnaire de paquets.

      Tout d’abord, mettez à jour votre liste de paquets :

      Ensuite, installez les paquets :

      • sudo apt install php-xml php-mbstring php-curl php-memcache php-ldap memcached

      Une fois l’installation terminée, redémarrez Apache pour activer les nouvelles extensions PHP :

      • sudo systemctl restart apache2

      Maintenant que SimpleSAMLphp est installé, configurons Apache pour servir les fichiers.

      Étape 2 – Configuration d’Apache pour servir SimpleSAMLphp

      Vous avez déjà configuré un domaine et pointé sur ce serveur, et vous avez mis en place un hôte virtuel pour travailler avec HTTPS en sécurisant Apache avec Let’s Encrypt. Utilisons cela pour servir SimpleSAMLphp.

      Le seul répertoire SimpleSAMLphp qui doit être visible sur le web est /var/simplesamlphp/www. Pour l’exposer au web, modifiez le fichier de configuration Apache SSL de l’hôte virtuel pour votre domaine.

      Si le fichier de configuration de votre hôte virtuel est nommé your_domain.conf, Let’s Encrypt a créé un nouveau fichier de configuration appelé your_domain-le-ssl.conf qui traite les demandes HTTPS pour votre domaine. Ouvrez le fichier de configuration SSL avec la commande suivante pour modifier le fichier. Veillez à remplacer your_domain avec le nom réel du fichier : 

      • sudo nano /etc/apache2/sites-available/your_domain-le-ssl.conf

      Le dossier doit ressembler à ce qui suit, bien que le dossier lui-même puisse comporter des commentaires plus descriptifs :

      your_domain-le-ssl.conf’>/etc/apache2/sites-available/your_domain-le-ssl.conf

      <IfModule mod_ssl.c>
      <VirtualHost *:443>
              ServerName your_domain
      
              ServerAdmin webmaster@localhost
              DocumentRoot /var/www/html
      
              ErrorLog ${APACHE_LOG_DIR}/error.log
              CustomLog ${APACHE_LOG_DIR}/access.log combined
      
      SSLCertificateFile /etc/letsencrypt/live/your_domain/fullchain.pem
      SSLCertificateKeyFile /etc/letsencrypt/live/your_domain/privkey.pem
      Include /etc/letsencrypt/options-ssl-apache.conf
      </VirtualHost>
      </IfModule>
      

      La directive ServerName définit ici le domaine de base qui doit correspondre à cette définition d’hôte virtuel. Il doit s’agir du nom de domaine pour lequel vous avez établi un certificat SSL dans la section Conditions préalables. Ajoutons une directive sur les alias qui donne le contrôle à SimpleSAMLphp pour toutes les URL qui correspondent https://votre_domaine/simplesaml/*. Faites-le en ajoutant la ligne suivante au fichier de configuration :

      your_domain-le-ssl.conf’>/etc/apache2/sites-available/your_domain-le-ssl.conf

      ...
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/html
      
        Alias /simplesaml /var/simplesamlphp/www
      
      ...
      

      Cela signifie que toutes les URL correspondent <^>domain_name^>/simplesaml/* sera dirigé vers le /var/simplesamlphp/www donnant le contrôle de SimpleSAMLphp. 

      Ensuite, nous donnerons accès au registre/var/simplesamlphp/www en spécifiant un Exiger tout le contrôle d'accès à ce dernier. Le service SimpleSAMLphp sera ainsi accessible sur le Web. Faites-le en ajoutant ce qui suit au fichier de configuration :

      your_domain-le-ssl.conf’>/etc/apache2/sites-available/your_domain-le-ssl.conf

      ...
        Alias /simplesaml /var/simplesamlphp/www
        <Directory /var/simplesamlphp/www/>
            Require all granted
        </Directory>
      ...
      

      Enregistrez et fermez le fichier. Redémarrez Apache pour que les changements prennent effet :

      • sudo systemctl restart apache2

      Maintenant qu’Apache est configuré pour servir les fichiers d’application, configurons SimpleSAMLphp.

      Étape 3 – Configuration de SimpleSAMLphp

      Ensuite, nous devons apporter plusieurs modifications à la configuration de base de SimpleSAMLphp située à /var/simplesamlphp/config/config.php. Ouvrez le fichier dans votre éditeur :

      • nano /var/simplesamlphp/config/config.php

      Définissez le mot de passe de l’administrateur en localisant la ligne « auth.adminpassword » et en remplaçant la valeur par défaut de 123 par un mot de passe plus sûr. Ce mot de passe vous permet d’accéder à certaines des pages de votre interface web d’installation de SimpleSAMLphp

      /var/simplesamlphp/config/config.php

      . . .
      'auth.adminpassword'        => 'your_admin_password',
      . . .
      

      Ensuite, définissez un sel secret, qui doit être une chaîne de caractères générée de façon aléatoire. Certaines parties de SimpleSAMLphp utilisent ce sel pour créer des hachages cryptographiquement sécurisés. Vous obtiendrez des erreurs si le sel n’est pas modifié par rapport à la valeur par défaut.

      Vous pouvez utiliser l’OpenSSL La fonction Rand permet de générer une chaîne aléatoire qui vous servira de chaîne de sel secrète. Ouvrez un nouveau terminal, reconnectez-vous à votre serveur et exécutez la commande suivante pour générer cette chaîne :

      L’option -base64 32 garantit une chaîne codée en Base64 de 32 caractères.

      Ensuite, dans le fichier de configuration, localisez l’entrée « secretsalt » et remplacez defaultsecretsalt avec la chaîne que vous avez générée : 

      /var/simplesamlphp/config/config.php

      . . .
      'secretsalt' => 'your_generated_salt',
      . . .
      

      Définissez ensuite les coordonnées techniques. Ces informations seront disponibles dans les métadonnées générées, et SimpleSAMLphp enverra des rapports d’erreur générés automatiquement à l’adresse électronique que vous aurez indiquée. Repérez la section suivante :

      /var/simplesamlphp/config/config.php

      . . .
      'technicalcontact_name'     => 'Administrator',
      'technicalcontact_email'    => 'na@example.org',
      . . .
      

      Remplacez Administrator et na@example.org avec des valeurs appropriées. 

      Définissez ensuite le fuseau horaire que vous souhaitez utiliser. Localisez cette section :

      /var/simplesamlphp/config/config.php

      . . .
      'timezone' => null,
      . . .
      

      Remplacez null avec un fuseau horaire préférentiel à partir de cette liste de fuseaux horaires pour PHP. Veillez à indiquer la valeur entre guillemets :

      /var/simplesamlphp/config/config.php

      . . .
      'timezone' => 'America/New_York',
      . . .
      

      Enregistrez et fermez le fichier. Vous devriez maintenant pouvoir accéder au site dans votre navigateur en visitant https://your_domain/simplesaml. Vous verrez l’écran suivant dans votre navigateur :

      simplesaml web interface

      Pour vous assurer que votre installation PHP répond à toutes les exigences pour le bon fonctionnement de SimpleSAMLphp, sélectionnez l’onglet Configuration et cliquez sur le lien Login as administrator (Se connecter en tant qu’administrateur). Utilisez ensuite le mot de passe administrateur que vous avez défini dans le fichier de configuration à l’étape 3.

      Une fois connecté, vous verrez une liste des extensions PHP obligatoires et facultatives utilisées par SimpleSAMLphp. Vérifiez que vous avez installé toutes les extensions, sauf predis/predis: 

      Toutes les extensions installées 

      S’il manque des composants requis, consultez ce tutoriel et installez les composants manquants avant de passer à autre chose.

      Vous verrez également un lien qui dit Sanity check of your SimpleSAMLphp setup (Contrôle de l’état de santé de votre installation SimpleSAMLphp). Cliquez sur ce lien pour obtenir une liste des contrôles appliqués à votre installation afin de voir s’ils sont réussis.

      Passons à la configuration d’une source d’authentification pour SimpleSAMLphp.

      Étape 4 – Configuration de la source d’authentification

      Maintenant que nous avons installé et configuré SimpleSAMLphp, configurons une source d’authentification afin de pouvoir authentifier les utilisateurs. Nous utiliserons une base de données MySQL pour stocker une liste de noms d’utilisateurs et de mots de passe permettant de s’authentifier.

      Pour commencer, connectez-vous au compte racine MySQL :

      Le mot de passe du compte root MySQL vous sera demandé. Fournissez-le pour pouvoir continuer.

      Ensuite, créez une base de données qui servira de source d’authentification. Nous l’appellerons auth. N’hésitez pas à donner un nom différent au vôtre :

      • CREATE DATABASE auth DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

      Maintenant, créons un utilisateur MySQL séparé pour opérer exclusivement sur notre base de données auth. Du point de vue de la gestion et de la sécurité, c’est une bonne pratique que de créer des bases de données et des comptes à fonction unique. Nous nommerons notre utilisateur authuser.  Exécutez la commande suivante pour créer l’utilisateur, définir un mot de passe et lui donner accès à notre base de données auth. N’oubliez pas de fournir ici un mot de passe fort pour votre nouvel utilisateur de la base de données.

      • GRANT ALL ON auth.* TO 'authuser'@'localhost' IDENTIFIED BY 'your_mysql_auth_user_password';

      Créez maintenant un utilisateur qui sera composé de deux champs : nom d'utilisateur et mot de passe. Pour une sécurité supplémentaire, nous allons utiliser la fonction MySQL AES_ENCRYPT() pour crypter la chaîne de mots de passe afin que nous ne stockions pas les mots de passe en texte clair. Cette fonction crypte une chaîne de caractères et renvoie une chaîne binaire.

      • CREATE TABLE auth.users(username VARCHAR(30), password VARBINARY(30));

      Insérez ensuite trois utilisateurs dans le tableau nouvellement créé. C’est là que nous utiliserons la fonction AES_ENCRYPT() pour crypter les valeurs du champ du mot de passe. Vous devez fournir une chaîne qui sert de clé de cryptage. Veillez à remplacer cela par votre propre chaîne, qui peut être n’importe laquelle tant qu’elle est complexe.

      • INSERT INTO auth.users(username, password) VALUES
      • ('user1', AES_ENCRYPT('user1pass','your_secret_key')),
      • ('user2', AES_ENCRYPT('user2pass','your_secret_key')),
      • ('user3', AES_ENCRYPT('user3pass','your_secret_key'));

      Utilisez la même clé pour chaque utilisateur, et assurez-vous de vous souvenir de la clé afin de pouvoir l’utiliser à nouveau pour créer d’autres utilisateurs à l’avenir. Vous utiliserez également cette clé secrète dans la configuration de SimpleSAMLphp afin de pouvoir décrypter les mots de passe et les comparer avec ceux que les utilisateurs saisissent.

      Nous devons vider les privilèges afin que l’instance actuelle de MySQL soit au courant des récents changements de privilèges que nous avons effectués :

      Sortez de l’invite MySQL en tapant :

      Pour activer la fonctionnalité de fournisseur d’identité dans SimpleSAMLphp, nous devons modifier le fichier/var/simplesamlphp/config/config.php. Plusieurs options sont disponibles, mais comme ce guide se concentre sur le support SAML 2.0, nous voulons permettre à l’option enable.saml20-idp.  Pour ce faire, ouvrez /var/simplesamlphp/config/config.php et activez le support SAML 2.0 : 

      • nano /var/simplesamlphp/config/config.php

      Localisez cette section du fichier et remplacez false par true :

      /var/simplesamlphp/config/config.php

      ...
      'enable.saml20-idp' => true,
      ...
      

      Ensuite, enregistrez le fichier et quittez l’éditeur.

      Maintenant que nous avons activé la fonctionnalité de fournisseur d’identité, nous devons indiquer le module d’authentification à utiliser. Comme nous avons une table d’utilisateurs sur une base de données MySQL, nous allons utiliser le module d’authentification SQL. Ouvrez le fichier de configuration authsources :

      • nano /var/simplesamlphp/config/authsources.php

      Localisez le bloc suivant, qui est commenté :

      /var/simplesamlphp/config/authsources.php

      ...
          /*
          'example-sql' => array(
              'sqlauth:SQL',
              'dsn' => 'pgsql:host=sql.example.org;port=5432;dbname=simplesaml',
              'username' => 'simplesaml',
              'password' => 'secretpassword',
              'query' => 'SELECT uid, givenName, email, eduPersonPrincipalName FROM users WHERE uid = :username AND password = SHA2(CONCAT((SELECT salt FROM users WHERE uid = :username), :password),256);',
          ),
          */
      ...
      

      Ce code définit une connexion à la base de données et une requête que SimpleSAMLphp peut utiliser pour rechercher un utilisateur dans une table de base de données appelée users. Nous devons le décommenter et modifier la requête pour rechercher un utilisateur dans notre table en utilisant la fonction AES_DECRYPT() de MySQL. Nous devrons fournir à la fonction AES_DECRYPT()la même clé que celle utilisée pour crypter les mots de passe dans la requête. 

      Modifiez la section du fichier pour spécifier les détails de connexion à la base de données et la requête :

      /var/simplesamlphp/config/authsources.php

      ...
          'example-sql' => array(
              'sqlauth:SQL',
              'dsn' => 'mysql:host=localhost;port=5432;dbname=auth',
              'username' => 'authuser',
              'password' => 'your_mysql_auth_user_password',
              'query' => 'SELECT username FROM users WHERE username = :username AND AES_DECRYPT(password,"your_secret_key") = :password',
          ),
      ...
      

      Veillez à placer la clé secrète que vous avez indiquée à la place de your_secret_key. 

      Enregistrez et fermez le fichier. Testons notre fournisseur d’identité.

      Étape 5 – Testez le fournisseur d’identité avec la démo de SAML 2.0 SP

      Vous pouvez tester la source d’authentification MySQL que vous venez de mettre en place en naviguant vers l’ onglet Authentification et en cliquant sur le lien Test configured authentication sources​​​ (Tester les sources d’authentification configurées). Une liste des sources d’authentification déjà configurées vous sera présentée.

      La liste des sources d'authentification configurées 

      Cliquez sur l’exemple-sqlcar il s’agit du fournisseur que vous avez configuré à l’étape précédente. Une invite à entrer un nom d’utilisateur et un mot de passe apparaîtra. Entrez l’une des trois combinaisons d’utilisateur et de mot de passe que vous avez insérées dans la table des utilisateurs MySQL. Essayez user1 avec le mot de passe user1pass.

      Si votre tentative est couronnée de succès, vous recevrez la page SAML 2.0 SP Demo Example(Exemple de démo de SAML 2.0 SP) : 

      La page de démonstration réussie 

      Si vous ne pouvez pas vous connecter et que vous savez que le mot de passe est correct, assurez-vous que vous avez utilisé la même clé avec la fonction AES_ENCRYPT() lorsque vous avez créé l’utilisateur, et la fonction AES_DECRYPT() lorsque vous avez recherché l’utilisateur.

      Vous pouvez désormais intégrer SimpleSAMLphp à vos propres applications en suivant les instructions de la Documentation de l’API SimpleSAMLphp. 

      Conclusion

      L’application SimpleSAMLphp est maintenant correctement installée et configurée sur votre VPS Ubuntu 18.04. SimpleSAMLphp permet également une personnalisation poussée de l’interface utilisateur grâce à la thématisation. Vous pouvez vous référer à leur documents thématiques pour en savoir plus à ce sujet. 



      Source link

      Comment utiliser l’extension PHP PDO pour exécuter MySQL en PHP sur Ubuntu 18.04


      L’auteur a choisi Open Sourcing Mental Illness pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      Une transaction MySQL est un groupe de commandes SQL logiquement liées qui sont exécutées dans la base de données comme une seule unité. Les transactions sont utilisées pour faire respecter la conformité ACID ( Atomicité, Cohérence, Isolation et Durabilité) dans une application. Il s’agit d’un ensemble de normes qui régissent la fiabilité des opérations de traitement dans une base de données.

      L’atomicité garantit le succès des opérations connexes ou un échec complet si une erreur se produit. La cohérence garantit la validité des données soumises à la base de données selon une logique commerciale définie. L’isolation est l’exécution correcte de transactions simultanées garantissant que les effets des différents clients se connectant à une base de données n’affectent pas les autres. La durabilité garantit que les transactions logiquement liées restent en permanence dans la base de données.

      Les instructions SQL émises via une transaction doivent soit réussir, soit échouer complètement. Si l’une des requêtes échoue, MySQL annule les modifications et celles-ci ne sont jamais enregistrées dans la base de données.

      Un bon exemple pour comprendre comment fonctionnent les transactions MySQL est un site web de commerce électronique. Lorsqu’un client passe une commande, l’application insère des enregistrements dans plusieurs tableaux, tels que : orders et orders_products, en fonction de la logique commerciale.  Les enregistrements multi-tableaux liés à une seule commande doivent être envoyés de manière atomique à la base de données en tant qu’unité logique unique.

      Un autre cas d’utilisation est celui d’une application bancaire. Lorsqu’un client transfère de l’argent, deux transactions sont envoyées à la base de données. Le compte de l’expéditeur est débité et le compte du destinataire est crédité. Les deux transactions doivent être effectuées simultanément. Si l’une d’elles échoue, la base de données revient à son état initial et aucune modification ne doit être enregistrée sur le disque.

      Dans ce tutoriel, vous utiliserez l’extension PHP PDO, qui fournit une interface permettant de travailler avec des bases de données en PHP, pour effectuer des transactions MySQL sur un serveur Ubuntu 18.04.

      Conditions préalables

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

      Étape 1 — Création d’un exemple de base de données et de tableaux

      Vous allez d’abord créer une base de données type et ajouter quelques tableaux avant de commencer à travailler avec les transactions MySQL. Tout d’abord, connectez-vous à votre serveur MySQL en tant que root :

      Lorsque vous y êtes invité, entrez votre mot de passe MySQL en tant que root et appuyez sur ENTER (ENTRÉE) pour continuer. Ensuite, créez une base de données. Aux fins de ce tutoriel, nous appellerons la base de données sample_store:

      • CREATE DATABASE sample_store;

      Vous verrez le résultat suivant :

      Output

      Query OK, 1 row affected (0.00 sec)

      Créez un utilisateur appelé sample_user pour votre base de données. N’oubliez pas de remplacer PASSWORD par une valeur forte :

      • CREATE USER 'sample_user'@'localhost' IDENTIFIED BY 'PASSWORD';

      Donnez à votre utilisateur tous les privilèges pour la base de données sample_store :

      • GRANT ALL PRIVILEGES ON sample_store.* TO 'sample_user'@'localhost';

      Enfin, rechargez les privilèges MySQL :

      Vous verrez la sortie suivante une fois que vous aurez créé votre utilisateur :

      Output

      Query OK, 0 rows affected (0.01 sec) . . .

      Avec la base de données et l’utilisateur en place, vous pouvez maintenant créer plusieurs tableaux pour montrer comment fonctionnent les transactions MySQL.

      Déconnectez-vous du serveur MySQL :

      Une fois que le système vous a déconnecté, vous verrez le résultat suivant :

      Output

      Bye.

      Ensuite, connectez-vous avec les informations d’identification de l'utilisateur que vous venez de créer :

      • sudo mysql -u sample_user -p

      Entrez le mot de passe de sample_user et appuyez sur ENTER (ENTRÉE) pour continuer.

      Passez à la base de données sample_store pour qu’elle devienne la base de données actuellement sélectionnée :

      Vous verrez la sortie suivante une fois qu’elle sera sélectionnée :

      Output

      Database Changed.

      Ensuite, créez un tableau products :

      • CREATE TABLE products (product_id BIGINT PRIMARY KEY AUTO_INCREMENT, product_name VARCHAR(50), price DOUBLE) ENGINE = InnoDB;

      Cette commande crée un tableau products avec un champ nommé product_id. Vous utilisez un type de données BIGINT qui peut accueillir une valeur importante allant jusqu’à 2^63-1. Vous utilisez ce même champ comme CLÉ PRIMAIRE pour identifier les produits de manière unique. Le mot-clé AUTO_INCREMENT indique à MySQL de générer la valeur numérique suivante lorsque de nouveaux produits sont insérés.

      Le champ product_name est du type VARCHAR qui peut contenir jusqu’à 50 lettres ou chiffres maximum. Pour le prix du produit, vous utilisez un type de données DOUBLE pour tenir compte des formats à virgule flottante dans les prix avec des nombres décimaux.

      Enfin, vous utilisez l’InnoDB comme MOTEUR car il prend confortablement en charge les transactions MySQL contrairement à d’autres moteurs de stockage tels que MyISAM.

      Une fois que vous aurez créé votre tableau products, vous obtiendrez le résultat suivant :

      Output

      Query OK, 0 rows affected (0.02 sec)

      Ensuite, ajoutez des éléments au tableau products en exécutant les commandes suivantes :

      • INSERT INTO products(product_name, price) VALUES ('WINTER COAT','25.50');
      • INSERT INTO products(product_name, price) VALUES ('EMBROIDERED SHIRT','13.90');
      • INSERT INTO products(product_name, price) VALUES ('FASHION SHOES','45.30');
      • INSERT INTO products(product_name, price) VALUES ('PROXIMA TROUSER','39.95');

      Vous verrez une sortie semblable à celle qui suit après chaque opération INSERT :

      Output

      Query OK, 1 row affected (0.02 sec) . . .

      Ensuite, vérifiez que les données ont été ajoutées au tableau products :

      Vous verrez une liste des quatre produits que vous avez insérés :

      Output

      +------------+-------------------+-------+ | product_id | product_name | price | +------------+-------------------+-------+ | 1 | WINTER COAT | 25.5 | | 2 | EMBROIDERED SHIRT | 13.9 | | 3 | FASHION SHOES | 45.3 | | 4 | PROXIMA TROUSER | 39.95 | +------------+-------------------+-------+ 4 rows in set (0.01 sec)

      Ensuite, vous allez créer un tableau customersqui contiendra des informations de base sur les clients :

      • CREATE TABLE customers (customer_id BIGINT PRIMARY KEY AUTO_INCREMENT, customer_name VARCHAR(50) ) ENGINE = InnoDB;

      Comme dans le tableau products, vous utilisez le type de données BIGINT pour le customer_id et cela garantira que le tableau peut supporter un grand nombre de clients, jusqu’à 2^63-1 enregistrements. Le mot-clé AUTO_INCREMENT incrémente la valeur des colonnes une fois que vous avez inséré un nouveau client.

      Comme la colonne customer_name accepte les valeurs alphanumériques, vous utilisez du type de données VARCHAR avec une limite de 50 caractères. Là encore, vous utilisez le MOTEUR de stockage InnoDB pour prendre en charge les transactions.

      Après avoir exécuté la commande précédente pour créer le tableau customers, vous verrez le résultat suivant :

      Output

      Query OK, 0 rows affected (0.02 sec)

      Vous ajouterez trois exemples de clients à la table. Exécutez les commandes suivantes :

      • INSERT INTO customers(customer_name) VALUES ('JOHN DOE');
      • INSERT INTO customers(customer_name) VALUES ('ROE MARY');
      • INSERT INTO customers(customer_name) VALUES ('DOE JANE');

      Une fois que les clients ont été ajoutés, vous verrez un résultat semblable à ce qui suit :

      Output

      Query OK, 1 row affected (0.02 sec) . . .

      Ensuite, vérifiez les données dans le tableau customers :

      Vous verrez une liste des trois clients :

      Output

      +-------------+---------------+ | customer_id | customer_name | +-------------+---------------+ | 1 | JOHN DOE | | 2 | ROE MARY | | 3 | DOE JANE | +-------------+---------------+ 3 rows in set (0.00 sec)

      Ensuite, vous allez créer un tableau orders pour enregistrer les commandes placées par différents clients. Pour créer le tableau orders, exécutez la commande suivante :

      • CREATE TABLE orders (order_id BIGINT AUTO_INCREMENT PRIMARY KEY, order_date DATETIME, customer_id BIGINT, order_total DOUBLE) ENGINE = InnoDB;

      Vous utilisez la colonne order_id comme CLE PRIMAIRE. Le type de données BIGINT vous permet d’enregistrer jusqu’à 2^63-1 commandes et s’incrémentera automatiquement après chaque insertion de commande. Le champ order_date contiendra la date et l’heure réelles de la commande et, par conséquent, vous utilisez le type de données DATETIME.  Le customer_id concerne le tableau customers que vous avez précédemment créé.

      Vous verrez le résultat suivant :

      Output

      Query OK, 0 rows affected (0.02 sec)

      Comme la commande d’un seul client peut contenir plusieurs articles, vous devez créer un tableau orders_products qui contiendra ces informations.

      Pour créer le tableau orders_products, exécutez la commande suivante :

      • CREATE TABLE orders_products (ref_id BIGINT PRIMARY KEY AUTO_INCREMENT, order_id BIGINT, product_id BIGINT, price DOUBLE, quantity BIGINT) ENGINE = InnoDB;

      Vous utilisez le ref_id comme CLÉ PRIMAIRE et celui-ci s’incrémentera automatiquement après chaque insertion d’enregistrement. order_id et product_id correspondent respectivement aux tableaux orders et products. La colonne price est du type de données DOUBLE afin de tenir compte des valeurs flottantes.

      Le moteur de stockage InnoDB doit correspondre aux autres tableaux créés précédemment, car la commande d’un seul client affectera plusieurs tableaux simultanément en utilisant des transactions.

      Votre sortie confirmera la création du tableau :

      Output

      Query OK, 0 rows affected (0.02 sec)

      Vous n’ajouterez aucune donnée aux tableaux orders et orders_products pour l’instant, mais vous le ferez plus tard en utilisant un script PHP qui implémente des transactions MySQL.

      Déconnectez-vous du serveur MySQL :

      Votre schéma de base de données est maintenant complet et vous l’avez rempli avec quelques enregistrements. Vous allez maintenant créer une classe PHP pour gérer les connexions à la base de données et les transactions MySQL.

      Étape 2 — Conception d’une classe PHP pour traiter les transactions MySQL

      Dans cette étape, vous allez créer une classe PHP qui utilisera PDO (PHP Data Objects) pour gérer les transactions MySQL. La classe se connectera à votre base de données MySQL et insèrera des données atomiquement à la base de données.

      Enregistrez le fichier de la classe dans le répertoire racine de votre serveur web Apache. Pour ce faire, créez un fichier DBTransaction.php à l’aide de votre éditeur de texte :

      • sudo nano /var/www/html/DBTransaction.php

      Ensuite, ajoutez le code suivant au fichier. Remplacez PASSWORD par la valeur que vous avez créée à l’étape 1 :

      /var/www/html/DBTransaction.php

      <?php
      
      class DBTransaction
      {
          protected $pdo;
          public $last_insert_id;
      
          public function __construct()
          {
              define('DB_NAME', 'sample_store');
              define('DB_USER', 'sample_user');
              define('DB_PASSWORD', 'PASSWORD');
              define('DB_HOST', 'localhost');
      
              $this->pdo = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
              $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
              $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
          }
      

      Vers le début de la classe DBTransaction, le PDO utilisera les constantes (DB_HOST, DB_NAME, DB_USER, et DB_PASSWORD) pour initialiser et se connecter à la base de données que vous avez créée à l’étape 1.

      Remarque : Comme nous démontrons ici des transactions MySQL à petite échelle, nous avons déclaré les variables de la base de données dans la classe DBTransaction. Dans un grand projet de production, vous devriez normalement créer un fichier de configuration séparé et charger les constantes de la base de données à partir de ce fichier en utilisant une déclaration PHP require_once.

      Ensuite, vous définissez deux attributs pour la classe PDO :

      • ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION : cet attribut indique à PDO de lancer une exception si une erreur est rencontrée. De telles erreurs peuvent être enregistrées pour le débogage.
      • ATTR_EMULATE_PREPARES, false : cette option désactive l’émulation des déclarations préparées et permet au moteur de la base de données MySQL de préparer les déclarations lui-même.

      Ajoutez maintenant le code suivant à votre fichier pour créer les méthodes pour votre classe :

      /var/www/html/DBTransaction.php

      . . .
          public function startTransaction()
          {
              $this->pdo->beginTransaction();
          }
      
          public function insertTransaction($sql, $data)
          {
              $stmt = $this->pdo->prepare($sql);
              $stmt->execute($data);
              $this->last_insert_id = $this->pdo->lastInsertId();
          }
      
          public function submitTransaction()
          {
              try {
                  $this->pdo->commit();
              } catch(PDOException $e) {
                  $this->pdo->rollBack();
                  return false;
              }
      
                return true;
          }
      }
      

      Enregistrez et fermez le fichier en appuyant sur CTRL + X, Y, puis sur ENTER.

      Pour travailler avec les transactions MySQL, vous créez trois méthodes principales dans la classe DBTransaction : startTransaction, insertTransaction et submitTransaction.

      • startTransaction : cette méthode demande à PDO de démarrer une transaction et désactive l’auto-validation jusqu’à ce qu’une commande de validation soit émise.

      • insertTransaction : cette méthode prend deux arguments. La variable $sql contient l’instruction SQL à exécuter tandis que la variable $data est un tableau des données à lier à l’instruction SQL puisque vous utilisez des déclarations préparées. Les données sont transmises sous forme de tableau à la méthode insertTransaction.

      • submitTransaction : Cette méthode valide les modifications apportées à la base de données de manière permanente en lançant une commande commit(). Cependant, s’il y a une erreur et que les transactions rencontrent un problème, la méthode appelle la méthode rollBack() pour remettre la base de données dans son état initial au cas où une exception PDO serait soulevée.

      Votre classe DBTransaction initialise une transaction, prépare les différentes commandes SQL à exécuter, et enfin valide les modifications de la base de données de manière atomique s’il n’y a pas de problème, sinon, la transaction est annulée. De plus, la classe vous permet de récupérer l’enregistrement order_id que vous venez de créer en accédant à la propriété publique last_insert_id.

      La classe DBTransaction est maintenant prête à être appelée et utilisée par n’importe quel code PHP, que vous allez créer ensuite.

      Étape 3 — Création d’un script PHP pour utiliser la classe DBTransaction

      Vous allez créer un script PHP qui implémentera la classe DBTransaction et enverra un groupe de commandes SQL à la base de données MySQL. Vous imiterez le déroulement de la commande d’un client dans un panier d’achat en ligne.

      Ces requêtes SQL affecteront les tableaux orders et orders_products. Votre classe DBTransaction ne devrait permettre de modifier la base de données que si toutes les requêtes sont exécutées sans aucune erreur.  Dans le cas contraire, vous obtiendrez un retour d’erreur et toute tentative de modification sera annulée.

      Vous créez une commande unique pour le client JOHN DOE identifié avec le customer_id 1.La commande du client comporte trois articles différents avec des quantités différentes du tableau products. Votre script PHP prend les données de la commande du client et les soumet dans la classe DBTransaction.

      Créez le fichier orders.php :

      • sudo nano /var/www/html/orders.php

      Ensuite, ajoutez le code suivant au fichier :

      /var/www/html/orders.php

      <?php
      
      require("DBTransaction.php");
      
      $db_host = "database_host";
      $db_name = "database_name";
      $db_user = "database_user";
      $db_password = "PASSWORD";
      
      $customer_id = 2;
      
      $products[] = [
        'product_id' => 1,
        'price' => 25.50,
        'quantity' => 1
      ];
      
      $products[] = [
        'product_id' => 2,
        'price' => 13.90,
        'quantity' => 3
      ];
      
      $products[] = [
        'product_id' => 3,
        'price' => 45.30,
        'quantity' => 2
      ];
      
      $transaction = new DBTransaction($db_host, $db_user, $db_password, $db_name);
      

      Vous avez créé un script PHP qui initialise une instance de la classe DBTransaction que vous avez créée à l’étape 2.

      Dans ce script, vous incluez le fichier DBTransaction.php et vous initialisez la classe DBTransaction. Ensuite, vous préparez un tableau multidimensionnel de tous les produits que le client commande dans le magasin. Vous invoquez également la méthode startTransaction() pour lancer une transaction.

      Ensuite, ajoutez le code suivant pour terminer votre script orders.php :

      /var/www/html/orders.php

      . . .
      $order_query = "insert into orders (order_id, customer_id, order_date, order_total) values(:order_id, :customer_id, :order_date, :order_total)";
      $product_query = "insert into orders_products (order_id, product_id, price, quantity) values(:order_id, :product_id, :price, :quantity)";
      
      $transaction->insertQuery($order_query, [
        'customer_id' => $customer_id,
        'order_date' => "2020-01-11",
        'order_total' => 157.8
      ]);
      
      $order_id = $transaction->last_insert_id;
      
      foreach ($products as $product) {
        $transaction->insertQuery($product_query, [
          'order_id' => $order_id,
          'product_id' => $product['product_id'],
          'price' => $product['price'],
          'quantity' => $product['quantity']
        ]);
      }
      
      $result = $transaction->submit();
      
      if ($result) {
          echo "Records successfully submitted";
      } else {
          echo "There was an error.";
      }
      
      

      Enregistrez et fermez le fichier en appuyant sur CTRL + X, Y, puis ENTER.

      Vous préparez la commande à insérer dans le tableau orders via la méthode insertTransaction. Après cela, vous récupérez la valeur de la propriété publique last_insert_id de la classe DBTransaction et l’utilisez-comme $order_id.

      Une fois que vous avez un $order_id, vous utilisez l’ID unique pour insérer les éléments de la commande du client dans le tableau orders_products.

      Enfin, vous appelez la méthode submitTransaction pour valider l’ensemble des détails de la commande du client dans la base de données s’il n’y a pas de problème. Dans le cas contraire, la méthode de la submitTransaction annulera les tentatives de modification.

      Vous allez maintenant exécuter le script orders.php dans votre navigateur. Exécutez ce qui suit et remplacez your-server-IP par l’adresse IP publique de votre serveur :

      http://your-server-IP/orders.php

      Vous verrez la confirmation que les enregistrements ont été soumis avec succès :

      Sortie PHP de la classe de transactions MySQL

      Votre script PHP fonctionne comme prévu et la commande ainsi que les produits associés ont été soumis à la base de données de manière atomique.

      Vous avez exécuté le fichier orders.php dans une fenêtre du navigateur. Le script a invoqué la classe DBTransaction qui a à son tour soumis les détails des orders (commandes) à la base de données. Dans l’étape suivante, vous allez vérifier si les enregistrements ont été sauvegardés dans les tableaux correspondants de la base de données.

      Étape 4 — Confirmation des entrées dans votre base de données

      Au cours de cette étape, vous vérifierez si la transaction initiée depuis la fenêtre du navigateur pour la commande du client a été enregistrée dans les tableaux de la base de données comme prévu.

      Pour ce faire, connectez-vous à nouveau à votre base de données MySQL :

      • sudo mysql -u sample_user -p

      Entrez le mot de passe du sample_user et appuyez sur ENTER (ENTRÉE) pour continuer.

      Passez à la base de données sample_store :

      Assurez-vous que la base de données est modifiée avant de poursuivre en confirmant la sortie suivante :

      Output

      Database Changed.

      Ensuite, lancez la commande suivante pour récupérer les enregistrements du tableau orders :

      Cela affichera la sortie suivante détaillant la commande du client :

      Output

      +----------+---------------------+-------------+-------------+ | order_id | order_date | customer_id | order_total | +----------+---------------------+-------------+-------------+ | 1 | 2020-01-11 00:00:00 | 2 | 157.8 | +----------+---------------------+-------------+-------------+ 1 row in set (0.00 sec)

      Ensuite, récupérez les enregistrements du tableau orders_products :

      • SELECT * FROM orders_products;

      Vous verrez une sortie semblable à celle qui suit avec une liste de produits de la commande du client :

      Output

      +--------+----------+------------+-------+----------+ | ref_id | order_id | product_id | price | quantity | +--------+----------+------------+-------+----------+ | 1 | 1 | 1 | 25.5 | 1 | | 2 | 1 | 2 | 13.9 | 3 | | 3 | 1 | 3 | 45.3 | 2 | +--------+----------+------------+-------+----------+ 3 rows in set (0.00 sec)

      Le résultat confirme que la transaction a été enregistrée dans la base de données et que la classe DBTransaction de votre assistant fonctionne comme prévu.

      Conclusion

      Dans ce guide, vous avez utilisé le PDO PHP pour travailler avec des transactions MySQL. Bien que cet article ne soit pas exhaustif sur la conception d’un logiciel de commerce électronique, il a fourni un exemple d’utilisation des transactions MySQL dans vos applications.

      Pour en apprendre davantage sur le modèle ACID de MySQL, pensez à consulter le guide InnoDB et le modèle ACID sur le site officiel de MySQL. Consultez notre page de contenu MySQL pour d’autres tutoriels, articles et Questions & Réponses.



      Source link

      Comment utiliser Visual Studio Code pour le développement à distance via le plugin Remote-SSH


      Introduction

      Visual Studio Code est un environnement de développement intégré (IDE) populaire pour les développeurs. Son grand choix de plugins, sa conception minimale et son support cross-platform en font une solution idéale pour les développeurs de tous niveaux. Ce tutoriel met l’accent sur l’utilisation du plugin Remote-SSH pour activer le développement de logiciels à distance. Avec ce plugin, vous pouvez éditer des fichiers sur votre poste de travail local, mais aussi exécuter des tâches de développement telles que l’exécution de programmes, les tests unitaires ou l’analyse statique sur un serveur distant.

      Il existe de nombreuses raisons pour lesquelles cela peut vous être bénéfique. Par exemple, vous pouvez avoir un poste de travail Windows et vouloir développer sur Windows, mais votre code tournera au final sur Linux. Vous pouvez avoir besoin de davantage de mémoire vive ou de puissance de traitement que n’en possède votre machine actuelle, ou vous souhaitez maintenir le code à l’écart de votre machine personnelle en raison d’une politique d’entreprise, ou du désir de préserver votre poste de travail.

      Dans ce tutoriel, vous allez activer le plugin Remote-SSH, configurer Visual Studio Code pour exécuter le code sur le serveur distant, et exécuter le code de votre installation locale de Visual Studio Code sur le serveur distant.

      Conditions préalables

      Pour suivre ce guide, vous aurez besoin des éléments suivants :

      • Une machine de développement locale fonctionnant sous Windows, MacOSX ou Linux. Ce tutoriel ne fonctionnera pas sur les dispositifs ChromeOS.
      • Visual Studio Code, que vous pouvez télécharger et installer depuis le site web officiel.
      • Une paire de clés SSH générée :
      • Un serveur Ubuntu 18.04 configuré en suivant le guide de configuration initiale du serveur Ubuntu 18.04, comprenant un utilisateur non root sudo activé et un pare-feu.

      Étape 1 — Installation du plugin Remote-SSH

      Extensions Marketplace​​​ est l’endroit où vous pouvez télécharger les extensions prises en charge et les extensions tierces pour une variété d’outils et de langages de programmation différents. C’est là que vous allez rechercher le plugin Remote-SSH en vue de l’installer.

      Sur le côté gauche de l’IDE, il existe une rangée verticale de cinq icônes. L’icône du bas, qui ressemble à quatre carrés dans une boîte avec le carré supérieur droit qui explose, est l’icône d’Extensions Marketplace :

      Emplacement de l'icône Extensions Marketplace

      Vous pouvez également accéder à cette section en appuyant sur Ctrl+Shift+X. Lorsque vous ouvrirez cette page, vous verrez des suggestions de plugins à télécharger et à installer.

      Une fois que vous avez ouvert Extensions Marketplace, tapez Remote-SSH dans la barre de recherche d’Extensions Marketplace. Lorsque vous trouvez le plugin, sélectionnez-le et cliquez ensuite sur le bouton vert Install pour installer l’extension.

      Recherche du plugin Remote SSH

      L’extension est maintenant installée. Ensuite, vous allez configurer l’extension afin de pouvoir vous connecter à votre serveur.

      Étape 2 — Configuration du plugin Remote-SSH et connexion à votre serveur

      Maintenant que vous avez installé le plugin, vous pouvez le configurer pour vous connecter à un serveur. Pour ce faire, vous aurez besoin des éléments d’information suivants :

      • L’IP ou le nom d’hôte du serveur.
      • Le nom d’utilisateur avec lequel vous allez vous connecter.
      • La clé privée que vous utiliserez pour authentifier votre utilisateur.

      Vous utiliserez ces informations pour créer un fichier de configuration SSH que Visual Studio Code peut utiliser pour SSH vers le serveur afin de synchroniser les fichiers et d’exécuter le code en votre nom. Vous allez créer cette configuration en utilisant Visual Studio Code.

      Maintenant que vous avez installé le plugin Remote-SSH, vous verrez une petite boîte verte dans le coin en bas à gauche de l’interface Visual Studio Code. Si vous survolez la boîte avec le pointeur de votre souris, la fenêtre contextuelle indiquera Open a remote window. Le bouton ressemble à un signe “supérieur à” situé un peu au-dessous d’un signe “inférieur à” (><), comme l’illustre l’image suivante :

      Bouton vert de l'interface Open a remote window

      Cliquez sur le bouton, et une boîte de dialogue apparaît en haut, au centre. Sélectionnez Remote-SSH : Open Configuration File… dans la liste :

      Selecting Configure SSH in the UI

      L’invite suivante vous demandera quel fichier de configuration vous voulez ouvrir. Si vous êtes sous Windows, vous verrez deux emplacements : un dans votre répertoire utilisateur personnel, et un dans l’emplacement d’installation pour SSH. Vous devez utiliser le fichier dans votre répertoire utilisateur lors de la configuration du serveur.

      Sélectionnez le fichier et votre éditeur ouvrira le fichier config. Ajoutez le code suivant au fichier pour définir la connexion à votre serveur, en remplaçant les sections surlignées par les informations de votre serveur :

      config

      Host my_remote_server
          HostName your_server_ip_or_hostname
          User sammy
          IdentityFile /location/of/your/private/key
      

      Voici comment fonctionne ce fichier de configuration :

      • Host : spécifie un nom pour votre hôte. Cela vous permet d’utiliser un nom ou abrégé au lieu de l’adresse IP complète ou du nom d’hôte lors de la connexion au serveur.
      • HostName : le nom d’hôte réel du serveur, qui est soit une adresse IP, soit un nom de domaine entièrement qualifié.
      • User : l’utilisateur que vous voulez utiliser pour vous connecter.
      • IdentityFile: : le chemin vers votre clé privée SSH. Sur les systèmes Mac et Linux, vous le trouverez dans votre répertoire personnel, dans un répertoire .ssh caché, généralement appelé id_rsa. Si vous êtes sous Windows, vous avez spécifié un emplacement pour enregistrer ce fichier lorsque vous l’avez créé en utilisant putty-gen.

      Spécifiez les valeurs appropriées dans votre fichier et enregistrez le fichier.

      Visual Studio Code est maintenant configuré et prêt à vous connecter à votre serveur. Cliquez sur le bouton vert Open a remote window​​​​​​ dans le coin inférieur gauche et sélectionnez Remote-SSH : Connect to Host…

      Connexion au serveur depuis Visual Studio Code

      Une fois que vous avez fait tout cela, les serveurs disponibles et configurés apparaîtront dans le menu déroulant. Sélectionner le serveur auquel vous voulez vous connecter à partir de cette liste.

      Si c’est la première fois que vous vous connectez à ce serveur depuis votre machine, vous serez probablement invité à utiliser la boîte de dialogue de vérification des empreintes digitales SSH, comme celle qui figure dans l’image suivante :

      Confirmer votre empreinte digitale SSH

      Cela permet de s’assurer que vous vous connectez réellement au serveur auquel vous pensez. Vous pouvez le vérifier en vous connectant manuellement à votre serveur et en exécutant ssh-keygen -l -f /etc/ssh/ssh_host_key.pub pour visualiser l’empreinte digitale du serveur. Si cette empreinte digitale est la même que celle qui vous est présentée dans Visual Studio Code, alors vous vous connectez effectivement au serveur auquel vous pensez, vous pouvez donc cliquer sur Continue.

      Visual Studio Code ouvre par défaut une nouvelle fenêtre lorsqu’une nouvelle connexion est établie. Une nouvelle fenêtre apparaîtra avec l’écran d’accueil. Vous saurez que votre connexion a réussi si vous voyez SSH : your_ip_address_or_hostname dans la boîte verte, située dans le coin inférieur gauche. Cela signifie que Visual Studio Code est connecté et communique avec votre serveur distant.

      Connexion SSH réussie

      Maintenant que vous êtes connecté, vous pouvez exécuter des commandes et du code à partir de votre éditeur.

      Étape 3 — Exécution de code sur le serveur distant

      Le plugin Remote-SSH est configuré, et il est temps d’exécuter du code sur votre machine distante. Ouvrez une fenêtre de terminal en sélectionnant Terminal dans la barre de navigation en haut de la fenêtre Visual Studio et en cliquant sur New Terminal. Vous pouvez également ouvrir un terminal en appuyant sur CTRL+Shift+`. Le terminal qui est ouvert est un terminal sur votre serveur distant, et non un terminal sur votre machine locale.

      Lorsque le terminal s’ouvre, lancez la commande suivante pour afficher l’adresse IP de votre serveur afin de vérifier que vous êtes connecté à votre serveur distant :

      Vous verrez la sortie suivante dans votre terminal :

      Output

      1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000 link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo valid_lft forever preferred_lft forever inet6 ::1/128 scope host valid_lft forever preferred_lft forever 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000 link/ether 16:cb:05:5b:30:f1 brd ff:ff:ff:ff:ff:ff inet your_server_ip brd your_broadcast_address scope global eth0 valid_lft forever preferred_lft forever ...

      Pour tester la capacité d’exécution de code distant, créez un nouveau fichier Python appelé hello.py dans votre éditeur. Lorsque vous êtes connecté à votre serveur distant, tous les fichiers créés par Visual Studio Code sont enregistrés sur ce serveur, et non sur votre machine locale.

      Ajoutez le contenu suivant au fichier :

      hello.py

      print("Hello Sammy!")
      

      Pour exécuter ce programme sur votre serveur, ouvrez un terminal dans Visual Studio Code à partir du menu navigation ou en appuyant sur la séquence de touches CTRL+Shift+`. Comme cette session de terminal est connectée à votre serveur distant, exécutez la commande suivante dans le terminal pour exécuter votre programme hello.py :

      La sortie de votre programme sera affichée.

      Exécuter votre script Python

      Vous pouvez également exécuter le fichier à partir du menu contextuel Debug en sélectionnant Run without Debugging.

      Remarque : Si vous avez des extensions de développement installées dans Visual Studio Code, telle que l’extension Python, vous devrez réinstaller ces extensions sur votre serveur via Extensions Marketplace. Si vous avez déjà installé ces plugins dans Visual Studio Code, lorsque vous les recherchez à nouveau, le Marketplace indiquera Install on SSH: hostname. Faites toujours attention au contexte de développement dans lequel vous vous trouvez, car c’est là que Visual Studio Code installera vos plugins et créera vos fichiers. Si vous essayez d’exécuter votre code sans que ces plugins soient installés, des boîtes de dialogue d’erreur apparaîtront dans le coin inférieur droit de l’écran, vous invitant à les installer sur votre serveur distant. Une fois que vous les aurez installés, vous devrez probablement recharger Visual Studio Code. Lorsque vous le relancerez, il continuera à fonctionner sur le serveur distant sans que vous ayez à vous reconnecter manuellement.

      Conclusion

      Le code Visual Studio est maintenant configuré pour le développement sur un serveur distant utilisant SSH. L’exécution à distance avec un IDE offre de nombreux avantages, notamment la possibilité de tester rapidement le fonctionnement de votre code sur différents systèmes d’exploitation et pour différentes spécifications matérielles. Tant que vous disposez d’une connexion Internet, vous pouvez vous connecter à votre serveur et travailler sur votre code depuis n’importe quel ordinateur, et vous pourrez développer en utilisant un environnement Linux même si vous utilisez Windows comme système d’exploitation principal.



      Source link