One place for hosting & domains

      Comment créer un effet parallaxe avec défilement en pure CSS


      Introduction

      La technologie CSS moderne constitue un outil puissant que vous pouvez utiliser pour créer de nombreuses fonctionnalités d’interface utilisateur (UI) avancées. Auparavant, ces caractéristiques reposaient sur des bibliothèques JavaScript.

      Au cours de ce guide, vous allez configurer quelques lignes de CSS pour créer un effet scrolling parallax sur une page Web. Vous utiliserez des images de placekitten.com comme images de balise d’arrière-plan.

      Une fois que vous aurez fini ce tutoriel, vous aurez une page Web avec un effet parallaxe avec défilement en pure CSS.

      Avertissement : les propriétés expérimentales de CSS utilisées dans cet article ne fonctionnent pas sur tous les navigateurs. Ce projet a été testé et fonctionne sur Chrome. Cette technique ne fonctionne pas correctement avec Firefox, Safari et iOS, en raison de certaines optimisations de ces navigateurs.

      Étape 1 — Création d’un nouveau projet

      Pour cette étape, utilisez la ligne de commande afin de configurer un nouveau dossier de projet et des fichiers. Pour commencer, ouvrez votre terminal et créez un nouveau dossier de projet.

      Saisissez la commande suivante pour créer le dossier de projet :

      Pour cet exercice, appelez le dossier css-parallax. Maintenant, passez dans le dossier css-parallax :

      Ensuite, créez un fichier index.html dans votre dossier css-parallax avec la commande nano suivante :

      Placez l'intégralité du HTML du projet dans ce fichier.

      Au cours de la prochaine étape, vous allez commencer à créer la structure de la page Web.

      Étape 2 — Configuration de la structure de l'application

      Au cours de cette étape, vous allez ajouter le HTML dont vous avez besoin pour créer la structure du projet.

      Ajoutez le code suivant dans votre fichier index.html :

      css-parallax/index.html

      
      <!DOCTYPE html>
      <html lang="en">
        <head>
          <meta charset="UTF-8" />
          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
          <title>CSS Scrolling Parallax</title>
        </head>
        <body></body>
      </html>
      

      Il s'agit de la structure de base de plupart des pages Web qui utilisent HTML.

      Ajoutez le code suivant dans la balise <body> :

      css-parallax/index.html

      
      <body>
      ...
         <main>
            <section class="section parallax bg1">
               <h1>Cute Kitten</h1>
            </section>
            <section class="section static">
               <h1>Boring</h1>
            </section>
            <section class="section parallax bg2">
               <h1>Fluffy Kitten</h1>
            </section>
         </main>
      ...
      </body>
      
      

      Ce code crée trois sections différentes. Deux auront une image en arrière-plan et l'autre aura un arrière-plan statique.

      Au cours des étapes suivantes, vous allez ajouter les styles de chaque section en utilisant les catégories que vous avez ajoutées dans le HTML.

      Étape 3 — Création d'un fichier CSS et ajout du CSS initial

      Au cours de cette étape, vous allez créer un fichier CSS. Ensuite, vous allez ajouter le CSS initial dont vous avez besoin pour formater le site Web et créer l'effet de parallaxe.

      Tout d'abors, créez un fichier styles.css dans votre dossier css-parallax avec la commande nano suivante :

      C'est là que vous allez mettre tout le CSS dont vous avez besoin pour créer l'effet parallaxe avec défilement.

      Ensuite, commencez par la catégorie .wrapper. Ajoutez le code suivant dans votre fichier styles.css :

      css-parallax/styles.css

      .wrapper {
        height: 100vh;
        overflow-x: hidden;
        overflow-y: auto;
        perspective: 2px;
      }
      

      La catégorie .wrapper configure les propriétés de perspective et de défilement sur toute la page.

      Pour que l'effet fonctionne, la hauteur de l'habillage doit être configurée sur une valeur fixe. Vous pouvez utiliser l'unité de visualisation vh configurée sur 100 pour obtenir la pleine hauteur de visualisation à l'écran.

      Lorsque vous dimensionnez les images, une barre de défilement horizontale apparaîtra à l'écran. Donc, vous pouvez la désactiver en ajoutant overflow-x: hidden;. La propriété perspective simule la distance de l'unité de visualisation aux pseudo-éléments que vous allez créer et continuer à transformer dans le CSS.

      Au cours de l'étape suivante, vous allez ajouter plus de CSS pour formater votre page Web.

      Étape 4 — Ajout des styles pour la catégorie .section

      Au cours de cette étape, vous allez ajouter des styles à la catégorie .section.

      À l'intérieur de votre fichier styles.css, ajoutez le code suivant en dessous de la catégorie de l'habillage :

      css-parallax/styles.css

      
      .wrapper {
        height: 100vh;
        overflow-x: hidden;
        perspective: 2px;
      }
      .section { 
        position: relative;
        height: 100vh;
        display: flex;
        align-items: center;
        justify-content: center;
        color: white;
        text-shadow: 0 0 5px #000;
      }
      

      La catégorie .section définit les propriétés de taille, d'affichage et de texte des principales sections.

      Configurez la position sur relative pour que l'enfant .parallax::after puisse être exactement positionné par rapport à l'élément parent .section.

      Chaque section dispose d'une view-height(vh) de 100 pour prendre en charge la pleine hauteur de l'unité de visualisation. Vous pouvez modifier et configurer cette valeur comme bon vous semble pour chaque section.

      Enfin, les autres propriétés de CSS permettent de formater et d'ajouter un style au texte dans chaque section. Elles vous permettent de positionner le texte au centre de chaque section et d'ajouter une couleur : white.

      Ensuite, vous allez ajouter un pseudo-élément et le formater pour créer l'effet parallaxe sur deux des sections de votre HTML.

      Étape 5 — Ajout de styles pour la catégorie .parallax

      Au cours de cette étape, vous allez ajouter des styles à la catégorie .parallax.

      Tout d'abord, vous allez ajouter un pseudo-élément dans la catégorie .parallax à formater.

      Remarque : vous pouvez consulter les docs web de MDN pour en savoir plus sur les pseudo-éléments de CSS.

      Ajoutez le code suivant sous la catégorie .section :

      css-parallax/styles.css

      ...
      
      .section {
        position: relative;
        height: 100vh;
        display: flex;
        align-items: center;
        justify-content: center;
        color: white;
        text-shadow: 0 0 5px #000;
      }
      
      .parallax::after {
        content: " ";
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        transform: translateZ(-1px) scale(1.5);
        background-size: 100%;
        z-index: -1;
      }
      ...
      

      La catégorie .parallax ajoute un pseudo-élément ::after à l'image d'arrière-plan et procède aux transformations nécessaires pour l'effet parallaxe.

      Le pseudo-élément est le dernier enfant de l'élément ayant la catégorie .parallax.

      La première moitié du code affiche et positionne le pseudo-élément. La propriété transform écarte le pseudo-élément de la caméra sur z-index, puis elle le rééchelonne pour remplir l'unité de visualisation.

      Comme le pseudo-élément se trouve plus loin, il semble se déplacer plus lentement.

      Au cours de la prochaine étape, vous allez ajouter les images de l'arrière plan et le style de l'arrière-plan statique.

      Étape 6 — Ajout des images et de l'arrière-plan pour chaque section

      Au cours de cette étape, vous allez ajouter les dernières propriétés de CSS pour intégrer les images d'arrière-plan et la couleur de fond de la section statique.

      Tout d'abord, ajoutez une couleur de fond unie à la section .static en utilisant le code suivant après la catégorie .parallax::after :

      css-parallax/styles.css

      ...
      
      .parallax::after {
        content: " ";
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        transform: translateZ(-1px) scale(1.5);
        background-size: 100%;
        z-index: -1;
      }
      
      .static {
        background: red;
      }
      ...
      

      La catégorie .static ajoute un arrière-plan à la section statique qui n'a pas d'image.

      Les deux sections portant la catégorie .parallax disposent également d'une catégorie supplémentaire qui est différente pour chacune d'elles. Utilisez les classes .bg1 et .bg2 pour ajouter les images d'arrière-plan de chatons.

      Ajoutez le code suivant à la catégorie .static :

      css-parallax/styles.css

      ...
      
      .static {
        background: red;
      }
      .bg1::after {
        background-image: url('https://placekitten.com/g/900/700');
      }
      
      .bg2::after {
        background-image: url('https://placekitten.com/g/800/600');
      }
      
      ...
      

      Les catégories .bg1, .bg2 ajoutent les images d'arrière-plan correspondant à chaque section.

      Les images proviennent du site web placekitten. Il s'agit d'un service qui met à disposition des photos de chatons que vous pouvez utiliser en tant que supports de présentation.

      Maintenant que tout le code de l'effet parallaxe avec défilement est ajouté, vous pouvez le lier à votre fichier styles.css dans votre index.html.

      Étape 7 — Liaison de styles.css et ouverture de index.html dans votre navigateur

      Au cours de cette étape, vous allez lier votre fichier styles.css et ouvrir le projet dans votre navigateur pour voir l'effet parallaxe avec défilement.

      Tout d'abord, ajoutez le code suivant à la balise <head> dans le fichier index.html :

      css-parallax/index.html

       ...
      <head>
        <meta charset="UTF-8" />
        <^>
        <link rel="stylesheet" href="https://www.digitalocean.com/community/tutorials/styles.css" />
        <^>
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>CSS Parallax</title>
      </head>
      
      ...
      

      Maintenant, vous pouvez ouvrir votre fichier index.html dans votre navigateur :

      GIF illustrant l'effet parallaxe avec défilement

      C'est fait, vous avez configuré une page web avec un effet de défilement qui fonctionne. Consultez ce référentiel GitHub pour voir le code complet.

      Conclusion

      Grâce à cet article, vous avez configuré un projet avec un fichier index.html et styles.css et vous disposez maintenant d'une page Web fonctionnelle. Vous y avez ajouté la structure de votre page Web et créé les styles des diverses sections du site.

      Vous pouvez éloigner les images ou l'effet parallaxe que vous utilisez pour qu'ils se déplacent plus lentement. Il vous faudra modifier la quantité de pixels sur perspective et les propriétés transform. Si vous ne souhaitez pas que l'image d'arrière-plan défile, utilisez background-attachment: fixed; au lieu de perspective/translate/scale.



      Source link

      Comprendre les actions asynchrones de Redux avec Redux Thunk


      Introduction

      Par défaut, les actions de Redux sont expédiées de façon synchrone, ce qui pose un problème pour toute application non triviale qui doit communiquer avec une application externe ou effectuer des effets secondaires. Redux permet également au middleware qui se trouve au milieu d’une action d’être distribué et à l’action d’atteindre les réducteurs.

      Il existe deux bibliothèques de middleware très populaires qui prennent en charge les effets spéciaux et les actions asynchrones : Redux Thunk et Redux Saga. Cette publication vous emmène à la découverte de Redux Thunk.

      Thunk est un concept de programmation dans lequel une fonction est utilisée pour retarder l’évaluation/le calcul d’une opération.

      Redux Thunk est un middleware qui vous permet de faire un appel à l’action auprès des créateurs qui renvoie une fonction au lieu d’un objet d’action. Cette fonction reçoit la méthode de distribution du store. Elle permet donc d’envoyer des actions synchrones régulières dans le corps de la fonction une fois que les opérations asynchrones ont été terminées.

      Dans cet article vous allez apprendre à ajouter Redux Thunk et découvrir de quelle manière il peut s’adapter à une application hypothétique de Todo.

      Conditions préalables

      Cet article suppose que vous disposez de certaines connaissances de base sur React et Redux. Vous pouvez consulter cet article si vous débutez avec Redux.

      Ce tutoriel est construit autour d’une hypothétique application de Todo qui est supposée assurer le suivi des tâches à faire et des tâches accomplies. Nous présumons que create-react-app a été utilisée pour générer une nouvelle application React. Cependant, redux, react-redux et axios ont déjà été installés.

      Cet article ne vous donne pas d’informations plus détaillées sur la manière de créer une application de Todo de zéro. Nous la présentons ici comme un paramètre conceptuel pour mettre en avant Redux Thunk.

      Ajout de redux-thunk

      Tout d’abord, utilisez le terminal pour naviguer vers le répertoire de projets et installez le paquet redux-thunk dans votre projet :

      • npm install redux-thunk@2.3.0

      Remarque : Redux Thunk ne dispose que de 14 lignes de code. Consultez la source ici pour en savoir plus sur le fonctionnement en arrière-plan d’un middleware Redux.

      Maintenant, utilisez le middleware pour créer le store de votre application en utilisant applyMiddleware de Redux. Avec une application React intégrant redux et react-redux, votre fichier index.js devrait ressembler à ce qui suit :

      src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import { Provider } from 'react-redux';
      import { createStore, applyMiddleware } from 'redux';
      import thunk from 'redux-thunk';
      import './index.css';
      import rootReducer from './reducers';
      import App from './App';
      import * as serviceWorker from './serviceWorker';
      
      // use applyMiddleware to add the thunk middleware to the store
      const store = createStore(rootReducer, applyMiddleware(thunk));
      
      ReactDOM.render(
        <Provider store={store}>
          <App />
        </Provider>,
        document.getElementById('root')
      );
      

      Maintenant, Redux Thunk a été importé et appliqué dans votre application.

      Utilisation de Redux Thunk dans un exemple d’application

      Redux Thunk est le plus couramment utilisé pour communiquer de manière asynchrone avec une application externe afin de récupérer ou de sauvegarder des données. Redux Thunk vous permet de facilement distribuer des actions qui suivent le cycle de vie d’une requête à une application externe.

      En règle générale, pour créer un nouvel élément de todo, il faut lancer une action pour indiquer qu’une création d’un élément todo a commencé. Ensuite, si l’élément todo est bien créé et renvoyé par le serveur externe, une autre action est distribuée avec le nouvel élément todo. Si une erreur survient et le serveur ne sauvegarde pas le todo, une action accompagnée d’une erreur risque d’être déclenchée.

      Voyons comment nous pourrions le faire avec Redux Thunk.

      Importez et distribuez l’action dans votre composant de conteneur :

      src/containers/AddTodo.js

      import { connect } from 'react-redux';
      import { addTodo } from '../actions';
      import NewTodo from '../components/NewTodo';
      
      const mapDispatchToProps = dispatch => {
        return {
          onAddTodo: todo => {
            dispatch(addTodo(todo));
          }
        };
      };
      
      export default connect(
        null,
        mapDispatchToProps
      )(NewTodo);
      

      L’action utilisera Axios pour envoyer une requête POST au terminal, au niveau de JSONPlaceholder (https://jsonplaceholder.typicode.com/todos) :

      src/actions/index.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from './types';
      
      import axios from 'axios';
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(`https://jsonplaceholder.typicode.com/todos`, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      const addTodoSuccess = todo => ({
        type: ADD_TODO_SUCCESS,
        payload: {
          ...todo
        }
      });
      
      const addTodoStarted = () => ({
        type: ADD_TODO_STARTED
      });
      
      const addTodoFailure = error => ({
        type: ADD_TODO_FAILURE,
        payload: {
          error
        }
      });
      

      Notez que le créateur d’action addTodo renvoie une fonction au lieu de l’objet d’action habituel. Cette fonction reçoit la méthode d’envoi du store.

      À l’intérieur du corps de la fonction, envoyez tout d’abord une action synchrone immédiate au store pour indiquer que vous avez commencé à enregistrer le todo avec l’application externe. Ensuite, vous devez envoyer la requête POST en elle-même au serveur, en utilisant Axios. Si le serveur vous envoie une réponse positive, vous distribuez une action synchrone probante avec les données reçues via la réponse. Mais, si la réponse est un échec, nous distribuons une action synchrone différente avec le message d’erreur.

      Lorsque vous utilisez une API externe, comme JSONPlaceholder dans le cas présent, il est possible qu’il y ait un retard au niveau du réseau. Cependant, si vous travaillez avec un serveur de backend local, il se peut que les réponses du réseau soient trop rapides pour pouvoir constater le retard de réseau qu’un utilisateur réel devrait subir. Vous pouvez donc ajouter un retard artificiel au cours du développement :

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              setTimeout(() => {
                dispatch(addTodoSuccess(res.data));
              }, 2500);
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Pour tester les scénarios d’erreur, vous pouvez lancer une erreur manuellement :

      src/actions/index.js

      // ...
      
      export const addTodo = ({ title, userId }) => {
        return dispatch => {
          dispatch(addTodoStarted());
      
          axios
            .post(ENDPOINT, {
              title,
              userId,
              completed: false
            })
            .then(res => {
              throw new Error('addToDo error!');
              // dispatch(addTodoSuccess(res.data));
            })
            .catch(err => {
              dispatch(addTodoFailure(err.message));
            });
        };
      };
      
      // ...
      

      Pour compléter, voici un exemple de ce à quoi le réducteur de todo pourrait ressembler pour prendre en charge l’intégralité du cycle de vie de la requête :

      src/reducers/todosReducer.js

      import {
        ADD_TODO_SUCCESS,
        ADD_TODO_FAILURE,
        ADD_TODO_STARTED,
        DELETE_TODO
      } from '../actions/types';
      
      const initialState = {
        loading: false,
        todos: [],
        error: null
      };
      
      export default function todosReducer(state = initialState, action) {
        switch (action.type) {
          case ADD_TODO_STARTED:
            return {
              ...state,
              loading: true
            };
          case ADD_TODO_SUCCESS:
            return {
              ...state,
              loading: false,
              error: null,
              todos: [...state.todos, action.payload]
            };
          case ADD_TODO_FAILURE:
            return {
              ...state,
              loading: false,
              error: action.payload.error
            };
          default:
            return state;
        }
      }
      

      Découverte de getState

      Non seulement la méthode de distribution de l’état est reçue, mais la fonction renvoyée par un créateur d’action asynchrone avec Redux Thunk reçoit également la méthode getState du store pour pouvoir lire les valeurs réelles du store :

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          dispatch(addTodoStarted());
      
          console.log('current state:', getState());
      
          // ...
        };
      };
      

      Avec ce qui précède, l’état actuel s’imprimera sur la console.

      Par exemple :

      {loading: true, todos: Array(1), error: null}
      

      Il peut s’avérer utile d’utiliser getState pour gérer les choses différemment en fonction de l’état actuel. Par exemple, si vous souhaitez limiter l’application à quatre éléments de todo à la fois, vous pouvez les renvoyer à partir de la fonction, si l’état contient déjà le nombre maximum d’éléments todo :

      src/actions/index.js

      export const addTodo = ({ title, userId }) => {
        return (dispatch, getState) => {
          const { todos } = getState();
      
          if (todos.length > 4) return;
      
          dispatch(addTodoStarted());
      
          // ...
        };
      };
      

      Compte tenu de ce qui précède, l’app sera limitée à quatre éléments de todo.

      Conclusion

      Au cours de ce tutoriel, vous avez appris à ajouter Redux Thunk à une application React pour pouvoir exécuter des actions de manière asynchrone. Ceci est utile si vous utilisez un store Redux et que vous vous appuyez sur des API externes.

      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

      Comment utiliser SFTP pour transférer des fichiers en toute sécurité avec un serveur distant


      Introduction

      FTP, ou « File Transfer Protocol » (protocole de transfert de fichiers) était une méthode non cryptée populaire utilisée pour transérer des fichiers entre deux systèmes distants.

      SFTP, qui signifie SSH File Transfer Protocol (protocole de transfert de fichiers SSH ou protocole de transfert de fichiers sécurisé) est un protocole distinct intégrant SSH, qui fonctionne de manière similaire mais via une connexion sécurisée. Il présente l’avantage de pouvoir tirer parti d’une connexion sécurisée pour transférer des fichiers et traverser le système de fichiers à la fois sur le système local et sur le système distant.

      Dans la plupart des cas, il est préférable d’utiliser le SFTP au lieu du FTP, en raison de ses fonctionnalités de sécurité sous-jacentes et de sa capacité à se greffer sur une connexion SSH. FTP est un protocole non sécurisé qui ne doit être utilisé que dans certains cas ou sur des réseaux de confiance.

      Bien que le SFTP soit intégré à de nombreux outils graphiques, ce guide vous expliquera de quelle manière l’utiliser via son interface de ligne de commande interactive.

      SFTP utilise le protocole SSH par défaut pour s’authentifier et établir une connexion sécurisée. Pour cette raison, les mêmes méthodes d’authentification que celles présentes dans SSH sont mises à disposition.

      Bien que les mots de passe soient faciles à utiliser et configurés par défaut, nous vous recommandons de créer des clés SSH et de transférer votre clé publique à tous les systèmes auxquels vous devez accéder. Cette méthode est bien plus sécurisée et vous permet de gagner du temps sur le long terme.

      Veuillez vous reporter à ce guide pour configurer des clés SSH et accéder ainsi à votre serveur, si vous ne l’avez pas encore fait.

      Si vous arrivez à vous connecter à la machine en utilisant SSH, cela signifie que vous avez rempli toutes les conditions requises pour gérer les fichiers à l’aide de SFTP. Testez l’accès à SSH à l’aide de la commande suivante :

      • ssh sammy@your_server_ip_or_remote_hostname

      Si cela fonctionne, ressortez en saisissant :

      Désormais, nous pouvons établir une session SFTP en émettant la commande suivante :

      • sftp sammy@your_server_ip_or_remote_hostname

      Votre connexion au système distant sera établie et votre invite se transformera en une invite SFTP.

      Si vous travaillez sur un port SSH personnalisé (et non pas sur le port 22 par défaut), vous pouvez alors ouvrir une session SFTP de la manière suivante  :

      • sftp -oPort=custom_port sammy@your_server_ip_or_remote_hostname

      Ceci établira votre connexion au système distant via le port que vous avez spécifié.

      Obtenir de l'aide dans SFTP

      La commande la plus utile que vous devez apprendre à utiliser en premier est la commande d'aide. Elle vous permet d'accéder à un résumé de l'aide de SFTP. Vous pouvez l'appeler en saisissant l'une ou l'autre des options suivantes dans l'invite :

      ou

      Une liste des commandes disponibles s'affichera :

      Output

      Available commands: bye Quit sftp cd path Change remote directory to 'path' chgrp grp path Change group of file 'path' to 'grp' chmod mode path Change permissions of file 'path' to 'mode' chown own path Change owner of file 'path' to 'own' df [-hi] [path] Display statistics for current directory or filesystem containing 'path' exit Quit sftp get [-Ppr] remote [local] Download file help Display this help text lcd path Change local directory to 'path' . . .

      Nous allons explorer certaines des commandes que vous allez aborder dans les sections suivantes.

      Un certain nombre de commandes qui fonctionnement de la même manière que leurs homologues shell nous permettent de naviguer dans la hiérarchie de fichiers du système distant.

      Tout d'abord, cherchons à savoir dans quel répertoire du système distant nous nous trouvons actuellement. Tout comme dans une session shell type, nous pouvons saisir ce qui suit pour obtenir le répertoire actuel :

      Output

      Remote working directory: /home/demouser

      Nous pouvons consulter le contenu du répertoire actuel du système distant à l'aide d'une autre commande commune :

      Output

      Summary.txt info.html temp.txt testDirectory

      Notez que les commandes de l'interface SFTP ne sont pas similaires aux commandes shell normales et ne sont pas aussi riches en fonctionnalités. Elles permettent cependant d'implémenter certaines des balises optionnelles les plus importantes :

      Output

      drwxr-xr-x 5 demouser demouser 4096 Aug 13 15:11 . drwxr-xr-x 3 root root 4096 Aug 13 15:02 .. -rw------- 1 demouser demouser 5 Aug 13 15:04 .bash_history -rw-r--r-- 1 demouser demouser 220 Aug 13 15:02 .bash_logout -rw-r--r-- 1 demouser demouser 3486 Aug 13 15:02 .bashrc drwx------ 2 demouser demouser 4096 Aug 13 15:04 .cache -rw-r--r-- 1 demouser demouser 675 Aug 13 15:02 .profile . . .

      Pour accéder à un autre répertoire, nous pouvons lancer la commande suivante :

      Maintenant que nous pouvons traverser le système de fichiers distant, qu'en est-il si nous devons accéder à notre système de fichiers local ? Nous pouvons diriger les commandes vers le système de fichiers local en les faisant précéder d'un l pour local.

      Toutes les commandes abordées jusqu'à maintenant disposent d'équivalents en local. Nous pouvons imprimer le répertoire de travail local :

      Output

      Local working directory: /Users/demouser

      Nous pouvons lister le contenu du répertoire actuel sur la machine locale :

      Output

      Desktop local.txt test.html Documents analysis.rtf zebra.html

      Nous pouvons également changer le répertoire avec lequel nous souhaitons interagir sur le système local :

      Transférer des fichiers avec SFTP

      L'utilité de la navigation dans les systèmes de fichiers distants et locaux reste limitée si nous ne pouvons pas transférer des fichiers entre les deux.

      Transférer des fichiers distants vers le système local

      Pour télécharger des fichiers à partir de notre hébergement local, vous pouvez passer la commande suivante :

      Output

      Fetching /home/demouser/remoteFile to remoteFile /home/demouser/remoteFile 100% 37KB 36.8KB/s 00:01

      Comme vous pouvez le voir, par défaut, la commande get télécharge un fichier distant vers un fichier qui porte le même nom sur le système de fichiers local.

      Nous pouvons copier le fichier distant en utilisant un autre nom, en spécifiant le nom par la suite :

      La commande get prend également en charge quelques balises d'option. Par exemple, nous pouvons copier un répertoire et l'intégralité de son contenu en spécifiant l'option récursive suivante :

      Nous pouvons dire au SFTP de maintenir les autorisations et les temps d'accès appropriés en utilisant la balise -P ou -p :

      Transférer des fichiers locaux vers le système distant

      Il est tout aussi facile de transférer des fichiers vers le système distant en utilisant la commande qui s'appelle, à juste titre, « put » :

      Output

      Uploading localFile to /home/demouser/localFile localFile 100% 7607 7.4KB/s 00:00

      Les mêmes balises que celles qui fonctionnent avec get s'appliquent à put. Donc, si vous souhaitez copier un répertoire local entier, vous pouvez lancer la commande suivante :

      Remarque: il existe actuellement un bogue dans les versions d'OpenSSH intégrant les versions actuelles d'Ubuntu (au moins 14.04 à 15.10), ce qui empêche la commande ci-dessus de fonctionner correctement. Une fois la commande ci-dessus lancée pour transférer le contenu vers un serveur en utilisant la version avec bogue d'OpenSSH, l'erreur suivante apparaîtra : Couldn't canonicalise: No such file or directory (Impossible à canonicaliser : pas de fichier ou de répertoire de ce type).

      Pour résoudre ce problème, créez le répertoire de destination tout d'abord du côté distant en saisissant mkdir localDirectory. Ensuite, la commande ci-dessus devrait s'exécuter sans erreur.

      La commande df est un outil pratique, communément utilisé pour télécharger et envoyer des fichiers. Elle fonctionne de la même manière que la version avec ligne de commande. Grâce à elle, vous pouvez vérifier si vous disposez d'assez d'espace pour procéder aux transferts que vous souhaitez effectuer :

      Output

      Size Used Avail (root) %Capacity 19.9GB 1016MB 17.9GB 18.9GB 4%

      Notez qu'il n'existe pas de variation locale de cette commande, mais nous pouvons contourner cela en émettant la commande ! .

      La commande ! nous amène dans un shell local, où nous pouvons exécuter toute commande disponible sur notre système local. Nous pouvons vérifier l'utilisation du disque en saisissant :

      et puis

      Output

      Filesystem Size Used Avail Capacity Mounted on /dev/disk0s2 595Gi 52Gi 544Gi 9% / devfs 181Ki 181Ki 0Bi 100% /dev map -hosts 0Bi 0Bi 0Bi 100% /net map auto_home 0Bi 0Bi 0Bi 100% /home

      Toute autre commande locale fonctionnera comme prévu. Pour revenir à votre session SFTP, saisissez :

      Maintenant, vous devriez voir apparaître l'invite SFTP.

      Manipulations simples de fichiers avec SFTP

      SFTP vous permet d'effectuer le type de maintenance de base sur les fichiers qui vous est utile lorsque vous travaillez avec des hiérarchies de fichiers.

      Par exemple, vous pouvez modifier le propriétaire d'un fichier sur le système distant en utilisant :

      À la différence de la commande chmod du système, vous remarquerez que la commande SFTP n'accepte pas les noms d'utilisateur, mais utilise des UID à la place. Malheureusement, il n'existe aucun moyen facile de connaître l'UID correspondant à partir de l'interface SFTP.

      Vous pourriez contourner le problème avec :

      • get /etc/passwd
      • !less passwd

      Output

      root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/bin/sh bin:x:2:2:bin:/bin:/bin/sh sys:x:3:3:sys:/dev:/bin/sh sync:x:4:65534:sync:/bin:/bin/sync games:x:5:60:games:/usr/games:/bin/sh man:x:6:12:man:/var/cache/man:/bin/sh . . .

      Notez qu'au lieu d'utiliser la commande ! proprement dite, nous l'avons utilisée comme préfixe pour une commande shell locale. Cette méthode fonctionne pour exécuter toute commande disponible sur notre machine locale, et aurait pu être utilisée avec la commande df locale que nous avons abordée précédemment.

      L'UID se trouvera dans la troisième colonne du fichier, délimitée par des deux-points.

      De la même façon, nous pouvons modifier le propriétaire de groupe d'un fichier en utilisant :

      Encore une fois, il n'existe aucun moyen facile d'obtenir une liste des groupes du système distant. Nous pouvons le faire avec la commande suivante :

      • get /etc/group
      • !less group

      Output

      root:x:0: daemon:x:1: bin:x:2: sys:x:3: adm:x:4: tty:x:5: disk:x:6: lp:x:7: . . .

      La troisième colonne contient l'ID du groupe associé au nom de la première colonne. C'est ce que nous voulons.

      Heureusement, la commande chmod fonctionne comme prévu sur le système de fichiers distant :

      Output

      Changing mode on /home/demouser/publicFile

      Il n'existe aucune commande pour manipuler les autorisations des fichiers locaux, mais vous pouvez configurer l'umask local de manière à ce que tous les fichiers copiés sur le système local disposent des autorisations correspondantes.

      Pour cela, vous pouvez utiliser la commande lumask :

      Output

      Local umask: 022

      Maintenant, tous les fichiers réguliers téléchargés (sous réserve que la balise -p ne soit pas utilisée) auront 644 autorisations.

      SFTP vous permet de créer des répertoires sur des systèmes locaux et distants avec lmkdir et mkdir, respectivement. Ces commandes fonctionnent comme prévu.

      Le reste des commandes de fichier cible uniquement le système de fichiers distant :

      Ces commandes répliquent le comportement de base des versions shell. Si vous devez effectuer ces actions sur le système de fichiers local, n'oubliez pas que vous pouvez vous connecter à un shell en lançant la commande suivante :

      Ou exécutez une seule commande sur le système local en faisant précédant la commande d'un ! comme suit :

      Une fois que vous en aurez terminé avec votre session SFTP, utilisez exit ou bye pour mettre fin à la connexion.

      Conclusion

      Bien que SFTP soit un outil simple, il est très utile pour gérer des serveurs et transférer des fichiers entre eux.

      Par exemple, vous pouvez utiliser SFTP pour permettre à certains utilisateurs de transférer des fichiers sans accès SSH. Pour de plus amples informations sur ce processus, veuillez consulter notre tutoriel How To Enable SFTP Without Shell Access (Comment activer le SFTP sans accès au shell).

      Si vous avez l'habitude d'utiliser FTP ou SCP pour effectuer vos transferts, SFTP est un bon compromis pour pouvoir tirer parti des avantages que les deux ont à offrir. Bien qu'il ne soit pas adapté à toute situation, c'est un outil flexible à avoir dans votre répertoire.



      Source link