One place for hosting & domains

      utiliser

      Comment utiliser SSH pour se connecter à un serveur distant


      Introduction

      L’un des outils essentiels à maîtriser en tant qu’administrateur système est le SSH.

      SSH, ou Secure Shell, est un protocole utilisé pour se connecter en toute sécurité à des systèmes distants. C’est le moyen le plus courant d’accéder à des serveurs Linux distants.

      Dans ce guide, nous verrons comment utiliser SSH pour se connecter à un système distant.

      Syntaxe de base

      Pour se connecter à un système distant utilisant SSH, nous utiliserons la commande ssh.  La forme la plus élémentaire de la commande est :

      Le remote_host dans cet exemple est l'adresse IP ou le nom de domaine auquel vous essayez de vous connecter.

      Cette commande suppose que votre nom d'utilisateur sur le système distant est le même que votre nom d'utilisateur sur votre système local.

      Si votre nom d'utilisateur est différent sur le système distant, vous pouvez le spécifier en utilisant cette syntaxe :

      • ssh remote_username@remote_host

      Une fois que vous vous êtes connecté au serveur, il peut vous être demandé de vérifier votre identité en fournissant un mot de passe. Plus tard, nous verrons comment générer des clés à utiliser à la place des mots de passe.

      Pour quitter la session ssh et revenir dans votre session shell locale, tapez :

      SSH fonctionne en connectant un programme client à un serveur ssh, appelé sshd.

      Dans la section précédente, ssh était le programme client. Le serveur ssh fonctionne déjà sur le remote_host que nous avons spécifié.

      Sur votre serveur, le sshd devrait déjà fonctionner. Si ce n'est pas le cas, vous devrez peut-être accéder à votre serveur via une console Web ou une console série locale.

      Le processus nécessaire pour démarrer un serveur ssh dépend de la distribution de Linux que vous utilisez.

      Sur Ubuntu, vous pouvez démarrer le serveur ssh en tapant :

      Cela devrait démarrer le serveur sshd et vous pourrez alors vous connecter à distance.

      Lorsque vous modifiez la configuration de SSH, vous modifiez les paramètres du serveur sshd.

      Dans Ubuntu, le fichier de configuration principal de sshd se trouve à /etc/ssh/sshd_config.

      Sauvegardez la version actuelle de ce fichier avant de l'éditer :

      • sudo cp /etc/ssh/sshd_config{,.bak}

      Ouvrez-le avec un éditeur de texte :

      • sudo nano /etc/ssh/sshd_config

      Il est préférable de laisser de côté la plupart des options de ce dossier. Cependant, il y en a quelques-uns que vous voudrez peut-être examiner :

      /etc/ssh/sshd_config

      Port 22
      

      La déclaration de port précise sur quel port le serveur sshd écoutera les connexions. Par défaut, il s'agit de 22. Vous devriez probablement ne pas toucher à ce paramètre, à moins que vous n'ayez des raisons spécifiques de faire autrement. Si vous **changez de port, nous vous montrerons comment vous connecter au nouveau port par la suite.

      /etc/ssh/sshd_config

      HostKey /etc/ssh/ssh_host_rsa_key
      HostKey /etc/ssh/ssh_host_dsa_key
      HostKey /etc/ssh/ssh_host_ecdsa_key
      

      Les déclarations de clés d'hôtes précisent où chercher les clés d'hôtes globales. Nous discuterons plus tard de ce qu'est une clé d'hôte.

      /etc/ssh/sshd_config

      SyslogFacility AUTH
      LogLevel INFO
      

      Ces deux éléments indiquent le niveau connexion qui devrait avoir lieu.

      Si vous avez des difficultés avec SSH, augmenter le nombre de connexions peut être un bon moyen de découvrir quel est le problème.

      /etc/ssh/sshd_config

      LoginGraceTime 120
      PermitRootLogin yes
      StrictModes yes
      

      Ces paramètres précisent certaines des informations de connexion.

      LoginGraceTime précise combien de secondes pour maintenir la connexion active sans se connecter avec succès.

      Il peut être judicieux de fixer ce temps juste un peu plus élevé que le temps qu'il vous faut pour vous connecter normalement.

      PermitRootLogin sélectionne si le root user est autorisé à se connecter.

      Dans la plupart des cas, il faut passer à no lorsque vous avez créé un compte d'utilisateur qui a accès à des privilèges élevés (via su ou sudo) et peut se connecter via ssh.

      strictModes est un garde de sécurité qui refusera une tentative de connexion si les fichiers d'authentification sont lisibles par tous.

      Cela permet d'éviter les tentatives de connexion lorsque les fichiers de configuration ne sont pas sécurisés.

      /etc/ssh/sshd_config

      X11Forwarding yes
      X11DisplayOffset 10
      

      Ces paramètres configurent une capacité appelée X11 Forwarding. Cela vous permet de visualiser l'environnement graphique (GUI) d'un système distant sur le système local.

      Cette option doit être activée sur le serveur et donnée avec le client SSH lors de la connexion avec l'option -X.

      Après avoir effectué vos modifications, enregistrez et fermez le fichier en tapant CTRL+X et Y, puis ENTER.

      Si vous avez modifié des paramètres dans /etc/ssh/sshd_config, veillez à recharger votre serveur sshd afin de mettre en œuvre vos modifications :

      • sudo systemctl reload ssh

      Vous devez tester vos changements de manière approfondie pour vous assurer qu'ils fonctionnent comme prévu.

      Il peut être judicieux d'avoir quelques séances actives lorsque vous effectuez des changements. Cela vous permettra de revenir sur la configuration si nécessaire.

      S'il est utile de pouvoir se connecter à un système à distance à l'aide de mots de passe, il est bien plus judicieux de mettre en place une authentification par clé.

      L'authentification par clé fonctionne en créant une paire de clés : une clé privée et une clé publique.

      La clé privée se trouve sur la machine du client et est sécurisée et gardée secrète.

      La clé publique peut être donnée à n'importe qui ou placée sur n'importe quel serveur auquel vous souhaitez accéder.

      Lorsque vous tentez de vous connecter à l'aide d'une paire de clés, le serveur utilise la clé publique pour créer un message pour l'ordinateur client qui ne peut être lu qu'avec la clé privée.

      L'ordinateur client renvoie alors la réponse appropriée au serveur et celui-ci saura que le client est légitime.

      Tout ce processus se fait automatiquement après l'installation des clés.

      Les clés SSH doivent être générées sur l'ordinateur duquel vous souhaitez vous connecter**. Il s'agit généralement de votre machine locale.

      Entrez ce qui suit dans la ligne de commande :

      Appuyez sur la touche Entrée pour accepter les valeurs par défaut. Vos clés seront créées à l'adresse ~/.ssh/id_rsa.pub et ~/.ssh/id_rsa.

      Passez dans le répertoire .ssh en tapant :

      Regardez les autorisations des fichiers :

      Output

      -rw-r--r-- 1 demo demo 807 Sep 9 22:15 authorized_keys -rw------- 1 demo demo 1679 Sep 9 23:13 id_rsa -rw-r--r-- 1 demo demo 396 Sep 9 23:13 id_rsa.pub

      Comme vous pouvez le voir, le fichier id_rsa est lisible et accessible en écriture uniquement au propriétaire.  C'est pour cela qu'il doit être gardé secret.

      Le fichier id_rsa.pub, cependant, peut être partagé et dispose de permissions appropriées pour cette activité.

      Si vous avez actuellement un accès par mot de passe à un serveur, vous pouvez y copier votre clé publique en émettant cette commande :

      Cela permettra de démarrer une session SSH. Après que vous ayez entré votre mot de passe, il copiera votre clé publique dans le fichier des clés autorisées du serveur, ce qui vous permettra de vous connecter sans mot de passe la prochaine fois.

      Options côté client

      Il existe un certain nombre d'indicateurs optionnels que vous pouvez sélectionner lorsque vous vous connectez via SSH.

      Certains d'entre eux peuvent être nécessaires pour correspondre aux paramètres de la configuration sshd de l'hôte distant.

      Par exemple, si vous avez changé le numéro de port dans votre sshd, vous devrez faire correspondre ce port côté client en tapant :

      • ssh -p port_number remote_host

      Si vous ne souhaitez exécuter qu'une seule commande sur un système distant, vous pouvez la spécifier après l'hôte comme cela :

      • ssh remote_host command_to_run

      Vous vous connecterez à la machine distante, vous vous authentifierez, et la commande sera exécutée.

      Comme nous l'avons déjà dit, si la transmission X11 est activée sur les deux ordinateurs, vous pouvez accéder à cette fonctionnalité en tapant :

      Si vous disposez des outils appropriés sur votre ordinateur, les programmes de l'environnement graphique que vous utilisez sur le système distant ouvriront désormais leur fenêtre sur votre système local.

      Désactiver l'authentification par mot de passe

      Si vous avez créé des clés SSH, vous pouvez renforcer la sécurité de votre serveur en désactivant l'authentification uniquement par mot de passe. En dehors de la console, la seule façon de se connecter à votre serveur est d'utiliser la clé privée qui se couple avec la clé publique que vous avez installée sur le serveur.

      Avertissement : Avant de procéder à cette étape, assurez-vous que vous avez installé une clé publique pour votre serveur. Sinon, vous serez bloqué à l'extérieur !

      En tant que root ou utilisateur avec des privilèges sudo, ouvrez le fichier de configuration sshd :

      • sudo nano /etc/ssh/sshd_config

      Localisez la ligne qui indique Password Authenticationet la décommenter en supprimant le premier #. Vous pouvez alors changer sa valeur à no :

      /etc/ssh/sshd_config

      PasswordAuthentication no
      

      Deux autres paramètres qui ne devraient pas avoir à être modifiés (à condition que vous n'ayez pas modifié ce fichier auparavant) sont PubkeyAuthentification et ChallengeResponseAuthentification. Elles sont définies par défaut et doivent se lire comme suit :

      /etc/ssh/sshd_config

      PubkeyAuthentication yes
      ChallengeResponseAuthentication no
      

      Après avoir effectué vos modifications, enregistrez et fermez le fichier.

      Vous pouvez maintenant recharger le démon SSH :

      • sudo systemctl reload ssh

      L'authentification par mot de passe devrait maintenant être désactivée, et votre serveur ne devrait être accessible que via l'authentification par clé SSH.

      Conclusion

      Apprendre à s'orienter au sein de SSH en vaut la peine, ne serait-ce que parce c'est un processus de routine.

      Au fur et à mesure que vous utiliserez les différentes options, vous découvrirez des fonctionnalités plus avancées qui peuvent vous faciliter la vie. SSH est resté populaire parce qu'il est sûr, léger et utile dans diverses situations.



      Source link

      Comment utiliser Systemctl pour gérer les services et les unités de Systemd


      Introduction

      systemd est un gestionnaire de systèmes d’initialisation et de systèmes qui est devenu la nouvelle norme pour les distributions de Linux. Étant largement adopté, cela vaut la peine de se familiariser avec systemd car l’administration de serveurs vous sera considérablement plus facile. En apprendre davantage sur les outils et les démons qui composent systemd vous permettra de mieux apprécier la puissance, la flexibilité et les capacités qu’il vous offre ou, tout du moins, de travailler avec un minimum de tracas.

      Au cours de ce guide, nous allons discuter de la commande systemctl, qui est l’outil de gestion essentiel pour contrôler le système d’initialisation. Nous allons voir de quelle la manière vous pouvez gérer les services, vérifier les états, modifier les états du système et travailler avec les fichiers de configuration.

      Notez que, bien que systemd soit devenu le système d’initialisation par défaut de nombreuses distributions Linux, il n’est pas universellement implémenté sur toutes les distributions. Si au cours de ce tutoriel votre terminal déclenche l’erreur bash: systemctl is not installed, il est alors probable que votre machine ait installé un système d’initialisation.

      Gestion de service

      L’objectif fondamental d’un système d’initialisation est d’initialiser les composants qui doivent être démarrés une fois que le noyau Linux est lancé (traditionnellement connus sous le nom de composants « userland »). De plus, le système d’initialisation vous permet de gérer à tout moment les services et les démons du serveur alors que le système est en marche. Dans cette optique, nous allons commencer par certaines des opérations de base de gestion de service.

      Dans systemd, la cible de la plupart des actions sont des « unités », c’est-à-dire des ressources que systemd sait gérer. Les unités sont classées par le type de ressources qu’elles représentent. Leur configuration se fait avec des fichiers que l’on appelle des « fichiers de l’unité ». Vous pouvez déduire le type de chaque unité à l’aide du suffixe qui se trouve à la fin du fichier.

      Pour les tâches de gestion de service, l’unité cible correspondra aux unités de service pour lesquelles les fichiers de l’unité se terminent par le suffixe .service. Cependant, en réalité, pour la plupart des commandes de gestion de service, vous n’avez pas nécessairement besoin du suffixe .service. En effet, systemd est assez intelligent pour savoir que, lorsque vous utilisez les commandes de gestion de service, vous souhaitez probablement travailler sur un service.

      Démarrage et arrêt des services

      Si vous souhaitez démarrer un service systemd en exécutant les instructions qui se trouvent dans le fichier de l’unité du service, utilisez la commande start. Si vous opérez comme un non-root user, vous devrez utiliser sudo car cela affectera l’état du système d’exploitation :

      • sudo systemctl start application.service

      Comme nous l’avons précédemment mentionné, étant donné que systemd sait qu’il doit rechercher les fichiers *.service pour les commandes de gestion de service, il vous suffirait de saisir la commande de la manière suivante :

      • sudo systemctl start application

      Même si, à des fins d’administration générale, vous pouvez utiliser le format ci-dessus, nous allons utiliser le suffixe .service pour le reste des commandes par soucis de clarté afin de définir clairement la cible sur laquelle nous travaillons.

      Pour arrêter un service en cours d’exécution, vous pouvez plutôt utiliser la commande stop :

      • sudo systemctl stop application.service

      Redémarrage et rechargement

      Pour redémarrer un service en cours d’exécution, vous pouvez utiliser la commande restart :

      • sudo systemctl restart application.service

      Si l’application en question est en capacité de recharger ses fichiers de configuration (sans redémarrage), vous pouvez lancer la commande reload pour initier ce processus :

      • sudo systemctl reload application.service

      Si vous ne savez pas si le service intègre la fonctionnalité qui lui permet de recharger sa configuration, vous pouvez lancer la commande reload-or-restart Si disponible, vous rechargerez la configuration en place. Sinon, le service redémarrera pour récupérer la nouvelle configuration :

      • sudo systemctl reload-or-restart application.service

      Activation et désactivation des services

      Les commandes ci-dessus vous seront utiles pour démarrer ou arrêter des services pendant la session en cours. Vous devez les activer pour demander à systemd de lancer automatiquement les services au démarrage.

      Pour lancer un service au démarrage, utilisez la commande enable :

      • sudo systemctl enable application.service

      Cela créera un lien symbolique à partir de la copie du fichier de service du système (généralement dans /lib/systemd/system ou /etc/systemd/system) à l’emplacement du disque où systemd cherche les fichiers de démarrage automatique (généralement /etc/systemd/system/some_target.target.wants. Nous verrons ce qu’est une cible plus tard dans ce guide).

      Pour désactiver le démarrage automatique d’un service, vous pouvez saisir :

      • sudo systemctl disable application.service

      Cela supprimera le lien symbolique indiquant que le service doit être démarré automatiquement.

      N’oubliez pas que l’activation du service ne le déclenche pas pendant la session en cours. Si vous souhaitez démarrer le service et, dans le même temps, l’activer au démarrage, vous devez lancer à la fois la commande start et la commande enable.

      Vérification de l’état des services

      Pour vérifier l’état d’un service sur votre système, vous pouvez utiliser la commande status :

      • systemctl status application.service

      Vous pourrez ainsi consulter l’état des services, la hiérarchie des groupes et les premières lignes du journal.

      Par exemple, lorsque vous souhaitez vérifier l’état d’un serveur Nginx, le résultat peut s’afficher comme suit :

      Output

      ● nginx.service - A high performance web server and a reverse proxy server Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled) Active: active (running) since Tue 2015-01-27 19:41:23 EST; 22h ago Main PID: 495 (nginx) CGroup: /system.slice/nginx.service ├─495 nginx: master process /usr/bin/nginx -g pid /run/nginx.pid; error_log stderr; └─496 nginx: worker process Jan 27 19:41:23 desktop systemd[1]: Starting A high performance web server and a reverse proxy server... Jan 27 19:41:23 desktop systemd[1]: Started A high performance web server and a reverse proxy server.

      Cela vous donne un bon aperçu de l’état actuel de l’application, vous signalant tout problème et toute action à mettre en œuvre.

      Certaines méthodes vous permettent également de contrôler des états spécifiques. Par exemple, si vous souhaitez vérifier si une unité est actuellement active (en cours d’exécution), vous pouvez utiliser la commande is-active :

      • systemctl is-active application.service

      Cela renverra l’état actuel de l’unité, qui est généralement active ou inactive. Si elle est active, le code de sortie affichera « 0 », ce qui simplifie l’analyse dans les scripts shell.

      Pour voir si l’unité est activée, vous pouvez utiliser la commande is-enabled :

      • systemctl is-enabled application.service

      Vous pourrez ainsi voir si le service est enabled ou disabled et le code de sortie sera à nouveau configuré sur « 0 » ou « 1 » en fonction de la réponse à la question de la commande.

      Une troisième vérification consiste à voir si l’état de l’unité indique un échec. Cela indique qu’un problème est survenu au démarrage de l’unité en question :

      • systemctl is-failed application.service

      Cela reverra active si l’exécution se fait correctement ou failed si une erreur survient. Si l’unité est intentionnellement arrêtée, elle peut renvoyer unknown ou inactive. Le statut de sortie « 0 » indique qu’une défaillance est survenue. Le statut de sortie « 1 » indique tout autre statut.

      Présentation générale des états du système

      Jusqu’à présent, les commandes nous ont permis de gérer des services uniques, mais pas vraiment de consulter l’état actuel du système. Il existe un certain nombre de commandes systemctl qui vous donnent ces informations.

      Liste des unités en cours d’utilisation

      Pour avoir une liste de toutes les unités actives que systemd reconnaît, nous pouvons utiliser la commande list-units :

      Cela affichera une liste de toutes les unités considérées comme actives par systemd sur le système. La sortie finale ressemblera à peu près à ceci :

      Output

      UNIT LOAD ACTIVE SUB DESCRIPTION atd.service loaded active running ATD daemon avahi-daemon.service loaded active running Avahi mDNS/DNS-SD Stack dbus.service loaded active running D-Bus System Message Bus dcron.service loaded active running Periodic Command Scheduler dkms.service loaded active exited Dynamic Kernel Modules System getty@tty1.service loaded active running Getty on tty1 . . .

      La sortie affiche les colonnes suivantes :

      • UNIT : le nom de l'unité systemd
      • LOAD : si la configuration de l'unité a été analysée par systemd. La configuration des unités chargées est gardée en mémoire.
      • ACTIVE : un état résumé indiquant si l'unité est active. Il s'agit généralement d'une méthode assez simple d'établir si l'unité a bien démarré ou pas.
      • SUB : il s'agit d'un état de niveau inférieur qui donne des informations plus détaillées sur l'unité. Il varie souvent en fonction du type, de l'état et du mode de fonctionnement réel de l'unité.
      • DESCRIPTION : une courte description textuelle de ce que l'unité est/fait.

      Étant donné que la commande list-units affiche uniquement les unités actives par défaut, toutes les entrées ci-dessus afficheront loaded dans la colonne LOAD et active dans la colonne ACTIVE. Cet affichage correspond en réalité au comportement par défaut de systemctl lorsque vous l'appelez sans commandes supplémentaires. Vous verrez donc la même chose se produire si vous appelez systemctl sans arguments :

      Nous pouvons instruire systemctl de générer des informations différentes en ajoutant des balises supplémentaires. Par exemple, pour consulter toutes les unités que systemd a chargées (ou tente de charger), qu'elles soient actuellement actives ou pas, vous pouvez utiliser la balise --all comme suit :

      • systemctl list-units --all

      Cela affichera toute unité que systemd a chargée ou tenté de charger, quel que soit l'état actuel du système. Certaines unités deviennent inactives après leur exécution et il se peut que certaines autres, celles que systemd a tenté de charger, restent introuvables sur le disque.

      Vous pouvez filtrer ces résultats en utilisant d'autres balises. Par exemple, nous pouvons utiliser la balise --state= pour indiquer les états LOAD, ACTIVE ou SUB que nous souhaitons consulter. Nous allons devoir garder la balise --all pour que systemctl permette l'affichage des unités inactives :

      • systemctl list-units --all --state=inactive

      Un autre filtre est couramment utilisé, le filtre --type=. Nous pouvons indiquer à systemctl d'afficher uniquement le type d'unités qui nous intéresse. Par exemple, pour consulter uniquement les unités de service actives, nous pouvons utiliser :

      • systemctl list-units --type=service

      Liste de tous les fichiers de l'unité

      La commande list-units affiche uniquement les unités que systemd a tentées d'analyser et de charger en mémoire. Étant donné que systemd lira uniquement les unités dont il pense avoir besoin, les unités disponibles sur le système ne seront pas nécessairement toutes répertoriées. Pour voir tous les fichiers de l'unité disponibles au sein des chemins de systemd, notamment ceux que systemd n'a pas tenté de charger, vous pouvez utiliser la commande list-unit-files à la place :

      • systemctl list-unit-files

      Les unités sont des représentations des ressources dont systemd a connaissance. Étant donné que systemd n'a pas nécessairement lu toutes les définitions de l'unité dans cet écran, seules les informations concernant les fichiers en eux-mêmes sont présentées. La sortie a deux colonnes : le fichier de l'unité et l'état.

      Output

      UNIT FILE STATE proc-sys-fs-binfmt_misc.automount static dev-hugepages.mount static dev-mqueue.mount static proc-fs-nfsd.mount static proc-sys-fs-binfmt_misc.mount static sys-fs-fuse-connections.mount static sys-kernel-config.mount static sys-kernel-debug.mount static tmp.mount static var-lib-nfs-rpc_pipefs.mount static org.cups.cupsd.path enabled . . .

      L'état indiquera généralement enabled, disabled, static ou masked. Dans ce contexte, static signifie que le fichier de l'unité ne contient pas de section install, qui sert à activer une unité. De ce fait, ces unités ne peuvent pas être activées. Habituellement, cela signifie que soit l'unité effectue une action unique, soit elle est uniquement utilisée qu'en tant que dépendance d'une autre unité et ne doit pas être exécutée seule.

      Nous allons voir dans un moment ce que masked signifie.

      Gestion de l'unité

      Jusque-là, nous avons travaillé avec les services et affiché des informations sur l'unité et sur les fichiers de l'unité dont systemd a connaissance. Cependant, en utilisant d'autres commandes, nous pouvons trouver des informations plus spécifiques sur les unités.

      Affichage du fichier de l'unité

      Pour afficher le fichier de l'unité que systemd a chargé sur son système, vous pouvez utiliser la commande cat qui a été ajoutée dans la version 209 de systemd). Par exemple, pour voir le fichier de l'unité de démon de planification atd, nous pourrions saisir :

      • systemctl cat atd.service

      Output

      [Unit] Description=ATD daemon [Service] Type=forking ExecStart=/usr/bin/atd [Install] WantedBy=multi-user.target

      On obtient ainsi le fichier de l'unité tel que reconnu par le processus systemd en cours d'exécution. Cela peut s'avérer important si vous avez récemment modifié des fichiers de l'unité ou si vous écrasez certaines options dans un fragment du fichier de l'unité (nous allons couvrir cela plus tard).

      Affichage des dépendances

      Pour voir une arborescence des dépendances de l'unité, vous pouvez utiliser la commande list-dependencies :

      • systemctl list-dependencies sshd.service

      Cela affichera une cartographie hiérarchisée des dépendances qui doivent être traitées afin de démarrer l'unité concernée. Dans ce contexte, les dépendances incluent les unités qui sont soit requises ou souhaitées par les unités au-dessus.

      Output

      sshd.service ├─system.slice └─basic.target ├─microcode.service ├─rhel-autorelabel-mark.service ├─rhel-autorelabel.service ├─rhel-configure.service ├─rhel-dmesg.service ├─rhel-loadmodules.service ├─paths.target ├─slices.target . . .

      Les dépendances récursives s'affichent uniquement pour .target, qui indique les états du système. Pour lister de manière récursive toutes les dépendances, ajoutez la balise --all.

      Pour afficher les dépendances inverses (les unités qui dépendent de l'unité spécifiée), vous pouvez ajouter la balise --reverse à la commande. D'autres balises vous seront utiles : --before et --after. Vous pouvez les utiliser pour afficher les unités qui dépendent de l'unité spécifiée qui a démarré avant et après elles, respectivement.

      Vérification des propriétés de l'unité

      Pour consulter les propriétés de niveau inférieur d'une unité, vous pouvez utiliser la commande show. Elle affichera une liste de propriétés configurées pour l'unité spécifiée en utilisant un format key=value :

      • systemctl show sshd.service

      Output

      Id=sshd.service Names=sshd.service Requires=basic.target Wants=system.slice WantedBy=multi-user.target Conflicts=shutdown.target Before=shutdown.target multi-user.target After=syslog.target network.target auditd.service systemd-journald.socket basic.target system.slice Description=OpenSSH server daemon . . .

      Pour afficher une seule propriété, vous pouvez faire utiliser la balise -p accompagnée du nom de la propriété. Par exemple, pour voir les conflits que l'unité sshd.service a, vous pouvez saisir :

      • systemctl show sshd.service -p Conflicts

      Output

      Conflicts=shutdown.target

      Masquage et affichage des unités

      Dans la section Gestion de service, nous avons vu de quelle manière arrêter ou désactiver un service, mais systemd a également la possibilité de marquer une unité comme étant totalement impossible à démarrer, automatiquement ou manuellement, en la reliant à /dev/null. On dit alors que l'on « masque » l'unité, et il est possible de le faire avec la commande mask :

      • sudo systemctl mask nginx.service

      Tant qu'elle est masquée, tout démarrage automatique ou manuel du service Nginx est impossible.

      Si vous vérifiez la list-unit-files, vous verrez que le service est maintenant répertorié comme étant masqué :

      • systemctl list-unit-files

      Output

      . . . kmod-static-nodes.service static ldconfig.service static mandb.service static messagebus.service static nginx.service masked quotaon.service static rc-local.service static rdisc.service disabled rescue.service static . . .

      Si vous tentez de lancer le service, vous verrez s'afficher le message suivant :

      • sudo systemctl start nginx.service

      Output

      Failed to start nginx.service: Unit nginx.service is masked.

      Pour afficher une unité et rendre son utilisation à nouveau possible, utilisez la commande unmask :

      • sudo systemctl unmask nginx.service

      Cela renverra l'unité à l'état précédent, ce qui lui permettra son démarrage ou son activation.

      Modification des fichiers de l'unité

      Bien que ce tutoriel ne traite pas du format spécifique des fichiers de l'unité, systemctl met à votre disposition des mécanismes intégrés d'édition et de modification des fichiers de l'unité pour vous permettre de faire des réglages. Cette fonctionnalité a été ajoutée dans la version 218 de systemd.

      Par défaut, la commande edit ouvrira le fragment de code du fichier de l'unité concerné :

      • sudo systemctl edit nginx.service

      Il s'agira d'un fichier vierge qui pourra être utilisé pour remplacer ou ajouter des directives à la définition de l'unité. Un répertoire sera créé dans le répertoire /etc/systemd/systemd qui contient le nom de l'unité avec un .d annexé. Par exemple, pour le nginx.service, un répertoire appelé nginx.service.d sera créé.

      Au sein de ce répertoire, un fragment de code appelé override.conf sera créé. Une fois l'unité chargée, systemd fusionnera, en mémoire, le fragment de code de remplacement avec le fichier de l'unité dans son intégralité. Les directives du fragment de code auront la priorité sur celles qui se trouvent dans le fichier de l'unité d'origine.

      Si vous souhaitez modifier l'intégralité du fichier de l'unité au lieu de créer un fragment de code, vous pouvez passer la balise --full.

      • sudo systemctl edit --full nginx.service

      Cela chargera le fichier de l'unité actuelle dans l'éditeur dans lequel vous pouvez le modifier. Lorsque l'éditeur se ferme, le fichier modifié sera écrit dans /etc/systemd/system, ce qui aura la priorité sur la définition de l'unité du système (qui se trouve généralement dans /lib/systemd/system).

      Pour supprimer tous les ajouts que vous avez effectués, vous pouvez supprimer soit le répertoire de configuration de l'unité .d ou le fichier de service modifié de /etc/systemd/system. Par exemple, pour supprimer un fragment de code, nous pourrions saisir :

      • sudo rm -r /etc/systemd/system/nginx.service.d

      Pour supprimer un fichier complet de l'unité modifié, il faudrait entrer :

      • sudo rm /etc/systemd/system/nginx.service

      Après avoir supprimé le fichier ou le répertoire, vous devez recharger le processus systemd pour qu'il ne tente plus de référencer ces fichiers et réutilise les copies du système. Vous pouvez le faire en tapant :

      • sudo systemctl daemon-reload

      Réglage de l'état du système (niveau d'exécution) avec des cibles

      Les cibles sont des fichiers spéciaux de l'unité qui décrivent un état ou un point de synchronisation du système. Comme avec les autres unités, les fichiers qui définissent des cibles peuvent être identifiés par leur suffixe, dans ce cas .target. Seules, les cibles ne font pas grand-chose, mais elles permettent de regrouper d'autres unités ensemble.

      Vous pouvez les utiliser pour mettre le système dans certains états, tout comme les autres systèmes d'initialisation utilisent les niveaux d'exécution. Elles servent de référence lorsque certaines fonctions sont disponibles. Elles vous permettent ainsi de spécifier l'état souhaité au lieu d'avoir à spécifier les unités individuellement pour produire cet état.

      Par exemple, il existe un swap.target qui est utilisé pour indiquer que le swap est prêt à être utilisé. Les unités qui font partie de ce processus peuvent se synchroniser avec cette cible en indiquant dans leur configuration qu'elles sont WantedBy= ou RequiredBy= le swap.target. Les unités qui nécessitent la disponibilité d'un swap peuvent spécifier cette condition en utilisant les spécifications Wants=, Requires=, et After= pour indiquer la nature de leur relation.

      Obtention et configuration de la cible par défaut

      Le processus systemd a une cible par défaut qu'il utilise au lancement du système. En satisfaisant la cascade des dépendances de cette cible unique, le système est amené à l'état souhaité. Pour trouver la cible par défaut de votre système, saisissez :

      Output

      multi-user.target

      Au besoin, pour configurer une autre cible par défaut, vous pouvez utiliser le set-default. Par exemple, si vous avez installé un bureau graphique et que vous souhaitez que le système s'y lance par défaut, vous pouvez modifier votre cible par défaut en conséquence :

      • sudo systemctl set-default graphical.target

      Liste des cibles disponibles

      Vous pouvez obtenir une liste des cibles disponibles sur votre système en saisissant :

      • systemctl list-unit-files --type=target

      Contrairement aux niveaux d'exécution, plusieurs cibles peuvent être actives à la fois. Une cible active indique que systemd a tenté de lancer toutes les unités liées à la cible et n'a pas encore réessayé de les détruire. Pour voir toutes les cibles actives, entrez :

      • systemctl list-units --type=target

      Isolation des cibles

      Il est possible de lancer toutes les unités associées à une cible et d'arrêter toutes celles qui ne font pas partie de l'arborescence de dépendance. La commande dont nous avons besoin pour cela s'appelle, comme il se doit, isolate. Le processus est similaire à celui qui permet de changer le niveau d'exécution sur les autres systèmes d'initialisation.

      Par exemple, si vous opérez dans un environnement graphique dans lequel graphical.target est active, vous pouvez arrêter le système graphique et mettre le système dans un état de ligne de commande multi-utilisateur en isolant le multi-user.target. Étant donné que graphical.target dépend de multi-user.target, mais pas l'inverse, toutes les unités graphiques seront arrêtées.

      Il est conseillé de consulter les dépendances de la cible que vous isolez avant d'effectuer cette procédure afin de s'assurer de ne pas arrêter les services essentiels :

      • systemctl list-dependencies multi-user.target

      Une fois satisfait des unités qui seront restées actives, vous pouvez isoler la cible en saisissant le texte suivant :

      • sudo systemctl isolate multi-user.target

      Utilisation de raccourcis pour les événements importants

      Il existe des cibles définies pour les événements importants comme la mise à l'arrêt ou le redémarrage. Cependant, systemctl intègre également quelques raccourcis qui ajoutent quelques fonctionnalités supplémentaires.

      Par exemple, pour mettre le système en mode sauvetage (utilisateur unique), vous pouvez utiliser la commande rescue au lieu de isolate rescue.target :

      Cela permettra d'avoir une fonctionnalité supplémentaire qui avertira tous les utilisateurs connectés de l'événement.

      Pour arrêter le système, vous pouvez utiliser la commande halt :

      Pour lancer un arrêt complet, vous pouvez utiliser la commande poweroff :

      Vous pouvez déclencher un redémarrage avec la commande reboot :

      Ces fonctionnalités avertiront les utilisateurs que l'événement est en cours, ce qui ne se fera pas en exécutant ou isolant uniquement la cible. Notez que la plupart des machines relieront les commandes les plus courtes et les plus classiques de ces opérations afin qu'elles fonctionnent correctement avec systemd.

      Par exemple, pour redémarrer le système, vous pouvez généralement taper :

      Conclusion

      Maintenant, vous devriez vous être familiarisé avec certaines des capacités de base de la commande systemctl qui vous permettent d'interagir avec votre instance systemd et de la contrôler. L'utilitaire systemctl sera votre principal point d'interaction pour gérer l'état des services et l'état du système.

      Bien que systemctl fonctionne principalement avec le processus de base systemd, il existe d'autres composants de l'écosystème systemd qui sont contrôlés par d'autres utilitaires . D'autres capacités, comme la gestion des journaux et les sessions utilisateur, sont traitées par des démons et des utilitaires de gestion distincts (journald/journalctl et (logind/loginctl respectivement). Prenez le temps de vous familiariser avec les autres outils et démons pour que la gestion soit plus facile.



      Source link

      Comment utiliser le routage avec React Navigation dans React Native


      Introduction

      React Navigation est une bibliothèque populaire pour le routage et la navigation dans une application React Native.

      Cette bibliothèque aide à résoudre le problème de la navigation entre plusieurs écrans et du partage des données entre eux.

      À la fin de ce tutoriel, vous disposerez d’un réseau social rudimentaire. Il affichera le nombre de connexions dont dispose un utilisateur et fournira un moyen de se connecter avec des amis supplémentaires. Vous utiliserez cet exemple d’application pour découvrir comment naviguer dans les écrans d’applications mobiles en utilisant react-navigation.

      Conditions préalables

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

      Remarque : Si vous avez travaillé avec react-navigation auparavant, vous pourriez rencontrer certaines différences. Vous pouvez consulter la documentation pour les guides pour migrer de 3.x et migrer de 4.x.

      Ce tutoriel a été vérifié avec Node v14.7.0, npm v6.14.7, react v16.13.1, react-native v0.63.2, @react-navigation/native v5.7.3 et @react-navigation/stack v5.9.0.

      Étape 1 – Création d’une nouvelle application React Native

      Tout d’abord, créez une nouvelle application React Native en entrant la commande suivante dans votre terminal :

      • npx react-native init MySocialNetwork --version 0.63.2

      Ensuite, naviguez vers le nouveau répertoire :

      Et lancez l'application pour iOS :

      Ou alors, pour Android :

      Note : Si vous rencontrez des problèmes, vous devrez peut-être consulter Résolution de problèmes pour React Native CLI.

      Cela permettra de créer un projet squelette pour vous. Il ne ressemble pas beaucoup à un réseau social pour l'instant. Réglons ça.

      Ouvrez App.js :

      Remplacez le contenu d’App.js avec le code suivant pour afficher un message de bienvenue :

      App.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class App extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Welcome to MySocialNetwork!</Text>
            </View>
          );
        }
      }
      
      const styles = StyleSheet.create({
        container: {
          flex: 1,
          backgroundColor: '#fff',
          alignItems: 'center',
          justifyContent: 'center',
        },
      });
      
      export default App;
      

      Sauvegardez le fichier. Maintenant, lorsque vous exécutez l'application, un Welcome to MySocialNetwork! MySocialNetwork! apparaîtra dans votre simulateur.

      Dans l'étape suivante, vous ajouterez d'autres écrans à votre application.

      Étape 2 - Création d'un HomeScreen et FriendsScreen

      Actuellement, vous disposez d'un seul écran affichant un message de bienvenue. Au cours de cette étape, vous créerez les deux écrans de votre application : HomeScreen et FriendsScreen.

      HomeScreen

      Votre application aura besoin d'un HomeScreen. Le HomeScreen affichera le nombre d'amis déjà présents dans votre réseau.

      Prenez le code d’App.js et ajoutez-le à un nouveau fichier appelé HomeScreen.js :

      Ouvrez HomeScreen.js:

      Modifiez HomeScreen.js pour utiliser HomeScreen au lieu d’App :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default HomeScreen;
      

      Ce code produira un message de remplacement You have (undefined) friends. Vous fournirez une valeur plus tard.

      FriendsScreen

      Votre application aura également besoin d'un FriendsScreen. Sur le FriendsScreen, vous pourrez ajouter de nouveaux amis.

      Prenez le code de App.js et ajoutez-le à un nouveau fichier appelé FriendsScreen.js :

      • cp App.js FriendsScreen.js

      Ouvrez FriendsScreen.js :

      Modifiez FriendsScreen.js pour utiliser FriendsScreen au lieu d’App :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
            </View>
          );
        }
      }
      
      // ...
      
      export default FriendsScreen;
      

      Ce code produira un Add friends here! here!

      À ce stade, vous avez un HomeScreen et FriendsScreen. Cependant, il n'y a pas moyen de naviguer entre eux. Vous développerez cette fonctionnalité au cours de la prochaine étape.

      Étape 3 - Utilisation des StackNavigator avec React Navigation

      Pour naviguer entre les écrans, vous utiliserez un StackNavigator. Un StackNavigator fonctionne exactement comme une pile d'appels. Chaque écran vers lequel vous naviguez est poussé vers le haut de la pile. Chaque fois que vous appuyez sur le bouton Retour, les écrans se détachent du haut de la pile.

      Tout d'abord, installez @react-navigation/native :

      • npm install @react-navigation/native@5.7.3

      Ensuite, installez @react-navigation/stack et ses dépendances :

      • npm install @react-navigation/stack@5.9.0 @react-native-community/masked-view@0.1.10 react-native-screens@2.10.1 react-native-safe-area-context@3.1.4 react-native-gesture-handler@1.7.0

      Remarque : Si vous développez pour iOS, vous pouvez avoir besoin de naviguer vers le répertoireios et exécuter pod install.

      Ensuite, revisitez App.js :

      Ajoutez NavigationContainer et createStackNavigator à App.js :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      
      const Stack = createStackNavigator();
      

      Ensuite, remplacez le contenu de render :

      App.js

      // ...
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Nichée à l'intérieur <Stack.Navigator>, ajoutez le HomeScreen :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Ce code crée une très petite pile pour votre navigateur avec un seul écran : HomeScreen.

      Nichée à l'intérieur <Stack.Navigator>, ajoutez le FriendsScreen :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import HomeScreen from './HomeScreen';
      import FriendsScreen from './FriendsScreen';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        render() {
          return (
            <NavigationContainer>
              <Stack.Navigator>
                <Stack.Screen
                  name="Home"
                  component={HomeScreen}
                />
                <Stack.Screen
                  name="Friends"
                  component={FriendsScreen}
                />
              </Stack.Navigator>
            </NavigationContainer>
          );
        }
      }
      
      // ...
      

      Ce code ajoute le FriendsScreen au navigateur.

      Remarque : Cela diffère de la façon dont createStackNavigator a été utilisé dans les versions précédentes de React Navigation.

      Maintenant, le navigateur est conscient de vos deux écrans.

      Ajouter des boutons à HomeScreen et FriendsScreen

      Enfin, ajoutez des boutons pour vous déplacer entre vos deux écrans.

      Dans HomeScreen.js, ajoutez le code suivant :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class HomeScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have (undefined) friends.</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Dans FriendsScreen.js, ajoutez le code suivant :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      
      class FriendsScreen extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      
      // ...
      

      Parlons de this.props.navigation. Tant que votre écran est inclus dans le StackNavigatorIl hérite automatiquement de nombreux accessoires utiles de la navigation objet. Dans ce cas, vous avez utilisé navigate pour passer à une autre page.

      HomeScreen et FriendsScreen

      Si vous ouvrez maintenant votre simulateur, vous pouvez naviguer entre le HomeScreen et le FriendsScreen.

      Étape 4 - Utilisation de Context pour transmettre des données à d'autres écrans

      Dans cette étape, vous allez créer un ensemble d'amis possibles - Alice, Bob et Sammy - et une série vide d'amis actuels. Vous créerez également une fonctionnalité permettant à l'utilisateur d'ajouter des amis possibles à ses amis actuels.

      Ouvrez App.js : 

      Ajoutez possibleFriends et currentFriends à l'état du composant :

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        // ...
      }
      
      // ...
      

      Ensuite, ajoutez une fonction permettant de déplacer un ami éventuel dans la liste des amis actuels :

      App.js

      // ...
      
      class App extends React.Component {
        constructor(props) {
          super(props)
          this.state = {
            possibleFriends: [
              'Alice',
              'Bob',
              'Sammy',
            ],
            currentFriends: [],
          }
        }
      
        addFriend = (index) => {
          const {
            currentFriends,
            possibleFriends,
          } = this.state
      
          // Pull friend out of possibleFriends
          const addedFriend = possibleFriends.splice(index, 1)
      
          // And put friend in currentFriends
          currentFriends.push(addedFriend)
      
          // Finally, update the app state
          this.setState({
            currentFriends,
            possibleFriends,
          })
        }
      
        // ...
      }
      
      // ...
      

      À ce stade, vous avez terminé la construction de la fonctionnalité permettant d'ajouter des amis.

      Ajouter FriendsContext à App

      Vous pouvez maintenant ajouter des amis dans App.jsmais vous voudrez les ajouter à FriendsScreen.js et les faire afficher dans HomeScreen.js. Comme ce projet est construit avec React, vous pouvez injecter cette fonctionnalité dans vos écrans avec context.

      Note : Dans les versions précédentes de React Navigation, il était possible d'utiliser screenProps pour partager les données entre les écrans. Dans la version actuelle de React Navigation, il est recommandé d'utiliser React Context pour partager les données entre les écrans.

      Pour éviter une référence circulaire, vous voudrez un nouveau fichier FriendsContext :

      Exportez FriendsContext :

      FriendsContext

      import React from 'react';
      
      export const FriendsContext = React.createContext();
      

      Ouvrez App.js : 

      Ajoutez le FriendsContext :

      App.js

      import 'react-native-gesture-handler';
      import React from 'react';
      import { StyleSheet } from 'react-native';
      import { NavigationContainer } from '@react-navigation/native';
      import { createStackNavigator } from '@react-navigation/stack';
      import { FriendsContext } from './FriendsContext';
      import Home from './Home';
      import Friends from './Friends';
      
      const Stack = createStackNavigator();
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider>
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Ce code établit FriendsContext comme nouvel objet Context et enveloppe le NavigationContainer dans un Context.Provider afin que tous les enfants de l'arbre des composants puissent s'abonner aux changements de contexte.

      Puisque vous n'utilisez plus View ou Text, il est possible de supprimer ces importations de react-native.

      Vous devrez fournir une valeur pour rendre les données accessibles aux consommateurs :

      App.js

      // ...
      
      class App extends React.Component {
        // ...
      
        render() {
          return (
            <FriendsContext.Provider
              value={
                {
                  currentFriends: this.state.currentFriends,
                  possibleFriends: this.state.possibleFriends,
                  addFriend: this.addFriend
                }
              }
            >
              <NavigationContainer>
                <Stack.Navigator>
                  <Stack.Screen
                    name="Home"
                    component={Home}
                  />
                  <Stack.Screen
                    name="Friends"
                    component={Friends}
                  />
                </Stack.Navigator>
              </NavigationContainer>
            </FriendsContext.Provider>
          );
        }
      }
      
      // ...
      

      Cela permettra à la HomeScreen et FriendsScreen de référencer tout changement de contexte currentFriends et possibleFriends.

      Vous pouvez maintenant travailler sur le référencement du contexte dans vos écrans.

      Ajouter FriendsContext à HomeScreen

      Dans cette étape, vous configurerez l'application pour afficher le nombre actuel d'amis.

      Ouvrez HomeScreen.js :

      Et ajoutez le FriendsContext :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class HomeScreen extends React.Component {
        // ...
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Ce code établit un Classe.contexteType. Vous pouvez maintenant accéder au contexte dans vos écrans.

      Par exemple, faisons en sorte que votre HomeScreen affiche combien de currentFriends vous avez :

      HomeScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Home extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>You have { this.context.currentFriends.length } friends!</Text>
      
              <Button
                title="Add some friends"
                onPress={() =>
                  this.props.navigation.navigate('Friends')
                }
              />
            </View>
          );
        }
      }
      HomeScreen.contextType = FriendsContext;
      
      // ...
      

      Si vous ouvrez à nouveau votre application dans le simulateur et que vous visualisez le HomeScreenvous verrez le message : You have 0 friends!

      Ajoutez FriendsContext à FriendsScreen

      Dans cette étape, vous configurerez l'application pour afficher les amis possibles et fournir des boutons pour les ajouter aux amis actuels.

      Ensuite, ouvrez FriendsScreen.js :

      Et ajoutez le FriendsContext :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class FriendsScreen extends React.Component {
        // ...
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Ce code établit un Class.contextType.

      Maintenant, créez un bouton pour ajouter des amis dans FriendsScreen.js :

      FriendsScreen.js

      import React from 'react';
      import { StyleSheet, Text, View, Button } from 'react-native';
      import { FriendsContext } from './FriendsContext';
      
      class Friends extends React.Component {
        render() {
          return (
            <View style={styles.container}>
              <Text>Add friends here!</Text>
      
              {
                this.context.possibleFriends.map((friend, index) => (
                  <Button
                    key={ friend }
                    title={ `Add ${ friend }` }
                    onPress={() =>
                      this.context.addFriend(index)
                    }
                  />
                ))
              }
      
              <Button
                title="Back to home"
                onPress={() =>
                  this.props.navigation.navigate('Home')
                }
              />
            </View>
          );
        }
      }
      FriendsScreen.contextType = FriendsContext;
      
      // ...
      

      Si vous ouvrez à nouveau votre application dans le simulateur et que vous visualisez le FriendsScreen, vous verrez une liste d'amis à ajouter.

      HomeScreen avec 0 currentFriends et FriendsScreen avec 3 possibleFriends

      Si vous visitez le FriendsScreen et cliquez sur le bouton pour ajouter des amis, vous verrez la liste des possibleFriends diminuer. Si vous visitez le HomeScreen, vous verrez le nombre d'amis augmenter.

      Vous pouvez désormais naviguer entre les écrans et partager des données entre eux.

      Conclusion

      Dans ce tutoriel, vous avez créé un exemple d'application React Native avec plusieurs écrans. En utilisant React Navigation, vous avez imaginé un moyen de naviguer entre les écrans. En utilisant React Context, vous avez développé un moyen de partager des données entre les écrans.

      L'ensemble du code source de ce tutoriel est disponible sur GitHub.

      Si vous souhaitez approfondir votre connaissance de React Navigation, consultez leur documentation.

      React Navigation n'est pas la seule solution de routage et de navigation. Il y a aussi React Native Navigation, React Native Router Fluxet React Router Native.

      Si vous souhaitez en savoir plus sur React, consultez notre série Comment coder dans React.js ou consultez notre page thématique React pour des exercices et des projets de programmation.



      Source link