One place for hosting & domains

      Comment surveiller les annonces et les itinéraires BGP en utilisant BGPalerter sur Ubuntu 18.04


      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      BGP (Border Gateway Protocol) est l’un des principaux protocoles utilisés pour le routage des paquets sur Internet, de sorte que lorsqu’il se trompe, des pannes importantes peuvent se produire. Par exemple, en 2019, un petit FAI a effectué une mauvaise configuration de BGP qui s’est malheureusement propagée en amont et a mis hors ligne une grande partie de Cloudflare et d’AWS pendant plus d’une heure. De plus, un an plus tôt, un détournement du BGP avait eu lieu afin d’intercepter le trafic vers un fournisseur bien connu de portefeuille de crypto-monnaie et de voler les fonds de clients peu méfiants.

      BGPalerter est un outil de surveillance open source du réseau BGP qui peut fournir des alertes en temps réel sur l’activité du BGP, y compris la visibilité des itinéraires et l’annonce de nouveaux itinéraires, ainsi que sur les activités potentiellement néfastes telles que les détournements ou les fuites d’itinéraires. BGPalerter ingère automatiquement les informations de routage réseau disponibles au public, ce qui signifie qu’il n’a pas besoin d’avoir un niveau d’accès privilégié ou d’intégration dans le(s) réseau(x) que vous souhaitez surveiller.

      Remarque : BGPalerter ingère automatiquement les informations de routage de réseau disponibles au public, ce qui signifie qu’il n’a pas besoin d’avoir un niveau d’accès privilégié ou d’intégration dans le(s) réseau(x) que vous souhaitez surveiller. Tous les contrôles sont entièrement conformes à la loi sur l’utilisation abusive de l’informatique, à la loi sur la fraude et les abus informatiques et à d’autres lois similaires. Toutefois, il est recommandé de divulguer de manière responsable toute constatation pertinente au gestionnaire de réseau concerné.

      Dans ce tutoriel, vous allez installer et configurer BGPalerter pour surveiller vos réseaux importants afin de détecter toute activité potentiellement suspecte.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin de :

      • Un serveur Ubuntu 18.04 configuré en suivant la Configuration initiale du serveur avec Ubuntu 18.04, y compris un utilisateur sudo non root.

      • Un ou plusieurs réseaux ou appareils que vous souhaitez surveiller, par exemple :

        • Un serveur dont vous êtes chargé de la maintenance
        • Le réseau de votre entreprise
        • Votre FAI local

      Pour chaque appareil ou réseau, vous devrez identifier soit l’adresse IP individuelle, soit la plage d’adresses IP, soit le numéro du système autonome dont il fait partie. Cette opération est couverte dans l’Étape 1.

      Une fois que tout cela est prêt, connectez-vous à votre serveur en tant qu’utilisateur non root pour commencer.

      Étape 1 — Identification des réseaux à surveiller

      Au cours de cette étape, vous identifierez les détails pertinents des réseaux que vous souhaitez surveiller.

      BGPalerter peut effectuer un suivi sur la base d’adresses IP individuelles ou de préfixes de réseau. Il peut également surveiller des réseaux entiers sur la base de leur numéro de système autonome (SA), qui est un identifiant unique au niveau mondial pour un réseau appartenant à une entité administrative particulière.

      Pour trouver ces informations, vous pouvez utiliser le IP-to-ASN WHOIS lookup service fourni par le service de renseignements sur les menaces Team Cymru. Il s’agit d’un serveur WHOIS personnalisé conçu pour la recherche d’adresses IP et d’informations sur le routage du réseau.

      Si vous n’avez pas encore installé whois, vous pouvez le faire en utilisant les commandes suivantes :

      • sudo apt update
      • sudo apt install whois

      Une fois que vous avez confirmé que whois a été installé, commencez par rechercher l’adresse IP de votre propre serveur, en utilisant l’argument -h pour spécifier un serveur personnalisé :

      • whois -h whois.cymru.com your-ip-address

      Vous obtiendrez alors une sortie similaire à celle qui suit, qui indique le nom et le numéro du SA dont votre serveur fait partie. Il s’agit généralement du SA de votre fournisseur d’hébergement de serveur, par exemple, DigitalOcean.

      Output

      AS | IP | AS Name 14061 | your-ip-address | DIGITALOCEAN-ASN, US

      Ensuite, vous pouvez effectuer une recherche pour identifier le préfixe/la plage de réseau dont votre serveur fait partie. Pour ce faire, vous devez ajouter l’argument -p à votre demande :

      • whois -h whois.cymru.com " -p your-ip-address"

      La sortie sera très similaire à la commande précédente, mais affichera désormais le préfixe de l’adresse IP à laquelle appartient l’adresse IP de votre serveur :

      Output

      AS | IP | BGP Prefix | AS Name 14061 | your-ip-address | 157.230.80.0/20 | DIGITALOCEAN-ASN, US

      Enfin, vous pouvez consulter d’autres détails sur le SA dont votre serveur fait partie, notamment la région géographique et la date d’attribution.

      Modifiez le numéro SA que vous avez identifié en utilisant les commandes précédentes. Vous utilisez l’argument -v pour permettre une sortie verbeuse, ce qui garantit que tous les détails pertinents sont affichés :

      • whois -h whois.cymru.com " -v as14061"

      La sortie affichera de plus amples informations sur le SA :

      Output

      AS | CC | Registry | Allocated | AS Name 14061 | US | arin | 2012-09-25 | DIGITALOCEAN-ASN, US

      Vous avez identifié les principaux détails concernant le(s) réseau(x) que vous souhaitez surveiller. Prenez note de ces détails quelque part, car vous en aurez besoin plus tard. Ensuite, vous commencerez la configuration de BGPalerter.

      Étape 2 — Création d’un utilisateur sans privilège pour BGPalerter

      Au cours de cette étape, vous allez créer un nouveau compte utilisateur sans privilège pour BGPalerter, car le programme n’a pas besoin de fonctionner avec les privilèges sudo/root.

      Tout d’abord, créez un nouvel utilisateur avec un mot de passe désactivé :

      • sudo adduser --disabled-password bgpalerter

      Vous n’avez pas besoin de définir un mot de passe ou des clés SSH, car vous utiliserez cet utilisateur uniquement comme compte de service pour l’exécution/la maintenance de BGPalerter.

      Connectez-vous au nouvel utilisateur à l’aide de su :

      Vous êtes maintenant connecté en tant que nouvel utilisateur :

      bgpalerter@droplet:/home/user$
      

      Utilisez la commande cd pour vous déplacer vers le répertoire d’accueil de votre nouvel utilisateur :

      bgpalerter@droplet:/home/user$ cd
      bgpalerter@droplet:~$
      

      Vous avez créé un nouvel utilisateur sans privilège pour BGPalerter. Ensuite, vous installerez et configurerez BGPalerter sur votre système.

      Étape 3 — Installation et configuration de BGPalerter

      Au cours de cette étape, vous allez installer et configurer BGPalerter. Assurez-vous d’être toujours connecté en tant que nouvel utilisateur sans privilège.

      Tout d’abord, vous devez identifier la dernière version de BGPalerter, afin de vous assurer que vous téléchargez la version la plus récente. Naviguez vers la page BGPalerter Releases et sélectionnez une copie du lien de téléchargement de la version Linux x64 la plus récente.

      Vous pouvez maintenant télécharger une copie de BGPalerter en utilisant wget, en vous assurant de substituer le bon lien de téléchargement :

      • wget https://github.com/nttgin/BGPalerter/releases/download/v1.24.0/bgpalerter-linux-x64

      Une fois le téléchargement du fichier terminé, marquez-le comme exécutable :

      • chmod +x bgpalerter-linux-x64

      Ensuite, vérifiez que BGPalerter a été téléchargé et installé avec succès en vérifiant le numéro de version :

      • ./bgpalerter-linux-x64 --version

      Le numéro de la version actuelle sera alors affiché :

      Output

      1.24.0

      Avant de pouvoir exécuter correctement BGPalerter, vous devez définir les réseaux que vous souhaitez surveiller dans un fichier de configuration. Créez et ouvrez le fichier prefixes.yml dans votre éditeur de texte préféré :

      Dans ce fichier de configuration, vous spécifierez chacune des adresses IP individuelles, des plages d’adresses IP et des numéros SA que vous souhaitez surveiller.

      Ajoutez l’exemple suivant et ajustez les valeurs de configuration selon les besoins, en utilisant les informations réseau que vous avez identifiées à l’Étape 1 :

      ~/prefixes.yml

      your-ip-address/32:
        description: My Server
        asn:
          - 14061
        ignoreMorespecifics: false
      
      157.230.80.0/20:
        description: IP range for my Server
        asn:
          - 14061
        ignoreMorespecifics: false
      
      options:
        monitorASns:
          '14061':
            group: default
      

      Vous pouvez surveiller autant de plages d’adresses IP ou de numéros SA que vous le souhaitez. Pour surveiller les adresses IP individuelles, représentez-les en utilisant /32 pour IPv4, et /128 pour IPv6.

      La valeur ignoreMorespecifics est utilisée pour contrôler si BGPalerter doit ignorer l’activité pour les itinéraires qui sont plus spécifiques (plus petits) que celui que vous surveillez. Par exemple, si vous surveillez un /20 et qu’un changement de routage est détecté pour un /24 à l’intérieur de celui-ci, cela est considéré comme plus spécifique. Dans la plupart des cas, vous ne voulez pas les ignorer, mais si vous surveillez un grand réseau avec plusieurs préfixes clients délégués, cela peut contribuer à réduire le bruit de fond.

      Vous pouvez maintenant lancer BGPalerter pour la première fois, afin de commencer à surveiller vos réseaux :

      Si BGPalerter démarre avec succès, vous obtiendrez une sortie similaire à celle qui suit. Notez qu’il faut parfois quelques minutes pour que la surveillance commence :

      Output

      Impossible to load config.yml. A default configuration file has been generated. BGPalerter, version: 1.24.0 environment: production Loaded config: /home/bgpalerter/config.yml Monitoring 157.230.80.0/20 Monitoring your-ip-address/32 Monitoring AS 14061

      BGPalerter continuera de fonctionner jusqu’à ce que vous l’arrêtiez en utilisant Ctrl+C.

      Dans l’étape suivante, vous interpréterez certaines des alertes que BGPalerter peut générer.

      Étape 4 — Interprétation des alertes BGPalerter

      Dans cette étape, vous allez examiner quelques exemples d’alertes BGPalerter. BGPalerter émettra des alertes sur le flux de sortie principal, ainsi qu’en option sur tout autre point final de rapport pouvant être configuré dans config.yml, comme décrit dans la documentation de BGPalerter.

      Par défaut, BGPalerter surveille et alerte sur les points suivants :

      • Détournement d’itinéraire : se produit lorsqu’un SA annonce un préfixe qu’il n’est pas autorisé à utiliser, ce qui entraîne un acheminement erroné du trafic. Il peut s’agir soit d’une attaque délibérée, soit d’une erreur de configuration accidentelle.

      • Perte de visibilité de l’itinéraire : un itinéraire est considéré comme visible lorsqu’une majorité de routeurs BGP sur Internet sont capables de l’atteindre de manière fiable. La perte de visibilité signifie que votre réseau est potentiellement indisponible, par exemple si votre peering BGP a cessé de fonctionner.

      • Annonces de nouveaux sous-préfixes : renvoie au moment où un SA commence à annoncer un préfixe plus petit que ce qui est prévu. Cela peut être le signe d’un changement de configuration prévu, d’une mauvaise configuration accidentelle ou, dans certains cas, d’une attaque.

      • Activité au sein de votre SA : fait généralement référence aux annonces de nouveaux itinéraires. Un itinéraire est considéré comme “nouveau” si BGPalerter ne le connaît pas encore.

      Vous trouverez ci-dessous quelques exemples d’alertes, ainsi qu’une brève description de leur signification :

      Alert #1

      The prefix 203.0.113.0/24 is announced by AS64496 instead of AS65540
      

      Cette alerte montre la preuve d’un détournement d’itinéraire, où l’AS64496 a annoncé 203.0.113.0/24 alors qu’il est prévu que ce itinéraire soit annoncé par l’AS65540. C’est un indicateur fort d’une mauvaise configuration menant à une fuite d’itinéraire, ou à un détournement délibéré par un agresseur.

      Alert #2

      The prefix 203.0.113.0/24 has been withdrawn. It is no longer visible from 6 peers
      

      Cette alerte montre que le réseau 203.0.113.0/24 n’est plus visible. Cela peut être dû à un problème de routage en amont, ou à une panne de courant sur un routeur.

      Alert #3

      A new prefix 203.0.113.0/25 is announced by AS64496. It should be instead 203.0.113.0/24 announced by AS64496
      

      Cette alerte montre qu’un préfixe plus spécifique a été annoncé là où il n’est pas prévu, par exemple en annonçant un /25 alors que seul un /24 est prévu. Il s’agit très probablement d’une mauvaise configuration, mais dans certains cas, cela pourrait être la preuve d’un détournement d’itinéraire.

      Alert #4

      AS64496 is announcing 192.0.2.0/24 but this prefix is not in the configured list of announced prefixes
      

      Enfin, cette alerte montre que l’AS64496 a annoncé un préfixe dont BGPalerter n’a pas encore connaissance. Cela pourrait être dû au fait que vous annoncez légitimement un nouveau préfixe, ou cela pourrait être le signe d’une mauvaise configuration qui vous amènerait à annoncer accidentellement un préfixe appartenant à quelqu’un d’autre.

      Dans cette étape, vous avez passé en revue quelques exemples d’alertes BGPalerter. Ensuite, vous configurerez BGPalerter pour qu’il s’exécute automatiquement au démarrage.

      Étape 5 — Démarrage de BGPalerter au démarrage

      Lors de cette dernière étape, vous configurerez BGPalerter pour qu’il se lance au démarrage.

      Assurez-vous que vous êtes toujours connecté en tant que nouvel utilisateur sans privilège, puis ouvrez l’éditeur crontab :

      Ensuite, ajoutez l’entrée suivante au bas du fichier crontab :

      crontab

      @reboot sleep 10; screen -dmS bgpalerter "./bgpalerter-linux-x64"
      

      À chaque fois que votre système démarrera, cela créera une session d'écran détachée appelée “bgpalerter”, et lancera BGPalerter dans cette session.

      Sauvegardez et quittez l’éditeur crontab. Vous souhaitez peut-être désormais redémarrer votre système afin de vous assurer que BGPalerter est correctement lancé au démarrage.

      Vous devez d’abord vous déconnecter de votre utilisateur BGPalerter :

      Ensuite, procédez à un redémarrage normal du système :

      Une fois que votre système a redémarré, reconnectez-vous à votre serveur et utilisez su pour accéder à nouveau à votre utilisateur BGPalerter :

      Vous pouvez alors vous joindre à la session à tout moment afin de visualiser les résultats de BGPalerter :

      Lors de cette dernière étape, vous avez configurer BGPalerter pour qu’il se lance au démarrage.

      Conclusion

      Dans cet article, vous avez configuré BGPalerter et l’avez utilisé pour surveiller les réseaux afin de détecter les changements de routage BGP.

      Si vous souhaitez rendre BGPalerter plus facile à utiliser, vous pouvez le configurer pour envoyer des alertes à un canal Slack via un webhook :

      Si vous souhaitez en savoir plus sur le BGP lui-même, mais que vous n’avez pas accès à un environnement de production de BGP, vous pouvez utiliser DN42 pour expérimenter le BGP dans un environnement sûr et isolé :



      Source link

      Utiliser les buffers dans Node.js


      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      Un buffer est un espace en mémoire (généralement de la RAM) qui stocke des données binaires. Dans Node.js, nous pouvons accéder à ces espaces de mémoire grâce à la classe Buffer intégrée. Les buffers stockent une séquence d’entiers, comme un array en JavaScript. Contrairement aux arrays, vous ne pouvez pas modifier la taille d’un buffer une fois qu’il est créé.

      Vous avez peut-être utilisé des buffers sans vous en rendre compte si vous avez déjà écrit du code de Node.js. Par exemple, lorsque vous lisez à partir d’un fichier avec fs.readFile(), les données renvoyées au callback ou à la Promise sont un objet buffer. En outre, lorsque des requêtes HTTP sont effectuées dans Node.js, elles renvoient des flux de données qui sont temporairement stockés dans un buffer interne lorsque le client ne peut pas traiter le flux en une seule fois.

      Les buffers sont utiles lorsque vous interagissez avec des données binaires, généralement à des niveaux de réseau inférieurs. Ils vous donnent également la possibilité d’effectuer des manipulations fines de données dans Node.js.

      Dans ce tutoriel, vous utiliserez Node.js REPL pour parcourir divers exemples de buffers, comme la création de buffers, la lecture de buffers, l’écriture et la copie de buffers, et l’utilisation de buffers pour convertir des données binaires en données codées. À la fin du tutoriel, vous aurez appris comment utiliser la classe Buffer pour travailler avec des données binaires.

      Conditions préalables

      Étape 1 — Création d’un buffer

      Cette première étape vous présentera les deux façons principales de créer un objet buffer dans Node.js.

      Pour décider de la méthode à utiliser, vous devez répondre à cette question : voulez-vous créer un nouveau buffer ou extraire un buffer à partir de données existantes ? Si vous allez stocker en mémoire des données que vous n’avez pas encore reçues, vous voudrez créer un nouveau buffer. Dans Node.js, nous utilisons la fonction alloc() de la classe Buffer pour ce faire.

      Ouvrons le Node.js REPL pour voir par nous-mêmes. Dans votre terminal, entrez la commande node :

      Vous verrez que l’invite commence par >.

      La fonction alloc() prend la taille du buffer comme premier et seul argument requis. La taille est un nombre entier représentant le nombre d’octets de mémoire que l’objet buffer utilisera. Par exemple, si nous voulions créer un buffer de 1 Ko (kilooctet), équivalent à 1024 octets, nous entrerions ceci dans la console :

      • const firstBuf = Buffer.alloc(1024);

      Pour créer un nouveau buffer, nous avons utilisé la classe Buffer globalement disponible, qui contient la méthode alloc(). En fournissant 1024 comme argument pour alloc(), nous avons créé un buffer d’une taille de 1 Ko.

      Par défaut, lorsque vous initialisez un buffer avec alloc(), le buffer est rempli de zéros binaires en guise d’emplacement pour les données ultérieures. Cependant, nous pouvons modifier la valeur par défaut si nous le souhaitons. Si nous voulions créer un nouveau buffer avec des 1 au lieu des 0, nous définirions le deuxième paramètre de la fonction alloc()fill.

      Dans votre terminal, créez un nouveau buffer à l’invite REPL qui est rempli de 1 :

      • const filledBuf = Buffer.alloc(1024, 1);

      Nous venons de créer un nouvel objet buffer qui fait référence à un espace en mémoire qui stocke 1 Ko de 1. Bien que nous ayons saisi un nombre entier, toutes les données stockées dans un buffer sont des données binaires.

      Les données binaires peuvent se présenter sous de nombreux formats différents. Considérons par exemple une séquence binaire représentant un octet de données : 01110110. Si cette séquence binaire représentait une chaîne en anglais utilisant la norme de codage ASCII, il s’agirait de la lettre v. Cependant, si notre ordinateur traitait une image, cette séquence binaire pourrait contenir des informations sur la couleur d’un pixel.

      L’ordinateur sait les traiter différemment parce que les octets sont codés différemment. L’encodage des octets est le format de l’octet. Un buffer dans Node.js utilise le schéma d’encodage UTF-8 par défaut s’il est initialisé avec des données de chaîne. Un octet en UTF-8 représente un nombre, une lettre (en anglais et dans d’autres langues) ou un symbole. L’UTF-8 est un superset de l’ASCII, le code standard américain pour l’échange d’informations. L’ASCII peut coder des octets avec des lettres anglaises majuscules et minuscules, les chiffres 0-9, et quelques autres symboles comme le point d’exclamation (!) ou le signe esperluette (&).

      Si nous écrivions un programme qui ne pourrait fonctionner qu’avec des caractères ASCII, nous pourrions modifier l’encodage utilisé par notre buffer avec le troisième argument de la fonction alloc()encoding.

      Créons un nouveau buffer de cinq octets de long qui ne stocke que des caractères ASCII :

      • const asciiBuf = Buffer.alloc(5, 'a', 'ascii');

      Le buffer est initialisé avec cinq octets du caractère a, en utilisant la représentation ASCII.

      Remarque : par défaut, Node.js prend en charge les codages de caractères suivants :

      • ASCII, représenté sous le nom ascii
      • UTF-8, représenté sous le nom utf-8 ou utf8
      • UTF-16, représenté sous le nom utf-16le ou utf16le
      • UCS-2, représentée sous le nom ucs-2 ou ucs2
      • Base64, représentée sous le nom base64
      • Hexadecimal, représenté sous le nom hex
      • ISO/IEC 8859-1, représenté sous le nom latin1 ou binary

      Toutes ces valeurs peuvent être utilisées dans les fonctions de la classe Buffer qui acceptent un paramètre encoding. Par conséquent, ces valeurs sont toutes valables pour la méthode alloc().

      Jusqu’à présent, nous avons créé de nouveaux buffers avec la fonction alloc(). Mais nous pouvons parfois vouloir créer un buffer à partir de données qui existent déjà, comme une chaîne ou un tableau.

      Pour créer un buffer à partir de données pré-existantes, nous utilisons la méthode from(). Nous pouvons utiliser cette fonction pour créer des buffers à partir de :

      • Un tableau d’entiers : les valeurs des entiers peuvent être comprises entre 0 et 255.
      • Un ArrayBuffer : c’est un objet JavaScript qui stocke une longueur fixe d’octets.
      • Une chaîne.
      • Un autre buffer.
      • D’autres objets JavaScript qui ont une propriété Symbol.toPrimitive. Cette propriété indique à JavaScript comment convertir l’objet en un type de données primitives : boolean, null, undefined, number, string, or symbol. Vous pouvez en savoir plus sur les symboles en consultant la documentation JavaScript de Mozilla.

      Voyons comment nous pouvons créer un buffer à partir d’une chaîne. Dans l’invite Node.js, saisissez ceci :

      • const stringBuf = Buffer.from('My name is Paul');

      Nous avons maintenant un objet buffer créé à partir de la chaîne de caractères My name is Paul. Créons un nouveau buffer à partir d’un autre buffer que nous avons créé précédemment :

      • const asciiCopy = Buffer.from(asciiBuf);

      Nous avons maintenant créé un nouveau buffer asciiCopy qui contient les mêmes données que asciiBuf.

      Maintenant que nous avons fait l’expérience de la création de buffers, nous pouvons nous plonger dans des exemples de lecture de leurs données.

      Étape 2 — Lecture à partir d’un buffer

      Il existe de nombreuses façons d’accéder aux données dans un buffer. Nous pouvons accéder à un octet individuel dans un buffer ou nous pouvons extraire le contenu entier.

      Pour accéder à un octet d’un buffer, nous passons l’index ou l’emplacement de l’octet que nous voulons. Les buffers stockent les données de manière séquentielle comme des tableaux. Ils indexent également leurs données comme des tableaux, à partir de 0. Nous pouvons utiliser la notation de tableau sur l’objet buffer pour obtenir un octet individuel.

      Voyons à quoi cela ressemble en créant un buffer à partir d’une chaîne dans le REPL :

      • const hiBuf = Buffer.from('Hi!');

      Maintenant, lisons le premier octet du buffer :

      Lorsque vous appuyez sur ENTER, le REPL affiche :

      Output

      72

      L’entier 72 correspond à la représentation UTF-8 pour la lettre H.

      Remarque : les valeurs pour les octets peuvent être des nombres entre 0 et 255. Un octet est une séquence de 8 bits. Un bit est binaire, et ne peut donc avoir qu’une seule des deux valeurs : 0 ou 1. Si nous avons une séquence de 8 bits et deux valeurs possibles par bit, alors nous avons un maximum de 2⁸ valeurs possibles pour un octet. Cela correspond à un maximum de 256 valeurs. Comme nous commençons à compter à partir de zéro, cela signifie que notre nombre le plus élevé est 255.

      Faisons de même pour le deuxième octet. Entrez ce qui suit dans le REPL :

      Le REPL renvoie 105, qui représente le i minuscule.

      Enfin, obtenons le troisième caractère :

      Vous verrez 33 affiché dans le REPL, ce qui correspond à !

      Essayons de récupérer un octet d’un index non valide :

      Le REPL renverra :

      Output

      undefined

      C’est comme si nous essayions d’accéder à un élément d’un tableau avec un index incorrect.

      Maintenant que nous avons vu comment lire les octets individuels d’un buffer, voyons nos options pour récupérer en une seule fois toutes les données stockées dans un buffer. L’objet buffer est doté des méthodes toString() et toJSON(), qui renvoient l’intégralité du contenu d’un buffer dans deux formats différents.

      Comme son nom l’indique, la méthode toString() convertit les octets du buffer en une chaîne de caractères et la renvoie à l’utilisateur. Si nous utilisons cette méthode sur hiBuf, nous obtiendrons la chaîne Hi!. Essayons !

      Dans l’invite, saisissez :

      Le REPL renverra :

      Output

      'Hi!'

      Ce buffer a été créé à partir d’une chaîne. Voyons ce qui se passe si nous utilisons la fonction toString() sur un buffer qui n’a pas été créé à partir de données de chaîne.

      Créons un nouveau buffer vide d’une taille de 10 octets :

      • const tenZeroes = Buffer.alloc(10);

      Maintenant, utilisons la méthode toString() :

      Nous verrons le résultat suivant :

      'u0000u0000u0000u0000u0000u0000u0000u0000u0000u0000'
      

      La chaîne u0000 est le caractère Unicode pour NULL. Il correspond au nombre 0. Lorsque les données du buffer ne sont pas encodées sous forme de chaîne, la méthode toString() renvoie l’encodage UTF-8 des octets.

      La toString() a un paramètre optionnel, encoding. Nous pouvons utiliser ce paramètre pour modifier l’encodage des données du buffer qui sont renvoyées.

      Par exemple, si vous voulez l’encodage hexadecimal pour hiBuf, vous devez entrer ce qui suit à l’invite :

      Cette instruction évaluera :

      Output

      '486921'

      486921 est la représentation hexadécimale des octets qui représentent la chaîne Hi! Dans Node.js, lorsque les utilisateurs veulent convertir l’encodage des données d’un formulaire à un autre, ils mettent généralement la chaîne dans un buffer et appellent toString() avec l’encodage souhaité.

      La méthode toJSON() se comporte différemment. Que le buffer ait été fait à partir d’une chaîne ou non, il renvoie toujours les données sous forme de représentation entière de l’octet.

      Réutilisons les buffers hiBuf et tenZeroes pour nous entraîner à utiliser toJSON(). Dans l’invite, saisissez :

      Le REPL renverra :

      Output

      { type: 'Buffer', data: [ 72, 105, 33 ] }

      L’objet JSON a une propriété type qui sera toujours Buffer. C’est ainsi que les programmes peuvent distinguer ces objets JSON des autres objets JSON.

      La propriété data contient un tableau de la représentation entière des octets. Vous avez peut-être remarqué que 72, 105 et 33 correspondent aux valeurs que nous avons reçues lorsque nous avons tiré les octets individuellement.

      Essayons la méthode toJSON() avec tenZeroes :

      Dans le REPL, vous verrez ce qui suit :

      Output

      { type: 'Buffer', data: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] }

      Le type est le même que celui indiqué précédemment. Cependant, les données sont maintenant un tableau avec dix zéros.

      Maintenant que nous avons couvert les principales façons de lire à partir d’un buffer, voyons comment nous modifions le contenu d’un buffer.

      Étape 3 — Modification d’un buffer

      Il existe de nombreuses façons de modifier un objet buffer existant. Comme pour la lecture, nous pouvons modifier individuellement les octets du buffer en utilisant la syntaxe du tableau. Nous pouvons également écrire de nouveaux contenus dans un buffer, en remplacement des données existantes.

      Commençons par examiner comment nous pouvons modifier les octets individuels d’un buffer. Rappelons notre variable tampon hiBuf, qui contient la chaîne de caractères Hi!. Changeons chaque octet pour qu’elle contienne plutôt Hey.

      Dans le REPL, essayons d’abord de remplacer le deuxième élément de hiBuf par e :

      Voyons maintenant ce buffer comme une chaîne de caractères pour confirmer qu’il stocke les bonnes données. Poursuivez en appelant la méthode toString() :

      Il sera évalué comme :

      Output

      'Hu0000!'

      Nous avons reçu cette étrange sortie parce que le buffer ne peut accepter qu’une valeur entière. On ne peut pas l’attribuer à la lettre e ; il faut plutôt lui attribuer le nombre dont l’équivalent binaire représente e :

      Maintenant, lorsque nous appelons la méthode toString() :

      Nous obtenons cette sortie dans le REPL :

      Output

      'He!'

      Pour modifier le dernier caractère du buffer, nous devons fixer le troisième élément au nombre entier qui correspond à l’octet pour y :

      Confirmez en utilisant à nouveau la méthode toString() :

      Votre REPL affichera :

      Output

      'Hey'

      Si nous essayons d’écrire un octet qui est en dehors de la plage du buffer, il sera ignoré et le contenu du buffer ne changera pas. Essayons, par exemple, de régler le quatrième élément inexistant du buffer sur o :

      Nous pouvons confirmer que le buffer est inchangé avec la méthode toString() :

      La sortie est toujours :

      Output

      'Hey'

      Si nous voulons modifier le contenu de l’ensemble du buffer, nous pouvons utiliser la méthode write(). La méthode write() accepte une chaîne de caractères qui remplacera le contenu d’un buffer.

      Utilisons la méthode write() pour modifier le contenu de hiBuf et revenir à Hi!. Dans votre shell Node.js, tapez la commande suivante à l’invite :

      La méthode write() a renvoyé 3 dans le REPL. C’est parce qu’il a écrit trois octets de données. Chaque lettre a la taille d’un octet, puisque ce buffer utilise le codage UTF-8, qui utilise un octet pour chaque caractère. Si le buffer avait utilisé le codage UTF-16, qui comporte un minimum de deux octets par caractère, la fonction write() aurait renvoyé 6.

      Maintenant, vérifiez le contenu du buffer en utilisant toString() :

      Le REPL produira :

      Output

      'Hi!'

      Cette technique est plus rapide que de devoir modifier chaque élément octet par octet.

      Si vous essayez d’écrire plus d’octets que la taille d’un buffer, l’objet buffer n’acceptera que le nombre d’octets qu’il peut recevoir. Pour illustrer cela, créons un buffer qui stocke trois octets :

      • const petBuf = Buffer.alloc(3);

      Essayons maintenant d’y écrire Cats :

      Lorsque l’appel write() est évalué, le REPL renvoie 3, indiquant que seuls trois octets ont été écrits dans le buffer. Confirmez maintenant que le buffer contient les trois premiers octets :

      Le REPL renvoie :

      Output

      'Cat'

      La fonction write() ajoute les octets dans un ordre séquentiel, de sorte que seuls les trois premiers octets ont été placés dans le buffer.

      En revanche, faisons un Buffer qui stocke quatre octets :

      • const petBuf2 = Buffer.alloc(4);

      Ecrivez-lui le même contenu :

      Ensuite, ajoutez un nouveau contenu qui occupe moins d’espace que le contenu original :

      Puisque les buffers s’écrivent séquentiellement en partant de 0, si nous imprimions le contenu du buffer :

      Nous verrions :

      Output

      'Hits'

      Les deux premiers caractères sont écrasés, mais le reste du buffer est intact.

      Parfois, les données que nous voulons dans notre buffer préexistant ne sont pas dans une chaîne mais résident dans un autre objet buffer. Dans ces cas, nous pouvons utiliser la fonction copy() pour modifier ce que notre buffer stocke.

      Créons deux nouveaux buffers :

      • const wordsBuf = Buffer.from('Banana Nananana');
      • const catchphraseBuf = Buffer.from('Not sure Turtle!');

      Les buffers wordsBuf et catchphraseBuf contiennent tous deux des données de chaîne. Nous voulons modifier catchphraseBuf pour qu’il stocke Nananana Turtle! au lieu de Not sure Turtle! . Nous utiliserons copy() pour faire passer Nananana de wordsBuf à catchphraseBuf.

      Pour copier des données d’un buffer à l’autre, nous utiliserons la méthode copy() sur le buffer qui est la source de l’information. Par conséquent, comme wordsBuf possède les données des chaînes de caractères que nous voulons copier, nous devons copier comme ceci :

      • wordsBuf.copy(catchphraseBuf);

      Dans ce cas, le paramètre target est le buffer catchphraseBuf.

      Lorsque nous entrons cela dans le REPL, il renvoie 15 indiquant que 15 octets ont été écrits. La chaîne Nananana n’utilise que 8 octets de données, nous savons donc immédiatement que notre copie ne s’est pas déroulée comme prévu. Utilisez la méthode toString() pour voir le contenu de catchphraseBuf :

      • catchphraseBuf.toString();

      Le REPL renvoie :

      Output

      'Banana Nananana!'

      Par défaut, copy() a pris tout le contenu de wordsBuf et l’a placé dans catchphraseBuf. Nous devons être plus sélectifs dans notre objectif et ne copier que Nananana. Réécrivons le contenu original de catchphraseBuf avant de continuer :

      • catchphraseBuf.write('Not sure Turtle!');

      La fonction copy() dispose de quelques paramètres supplémentaires qui nous permettent de personnaliser les données qui sont copiées dans l’autre buffer. Voici une liste de tous les paramètres de cette fonction :

      • target – C’est le seul paramètre requis de copy(). Comme nous l’avons vu lors de notre précédente utilisation, il s’agit du buffer vers lequel nous voulons copier.
      • targetStart – Il s’agit de l’index des octets du buffer cible vers lequel nous devons commencer la copie. Par défaut, il est de 0, ce qui signifie qu’il copie les données à partir du début du buffer.
      • sourceStart – C’est l’index des octets du buffer source où nous devons copier.
      • sourceEnd – C’est l’index des octets dans le buffer source où nous devons arrêter la copie. Par défaut, il s’agit de la longueur du buffer.

      Donc, pour copier Nananana de wordsBuf à catchphraseBuf, notre target devrait être catchphraseBuf comme avant. targetStart serait 0, car nous voulons que Nananana apparaisse au début de catchphraseBuf. Le sourceStart devrait être 7, car c’est l’indice où commence Nananana dans wordsBuf. Le sourceEnd continuerait à être la longueur des buffers.

      À l’invite du REPL, copiez le contenu de wordsBuf comme ceci :

      • wordsBuf.copy(catchphraseBuf, 0, 7, wordsBuf.length);

      Le REPL confirme que 8 octets ont été écrits. Notez comment wordsBuf.length est utilisé comme valeur pour le paramètre sourceEnd. Comme pour les tableaux, la propriété length nous donne la taille du buffer.

      Voyons maintenant le contenu de catchphraseBuf :

      • catchphraseBuf.toString();

      Le REPL renvoie :

      Output

      'Nananana Turtle!'

      Bravo! Nous avons pu modifier les données de catchphraseBuf en copiant le contenu de wordsBuf.

      Vous pouvez quitter le Node.js REPL si vous le souhaitez. Notez que toutes les variables qui ont été créées ne seront plus disponibles lorsque vous le ferez :

      Conclusion

      Dans ce tutoriel, vous avez appris que les buffers sont des allocations de longueur fixe en mémoire qui stockent des données binaires. Vous avez d’abord créé des buffers en définissant leur taille en mémoire et en les initialisant avec des données pré-existantes. Vous avez ensuite lu les données d’un buffer en examinant leurs octets individuels et en utilisant les méthodes toString() et toJSON(). Enfin, vous avez modifié les données stockées par un buffer en changeant ses octets individuels et en utilisant les méthodes write() et copy().

      Les buffers vous donnent un bon aperçu de la façon dont les données binaires sont manipulées par Node.js. Maintenant que vous pouvez interagir avec les buffers, vous pouvez observer les différentes façons dont l’encodage des caractères affecte la façon dont les données sont stockées. Par exemple, vous pouvez créer des buffers à partir de données de chaînes qui ne sont pas codées en UTF-8 ou ASCII et observer leur différence de taille. Vous pouvez également choisir un buffer avec UTF-8 et utiliser toString() pour le convertir en d’autres schémas d’encodage.

      Pour en savoir plus sur les buffers dans Node.js, vous pouvez lire la documentation de Node.js sur l’objet Buffer. Si vous souhaitez continuer à apprendre Node.js, vous pouvez revenir à la série Comment coder dans Node.js, ou parcourir les projets de programmation et les configurations sur notre page thématique Node.



      Source link

      Sysadmin eBook: Faire fonctionner les serveurs


      Télécharger le eBook complet

      Faire fonctionner les serveurs : Un guide pratique de l’administration des systèmes un eBook au format EPUB

      Faire fonctionner les serveurs : un Guide pratique pour l’administration du système *un eBook en *format PDF**

      Présentation de l’eBook

      Ce livre met en lumière les compétences pratiques des administrateurs système, les architectures courantes que vous rencontrerez et les meilleures pratiques qui s’appliquent à l’automatisation et à l’exécution de systèmes à toute échelle, d’un ordinateur portable ou d’un serveur à 1 000 ou plus. Il est destiné à vous aider à vous orienter dans la discipline et, nous l’espérons, vous encourager à en apprendre davantage sur l’administration du système.

      Ce livre est basé sur le programme d’études Faire fonctionner les serveurs : Un guide pratique pour l’administration du système Linux que l’on trouve dans la communauté DigitalOcean. Il se structure autour de quelques thèmes centraux :

      1. Sujets d’introduction

      2. Les piles technologiques LAMP et LEMP

      3. Sécuriser vos serveurs

      4. Automatisation avec Ansible

      5. Contrôle de la version et intégration continue

      N’hésitez pas à choisir les sujets qui vous intéressent dans ce livre et à les explorer en utilisant ces chapitres comme des guides. En parcourant ce livre, vous découvrirez une grande variété de technologies, de termes techniques et d’approches conceptuelles de la gestion des serveurs Linux. Vous pouvez parcourir chaque chapitre ou section à votre propre rythme et dans l’ordre que vous souhaitez.

      Télécharger le eBook

      Vous pouvez télécharger le eBook au format EPUB ou PDF en suivant les liens ci-dessous.

      Télécharger le eBook complet

      Faire fonctionner les serveurs : Un guide pratique de l’administration des systèmes un eBook au format EPUB

      Faire fonctionner les serveurs : un Guide pratique pour l’administration du système un eBook en format PDF

      Pour des ressources sysadmin supplémentaires qui vous aideront à démarrer, et pour participer à la communauté DigitalOcean d’autres développeurs et administrateurs, consultez notre bibliothèque sans cesse croissante de tutoriels, de questions et de projets avec le tag Getting Started.



      Source link