One place for hosting & domains

      utilisant

      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

      Comment utiliser Go avec MongoDB en utilisant le pilote MongoDB Go


      L’auteur a choisi la Free Software Foundation pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      Après s’être appuyée sur des solutions développées par la communauté pendant de nombreuses années, MongoDB a annoncé qu’elle travaillait sur un pilote officiel pour Go. En mars 2019, ce nouveau pilote a atteint un statut prêt pour la production avec la sortie de la v1.0.0 et a été continuellement mis à jour depuis lors.

      Comme les autres pilotes officiels de MongoDB, le pilote Go est idiomatique au langage de programmation Go et fournit un moyen facile d’utiliser MongoDB comme solution de base de données pour un programme Go. Il est entièrement intégré à l’API MongoDB, et expose toutes les fonctions d’interrogation, d’indexation et d’agrégation de l’API, ainsi que d’autres fonctions avancées. Contrairement aux bibliothèques tierces, il sera entièrement pris en charge par les ingénieurs de MongoDB afin que vous puissiez être assuré de son développement et de sa maintenance continus.

      Dans ce tutoriel, vous commencerez à utiliser le pilote officiel Go de MongoDB. Vous allez installer le pilote, vous connecter à une base de données MongoDB et effectuer plusieurs opérations CRUD. Dans le processus, vous créerez un programme de gestion des tâches pour gérer les tâches par la ligne de commande.

      Conditions préalables

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

      Si vous utilisez Go v1.11 ou 1.12, assurez-vous que Go Modules est activé en définissant la variable d’environnement GO111MODULE sur on comme indiqué ci-dessous :

      Pour plus d’informations sur l’implémentation des variables d’environnement, lisez ce tutoriel sur Comment lire et configurer les variables d’environnements et les variables shell.

      Les commandes et le code présentés dans ce guide ont été testés avec Go v1.14.1 et MongoDB v3.6.3.

      Étape 1 — Installation du pilote Go de MongoDB

      Dans cette étape, vous allez installer le package Go Driver pour MongoDB et l’importer dans votre projet. Vous vous connecterez également à votre base de données MongoDB et vérifierez l’état de la connexion.

      Allez-y et créez un nouveau répertoire pour ce tutoriel dans votre système de fichiers :

      Une fois que votre répertoire de projet est configuré, modifiez-le avec la commande suivante :

      Ensuite, initialisez le projet Go avec un fichier go.mod. Ce fichier définit les exigences du projet et verrouille les dépendances à leurs versions correctes :

      Si votre répertoire de projet se trouve en dehors du $GOPATH, vous devez spécifier l’itinéraire d’importation de votre module comme suit :

      • go mod init github.com/<your_username>/tasker

      À ce stade, votre fichier go.mod ressemblera à ceci :

      go.mod

      module github.com/<your_username>/tasker
      
      go 1.14
      

      Ajoutez le pilote MongoDB Go comme dépendance pour votre projet en utilisant la commande suivante :

      • go get go.mongodb.org/mongo-driver

      Vous verrez une sortie comme celle-ci :

      Output

      go: downloading go.mongodb.org/mongo-driver v1.3.2 go: go.mongodb.org/mongo-driver upgrade => v1.3.2

      À ce stade, votre fichier go.mod ressemblera à ceci :

      go.mod

      module github.com/<your_username>/tasker
      
      go 1.14
      
      require go.mongodb.org/mongo-driver v1.3.1 // indirect
      

      Ensuite, créez un fichier main.go dans votre projet root et ouvrez-le dans votre éditeur de texte :

      Pour commencer à utiliser le pilote, importez les packages suivants dans votre fichier main.go :

      main.go

      package main
      
      import (
          "context"
          "log"
      
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
      )
      

      Vous ajoutez ici les packages mongo et options, que le pilote Go de MongoDB fournit.

      Ensuite, après vos importations, créez un nouveau client MongoDB et connectez-vous à votre serveur MongoDB en cours d’exécution :

      main.go

      . . .
      var collection *mongo.Collection
      var ctx = context.TODO()
      
      func init() {
          clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
          client, err := mongo.Connect(ctx, clientOptions)
          if err != nil {
              log.Fatal(err)
          }
      }
      

      mongo.Connect() accepte un Context et un objet options.ClientOptions, qui est utilisé pour définir la chaîne de connexion et d’autres paramètres du pilote. Vous pouvez consulter la documentation du package options pour voir quelles sont les options de configuration disponibles.

      Context est comme un délai ou une date limite qui indique quand une opération doit s’arrêter et reprendre. Il contribue à prévenir la dégradation des performances des systèmes de production lorsque certaines opérations sont lentes. Dans ce code, vous passez context.TODO() pour indiquer que vous n’êtes pas sûr du contexte à utiliser pour le moment, mais que vous prévoyez d’en ajouter un à l’avenir.

      Ensuite, assurons-nous que votre serveur MongoDB a été trouvé et connecté avec succès en utilisant la méthode Ping. Ajoutez le code suivant à l’intérieur de la fonction init :

      main.go

      . . .
          log.Fatal(err)
        }
      
        err = client.Ping(ctx, nil)
        if err != nil {
          log.Fatal(err)
        }
      }
      

      S’il y a des erreurs lors de la connexion à la base de données, le programme devrait planter pendant que vous essayez de résoudre le problème, car il ne sert à rien de laisser le programme fonctionner sans une connexion active à la base de données.

      Ajoutez le code suivant pour créer une base de données :

      main.go

      . . .
        err = client.Ping(ctx, nil)
        if err != nil {
          log.Fatal(err)
        }
      
        collection = client.Database("tasker").Collection("tasks")
      }
      

      Vous créez une base de données tasker et une collection task pour stocker les tâches que vous allez créer. Vous configurez également la collection comme une variable au niveau du package afin de pouvoir réutiliser la connexion à la base de données dans l’ensemble du package.

      Enregistrez et quittez le fichier.

      Le main.go complet à ce stade est le suivant :

      main.go

      package main
      
      import (
          "context"
          "log"
      
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
      )
      
      var collection *mongo.Collection
      var ctx = context.TODO()
      
      func init() {
          clientOptions := options.Client().ApplyURI("mongodb://localhost:27017/")
          client, err := mongo.Connect(ctx, clientOptions)
          if err != nil {
              log.Fatal(err)
          }
      
          err = client.Ping(ctx, nil)
          if err != nil {
              log.Fatal(err)
          }
      
          collection = client.Database("tasker").Collection("tasks")
      }
      

      Vous avez configuré votre programme pour vous connecter à votre serveur MongoDB en utilisant le pilote Go. Dans l’étape suivante, vous procéderez à la création de votre programme de gestion des tâches.

      Étape 2 — Création d’un programme CLI

      Au cours de cette étape, vous installerez le célèbre package cli pour vous aider à développer votre programme de gestion des tâches. Il offre une interface dont vous pouvez tirer parti pour créer rapidement des outils modernes en ligne de commande. Par exemple, ce package donne la possibilité de définir des sous-commandes destinées à votre programme, pour une expérience en ligne de commande plus proche de celle de git.

      Exécutez la commande suivante pour ajouter le package en tant que dépendance :

      • go get github.com/urfave/cli/v2

      Ensuite, ouvrez à nouveau votre fichier main.go :

      Ajoutez le code surligné suivant à votre fichier main.go :

      main.go

      package main
      
      import (
          "context"
          "log"
          "os"
      
          "github.com/urfave/cli/v2"
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
      )
      . . .
      

      Vous importez le package cli comme mentionné. Vous importez également le package os, que vous utiliserez pour passer les arguments de la ligne de commande à votre programme :

      Ajoutez le code suivant après votre fonction init pour créer votre programme CLI et faire en sorte que votre code se compile :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:     "tasker",
              Usage:    "A simple CLI program to manage your tasks",
              Commands: []*cli.Command{},
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      

      Ce snippet crée un programme CLI appelé tasker et ajoute une courte description d’utilisation qui sera imprimée lorsque vous exécuterez le programme. La slice Commands est le lieu où vous ajouterez des commandes pour votre programme. La commande Run décrit la slice arguments à la commande appropriée.

      Enregistrez et fermez votre fichier

      Voici la commande dont vous avez besoin pour construire et exécuter le programme :

      Vous verrez la sortie suivante :

      Output

      NAME: tasker - A simple CLI program to manage your tasks USAGE: main [global options] command [command options] [arguments...] COMMANDS: help, h Shows a list of commands or help for one command GLOBAL OPTIONS: --help, -h show help (default: false)

      Le programme s’exécute et affiche un texte d’aide, qui est pratique pour apprendre ce que le programme peut faire, et comment l’utiliser.

      Dans les prochaines étapes, vous améliorerez l’utilité de votre programme en ajoutant des sous-commandes pour vous aider à gérer vos tâches dans MongoDB.

      Étape 3 — Création d’une tâche

      Au cours de cette étape, vous ajouterez une sous-commande à votre programme CLI en utilisant le package cli. À la fin de cette section, vous pourrez ajouter une nouvelle tâche à votre base de données MongoDB en utilisant une nouvelle commande add dans votre programme CLI.

      Commencez par ouvrir votre fichier main.go :

      Ensuite, importez les packages go.mongodb.org/mongo-driver/bson/primitive, time et errors :

      main.go

      package main
      
      import (
          "context"
          "errors"
          "log"
          "os"
          "time"
      
          "github.com/urfave/cli/v2"
          "go.mongodb.org/mongo-driver/bson/primitive"
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
      )
      . . .
      

      Puis, créez une nouvelle structure pour représenter une seule tâche dans la base de données et insérez-la immédiatement avant la fonction main :

      main.go

      . . .
      type Task struct {
          ID        primitive.ObjectID `bson:"_id"`
          CreatedAt time.Time          `bson:"created_at"`
          UpdatedAt time.Time          `bson:"updated_at"`
          Text      string             `bson:"text"`
          Completed bool               `bson:"completed"`
      }
      . . .
      

      Vous utilisez le package primitive pour définir le type de l’ID de chaque tâche, puisque MongoDB utilise les ObjectID par défaut pour le champ _id. L’un des autres comportements par défaut de MongoDB est que le nom de champ en minuscules est utilisé comme clé pour chaque champ exporté lors de sa sérialisation, mais cela peut être modifié en utilisant les balises struct bson.

      Ensuite, créez une fonction qui reçoit une instance de Task et l’enregistre dans la base de données. Ajoutez ce snippet à la fonction main :

      main.go

      . . .
      func createTask(task *Task) error {
          _, err := collection.InsertOne(ctx, task)
        return err
      }
      . . .
      

      La méthode collection.InsertOne() insère la tâche fournie dans la collection de la base de données et renvoie l’identifiant du document qui a été inséré. Étant donné que vous n’avez pas besoin de cet identifiant, vous le supprimez en l’attribuant à l’opérateur de soulignement.

      L’étape suivante consiste à ajouter une nouvelle commande à votre programme de gestion des tâches pour créer de nouvelles tâches. Appelons-la add :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
              },
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      

      Toute nouvelle commande ajoutée à votre programme CLI est placée dans la slice Commands. Chacune d’entre elles se compose d’un nom, d’une description d’usage et d’une action. C’est le code qui sera exécuté lors de l’exécution de la commande.

      Dans ce code, vous collectez le premier argument à add et l’utilisez pour définir la propriété Text d’une nouvelle instance Task tout en attribuant les valeurs par défaut appropriées pour les autres propriétés. La nouvelle tâche est ensuite transmise à createTask, qui insère la tâche dans la base de données et renvoie nil si tout va bien, ce qui entraîne la sortie de la commande.

      Enregistrez et fermez votre fichier

      Testez ce processus en ajoutant quelques tâches à l’aide de la commande add. En cas de succès, vous ne verrez aucune erreur s’imprimer sur votre écran :

      • go run main.go add "Learn Go"
      • go run main.go add "Read a book"

      Maintenant que vous pouvez ajouter des tâches avec succès, mettons en place un moyen d’afficher toutes les tâches que vous avez ajoutées à la base de données.

      Étape 4 — Liste de toutes les tâches

      Le listage des documents d’une collection peut être effectué à l’aide de la méthode collection.Find(), qui attend un filtre ainsi qu’un pointeur vers une valeur en laquelle le résultat peut être décodé. Sa valeur de retour est un Curseur, qui fournit un flux de documents qui peuvent être répétés et décodés un à la fois. Le Curseur est ensuite fermé une fois qu’il a été épuisé.

      Ouvrez votre fichier main.go :

      Veillez à importer le package bson :

      main.go

      package main
      
      import (
          "context"
          "errors"
          "log"
          "os"
          "time"
      
          "github.com/urfave/cli/v2"
          "go.mongodb.org/mongo-driver/bson"
          "go.mongodb.org/mongo-driver/bson/primitive"
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
      )
      . . .
      

      Ensuite, créez les fonctions suivantes immédiatement après createTask :

      main.go

      . . .
      func getAll() ([]*Task, error) {
        // passing bson.D{{}} matches all documents in the collection
          filter := bson.D{{}}
          return filterTasks(filter)
      }
      
      func filterTasks(filter interface{}) ([]*Task, error) {
          // A slice of tasks for storing the decoded documents
          var tasks []*Task
      
          cur, err := collection.Find(ctx, filter)
          if err != nil {
              return tasks, err
          }
      
          for cur.Next(ctx) {
              var t Task
              err := cur.Decode(&t)
              if err != nil {
                  return tasks, err
              }
      
              tasks = append(tasks, &t)
          }
      
          if err := cur.Err(); err != nil {
              return tasks, err
          }
      
        // once exhausted, close the cursor
          cur.Close(ctx)
      
          if len(tasks) == 0 {
              return tasks, mongo.ErrNoDocuments
          }
      
          return tasks, nil
      }
      

      BSON (Binary-encoded JSON) est la façon dont les documents sont représentés dans une base de données MongoDB et le package bson est ce qui nous aide à travailler avec les objets BSON dans Go. Le type bson.D utilisé dans la fonction getAll() représente un document BSON et il est utilisé lorsque l’ordre des propriétés est important. En passant bson.D{{}} comme filtre à filterTasks(), vous indiquez que vous voulez faire correspondre tous les documents de la collection.

      Dans la fonction filterTasks(), vous itérez sur le Curseur renvoyé par la méthode collection.Find() et décodez chaque document en une instance de Task. Chaque Task est ensuite annexée à la slice de tâches créée au début de la fonction. Une fois que le Curseur est épuisé, il est fermé et la slice des tasks est retournée.

      Avant de créer une commande pour lister toutes les tâches, créons une fonction d’aide qui prend une slice de tasks et l’imprime sur la sortie standard. Vous utiliserez le package color pour colorer la sortie.

      Avant de pouvoir utiliser ce package, installez le avec :

      • go get gopkg.in/gookit/color.v1

      Vous verrez la sortie suivante :

      Output

      go: downloading gopkg.in/gookit/color.v1 v1.1.6 go: gopkg.in/gookit/color.v1 upgrade => v1.1.6

      Et importez-le dans votre fichier main.go en même temps que le package fmt :

      main.go

      package main
      
      import (
          "context"
          "errors"
        "fmt"
          "log"
          "os"
          "time"
      
          "github.com/urfave/cli/v2"
          "go.mongodb.org/mongo-driver/bson"
          "go.mongodb.org/mongo-driver/bson/primitive"
          "go.mongodb.org/mongo-driver/mongo"
          "go.mongodb.org/mongo-driver/mongo/options"
          "gopkg.in/gookit/color.v1"
      )
      . . .
      

      Ensuite, créez une nouvelle fonction printTasks à la suite de votre fonction main :

      main.go

      . . .
      func printTasks(tasks []*Task) {
          for i, v := range tasks {
              if v.Completed {
                  color.Green.Printf("%d: %sn", i+1, v.Text)
              } else {
                  color.Yellow.Printf("%d: %sn", i+1, v.Text)
              }
          }
      }
      . . .
      

      Cette fonction printTasks prend une slice de tasks, l’itére sur chacune et l’imprime sur la sortie standard en utilisant la couleur verte pour indiquer les tâches terminées, et jaune pour les tâches incomplètes.

      Poursuivez en ajoutant les lignes surlignées suivantes pour créer une nouvelle commande all dans la slice Commands. Cette commande permet d’imprimer toutes les tâches ajoutées à la sortie standard :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
                  {
                      Name:    "all",
                      Aliases: []string{"l"},
                      Usage:   "list all tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getAll()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
              },
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      
      . . .
      

      La commande all récupère toutes les tâches présentes dans la base de données et les imprime sur la sortie standard. Si aucune tâche n’est présente, une invite à ajouter une nouvelle tâche est imprimée à la place.

      Enregistrez et fermez votre fichier

      Construisez et exécutez votre programme avec la commande all :

      Il énumérera toutes les tâches que vous avez ajoutées jusqu’à présent :

      Output

      1: Learn Go 2: Read a book

      Maintenant que vous pouvez visualiser toutes les tâches dans la base de données, ajoutons la possibilité de marquer une tâche comme terminée à l’étape suivante.

      Étape 5 — Fin d’une tâche

      Dans cette étape, vous créerez une nouvelle sous-commande appelée done qui vous permettra de marquer une tâche existante dans la base de données comme étant terminée. Pour marquer une tâche comme terminée, vous pouvez utiliser la méthode collection.FindOneAndUpdate(). Il permet de localiser un document dans une collection et de mettre à jour toutes ou une partie de ses propriétés. Cette méthode nécessite un filtre pour localiser le document et un document de mise à jour pour décrire l’opération. Les deux sont construits en utilisant les types bson.D.

      Commencez par ouvrir votre fichier main.go :

      Insérez le snippet suivant à la suite de votre fonction filterTasks :

      main.go

      . . .
      func completeTask(text string) error {
          filter := bson.D{primitive.E{Key: "text", Value: text}}
      
          update := bson.D{primitive.E{Key: "$set", Value: bson.D{
              primitive.E{Key: "completed", Value: true},
          }}}
      
          t := &Task{}
          return collection.FindOneAndUpdate(ctx, filter, update).Decode(t)
      }
      . . .
      

      La fonction correspond au premier document où la propriété de texte est égale au paramètre text. Le document update précise que la propriété completed doit être réglée sur true. S’il y a une erreur dans l’opération FindOneAndUpdate(), elle sera renvoyée par completeTask(). Sinon, nil est renvoyé.

      Ensuite, ajoutons une nouvelle commande done à votre programme CLI qui marque une tâche comme étant terminée :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
                  {
                      Name:    "all",
                      Aliases: []string{"l"},
                      Usage:   "list all tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getAll()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
                  {
                      Name:    "done",
                      Aliases: []string{"d"},
                      Usage:   "complete a task on the list",
                      Action: func(c *cli.Context) error {
                          text := c.Args().First()
                          return completeTask(text)
                      },
                  },
              },
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      
      . . .
      

      Vous utilisez l’argument passé à la commande done pour trouver le premier document dont la propriété text correspond. S’il est trouvé, la propriété completed sur le document est réglée sur true.

      Enregistrez et fermez votre fichier

      Ensuite, exécutez votre programme avec la commande done :

      • go run main.go done "Learn Go"

      Si vous utilisez à nouveau la commande all, vous remarquerez que la tâche qui était marquée comme terminée est maintenant imprimée en vert.

      Capture d'écran de la sortie du terminal après l'achèvement d'une tâche

      Parfois, vous voulez seulement voir les tâches qui n’ont pas encore été terminées. Nous ajouterons cet élément par la suite.

      Étape 6 — Affichage des tâches en attente uniquement

      Dans cette étape, vous allez incorporer du code pour récupérer les tâches en attente dans la base de données, en utilisant le pilote MongoDB. Les tâches en attente sont celles dont la propriété completed est réglée sur false.

      Ajoutons une nouvelle fonction qui récupère les tâches qui n’ont pas encore été terminées. Ouvrez votre fichier main.go :

      Ajoutez ensuite ce snippet à la suite de la fonction completeTask :

      main.go

      . . .
      func getPending() ([]*Task, error) {
          filter := bson.D{
              primitive.E{Key: "completed", Value: false},
          }
      
          return filterTasks(filter)
      }
      . . .
      

      Vous créez un filtre en utilisant les package bson et primitive du pilote MongoDB, qui correspondra aux documents dont la propriété completed est réglée sur false. La slice des tâches en attente est ensuite renvoyée à l’appelant.

      Au lieu de créer une nouvelle commande pour lister les tâches en attente, faisons en sorte que ce soit l’action par défaut lors de l’exécution du programme sans aucune commande. Vous pouvez effectuer ceci en ajoutant une propriété Action au programme comme suit :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Action: func(c *cli.Context) error {
                  tasks, err := getPending()
                  if err != nil {
                      if err == mongo.ErrNoDocuments {
                          fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                          return nil
                      }
      
                      return err
                  }
      
                  printTasks(tasks)
                  return nil
              },
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
      . . .
      

      La propriété Action exécute une action par défaut lorsque le programme est exécuté sans aucune sous-commande. C’est là que se situe la logique de la liste des tâches en attente. La fonction getPending() est appelée et les tâches résultantes sont imprimées sur la sortie standard à l’aide de printTasks(). S’il n’y a pas de tâches en attente, une invite est affichée à la place, encourageant l’utilisateur à ajouter une nouvelle tâche à l’aide de la commande add.

      Enregistrez et fermez votre fichier

      Si vous exécutez le programme maintenant sans ajouter de commandes, toutes les tâches en attente seront listées dans la base de données :

      Vous verrez la sortie suivante :

      Output

      1: Read a book

      Maintenant que vous pouvez lister les tâches incomplètes, ajoutons une autre commande qui vous permet de ne voir que les tâches terminées.

      Étape 7 — Affichage des tâches terminées

      Dans cette étape, vous ajouterez une nouvelle sous-commande finished qui récupère les tâches terminées dans la base de données et les affiche à l’écran. Cela implique de filtrer et de renvoyer les tâches dont la propriété completed est réglée sur true.

      Ouvrez votre fichier main.go :

      Ajoutez ensuite le code suivant à la fin de votre dossier :

      main.go

      . . .
      func getFinished() ([]*Task, error) {
          filter := bson.D{
              primitive.E{Key: "completed", Value: true},
          }
      
          return filterTasks(filter)
      }
      . . .
      

      Comme pour la fonction getPending(), vous avez ajouté une fonction getFinished() qui renvoie une slice de tâches terminées. Dans ce cas, le filtre a la propriété completed réglée sur true, de sorte que seuls les documents qui correspondent à cette condition seront retournés.

      Ensuite, créez une commande finished qui imprime toutes les tâches terminées :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Action: func(c *cli.Context) error {
                  tasks, err := getPending()
                  if err != nil {
                      if err == mongo.ErrNoDocuments {
                          fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                          return nil
                      }
      
                      return err
                  }
      
                  printTasks(tasks)
                  return nil
              },
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
                  {
                      Name:    "all",
                      Aliases: []string{"l"},
                      Usage:   "list all tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getAll()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
                  {
                      Name:    "done",
                      Aliases: []string{"d"},
                      Usage:   "complete a task on the list",
                      Action: func(c *cli.Context) error {
                          text := c.Args().First()
                          return completeTask(text)
                      },
                  },
                  {
                      Name:    "finished",
                      Aliases: []string{"f"},
                      Usage:   "list completed tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getFinished()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `done 'task'` to complete a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
              }
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      . . .
      

      La commande finished récupère les tâches dont la propriété completed est réglée sur true via la fonction getFinished() créée ici. Il la transmet ensuite à la fonction printTasks afin qu’elle soit imprimée sur la sortie standard.

      Enregistrez et fermez votre fichier

      Exécutez la commande suivante :

      Vous verrez la sortie suivante :

      Output

      1: Learn Go

      Dans la dernière étape, vous donnerez aux utilisateurs la possibilité de supprimer des tâches de la base de données.

      Étape 8 — Suppression d’une tâche

      Dans cette étape, vous ajouterez une nouvelle sous-commande delete pour permettre aux utilisateurs de supprimer une tâche de la base de données. Pour supprimer une seule tâche, vous utiliserez la méthode collection.DeleteOne() du pilote MongoDB. Il s’appuie également sur un filtre pour faire correspondre le document à supprimer.

      Ouvrez votre fichier main.go une fois de plus :

      Ajoutez cette fonction deleteTask pour supprimer des tâches de la base de données juste après votre fonction getFinished :

      main.go

      . . .
      func deleteTask(text string) error {
          filter := bson.D{primitive.E{Key: "text", Value: text}}
      
          res, err := collection.DeleteOne(ctx, filter)
          if err != nil {
              return err
          }
      
          if res.DeletedCount == 0 {
              return errors.New("No tasks were deleted")
          }
      
          return nil
      }
      . . .
      

      Cette méthode deleteTask prend un argument de type chaîne de caractères qui représente l’élément de tâche à supprimer. Un filtre est construit pour correspondre à l’élément de tâche dont la propriété text est réglée sur l’argument de la chaîne de caractères. Vous passez le filtre à la méthode DeleteOne() qui correspond à l’article dans la collection et le supprime.

      Vous pouvez vérifier la propriété DeletedCount sur le résultat de la méthode DeleteOne pour confirmer si des documents ont été supprimés. Si le filtre ne parvient pas à faire correspondre un document à supprimer, le DeletedCount sera égal à zéro et vous pourrez renvoyer une erreur dans ce cas.

      Ajoutez maintenant une nouvelle commande rm comme surlignée :

      main.go

      . . .
      func main() {
          app := &cli.App{
              Name:  "tasker",
              Usage: "A simple CLI program to manage your tasks",
              Action: func(c *cli.Context) error {
                  tasks, err := getPending()
                  if err != nil {
                      if err == mongo.ErrNoDocuments {
                          fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                          return nil
                      }
      
                      return err
                  }
      
                  printTasks(tasks)
                  return nil
              },
              Commands: []*cli.Command{
                  {
                      Name:    "add",
                      Aliases: []string{"a"},
                      Usage:   "add a task to the list",
                      Action: func(c *cli.Context) error {
                          str := c.Args().First()
                          if str == "" {
                              return errors.New("Cannot add an empty task")
                          }
      
                          task := &Task{
                              ID:        primitive.NewObjectID(),
                              CreatedAt: time.Now(),
                              UpdatedAt: time.Now(),
                              Text:      str,
                              Completed: false,
                          }
      
                          return createTask(task)
                      },
                  },
                  {
                      Name:    "all",
                      Aliases: []string{"l"},
                      Usage:   "list all tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getAll()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `add 'task'` to add a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
                  {
                      Name:    "done",
                      Aliases: []string{"d"},
                      Usage:   "complete a task on the list",
                      Action: func(c *cli.Context) error {
                          text := c.Args().First()
                          return completeTask(text)
                      },
                  },
                  {
                      Name:    "finished",
                      Aliases: []string{"f"},
                      Usage:   "list completed tasks",
                      Action: func(c *cli.Context) error {
                          tasks, err := getFinished()
                          if err != nil {
                              if err == mongo.ErrNoDocuments {
                                  fmt.Print("Nothing to see here.nRun `done 'task'` to complete a task")
                                  return nil
                              }
      
                              return err
                          }
      
                          printTasks(tasks)
                          return nil
                      },
                  },
                  {
                      Name:  "rm",
                      Usage: "deletes a task on the list",
                      Action: func(c *cli.Context) error {
                          text := c.Args().First()
                          err := deleteTask(text)
                          if err != nil {
                              return err
                          }
      
                          return nil
                      },
                  },
              }
          }
      
          err := app.Run(os.Args)
          if err != nil {
              log.Fatal(err)
          }
      }
      . . .
      

      Comme pour toutes les autres sous-commandes ajoutées précédemment, la commande rm utilise son premier argument pour faire correspondre une tâche dans la base de données et la supprime.

      Enregistrez et fermez votre fichier

      Vous pouvez lister les tâches en attente en exécutant votre programme sans passer par des sous-commandes :

      Output

      1: Read a book

      L’exécution de la sous-commande rm sur la tâche "Read a book" la supprimera de la base de données :

      • go run main.go rm "Read a book"

      Si vous listez à nouveau toutes les tâches en attente, vous remarquerez que la tâche "Read a book" n’apparaît plus et qu’une invite à ajouter une nouvelle tâche est affichée à la place :

      Output

      Nothing to see here Run `add 'task'` to add a task

      Dans cette étape, vous avez ajouté une fonction permettant de supprimer des tâches de la base de données.

      Conclusion

      Vous avez créé avec succès un programme de ligne de commande de gestionnaire de tâches et appris les bases de l’utilisation du pilote MongoDB Go dans le processus.

      N’oubliez pas de consulter la documentation complète du pilote MongoDB Go sur GoDoc pour en savoir plus sur les fonctionnalités qu’offre l’utilisation du pilote. La documentation qui décrit l’utilisation des agrégats ou des transactions peut vous intéresser particulièrement.

      Le code final de ce tutoriel peut être consulté dans ce dépôt GitHub.



      Source link

      Comment créer une application web en utilisant Flask en Python 3


      L’auteur a choisi le Free and Open Source Fund pour recevoir un don dans le cadre du programme Write for Donations.

      Introduction

      Flask est un petit framework web Python léger, qui fournit des outils et des fonctionnalités utiles qui facilitent la création d’applications web en Python.  Il offre aux développeurs une certaine flexibilité et constitue un cadre plus accessible pour les nouveaux développeurs puisque vous pouvez construire rapidement une application web en utilisant un seul fichier Python. Flask est également extensible et ne force pas une structure de répertoire particulière ou ne nécessite pas de code standard compliqué avant de commencer.

      Dans le cadre de ce tutoriel, vous utiliserez la boîte à outils Bootstrap pour styliser votre application afin qu’elle soit plus attrayante visuellement. Bootstrap vous aidera à incorporer des pages web réactives dans votre application web afin qu’elle fonctionne également bien sur les navigateurs mobiles sans avoir à écrire votre propre code HTML, CSS et JavaScript pour atteindre ces objectifs. La boîte à outils vous permettra de vous concentrer sur l’apprentissage du fonctionnement de Flask.

      Flask utilise le moteur de modèle Jinja pour construire dynamiquement des pages HTML en utilisant des concepts Python familiers tels que les variables, les boucles, les listes, etc. Vous utiliserez ces modèles dans le cadre de ce projet.

      Dans ce tutoriel, vous allez construire un petit blog web en utilisant Flask et SQLite en Python 3. Les utilisateurs de l’application peuvent consulter tous les articles de votre base de données et cliquer sur le titre d’un article pour en voir le contenu, avec la possibilité d’ajouter un nouvel article à la base de données et de modifier ou supprimer un article existant.

      Conditions préalables

      Avant de commencer à suivre ce guide, vous aurez besoin des éléments suivants :

      Étape 1 – Installation de Flask

      Dans cette étape, vous allez activer votre environnement Python et installer Flask en utilisant l’installateur de paquets pip.

      Si vous n’avez pas encore activé votre environnement de programmation, assurez-vous que vous êtes dans le répertoire de votre projet (flask_blog) et utilisez la commande suivante pour activer l’environnement :

      Une fois que votre environnement de programmation est activé, votre invite aura maintenant un préfixe env qui peut ressembler à ce qui suit :

      Ce préfixe est une indication que l’environnement env est actuellement actif, qui peut avoir un autre nom selon la façon dont vous l’avez nommé lors de sa création.

      Remarque : vous pouvez utiliser Git, un système de contrôle de version pour gérer et suivre efficacement le processus de développement de votre projet. Pour apprendre à utiliser Git, vous pouvez consulter notre article Introduction à l’installation, l’utilisation et les branches de Git.

      Si vous utilisez Git, il est conseillé d’ignorer le répertoire env nouvellement créé dans votre fichier .gitignore pour éviter de suivre des fichiers non liés au projet.

      Vous allez maintenant installer des paquets Python et isoler le code de votre projet de l’installation principale du système Python. Vous ferez cela en utilisant pip et python.

      Pour installer Flask, exécutez la commande suivante :

      Une fois l’installation terminée, exécutez la commande suivante pour confirmer l’installation :

      • python -c "import flask; print(flask.__version__)"

      Vous utilisez l’interface en ligne de commande python avec l’option -c pour exécuter le code Python. Ensuite, vous importez le paquet flask avec import flask; puis vous imprimez la version de Flask, qui est fournie via la variable flask.__version__.

      La sortie sera un numéro de version semblable à ce qui suit :

      Output

      1.1.2

      Vous avez créé le dossier du projet, un environnement virtuel et installé Flask. Vous êtes maintenant prêt à configurer votre application de base.

      Étape 2 – Créer une application de base

      Maintenant que vous avez configuré votre environnement de programmation, vous allez commencer à utiliser Flask. Dans cette étape, vous allez créer une petite application web dans un fichier Python et l’exécuter pour démarrer le serveur, qui affichera certaines informations sur le navigateur.

      Dans votre répertoire flask_blog, ouvrez un fichier nommé hello.py pour le modifier, utilisez nano ou votre éditeur de texte préféré :

      Ce fichier hello.py servira d’exemple minimal de la manière de traiter les requêtes HTTP. À l’intérieur de ce fichier, vous importerez l’objet Flask et créerez une fonction qui renvoie une réponse HTTP.  Écrivez le code suivant à l’intérieur hello.py :

      flask_blog/hello.py

      from flask import Flask
      
      app = Flask(__name__)
      
      
      @app.route('/')
      def hello():
          return 'Hello, World!'
      

      Dans le bloc de code précédent, vous importez d’abord l’objet Flask du paquet flask. Vous l’utilisez ensuite pour créer votre instance d’application Flask avec le nom app. Vous passez la variable spéciale __name__ qui contient le nom du module Python actuel.  Il est utilisé pour indiquer à l’instance où elle se trouve – vous en avez besoin car Flask établit certains chemins en coulisses.

      Une fois que vous avez créé l’instance de l'application, vous l’utilisez pour traiter les demandes web entrantes et envoyer des réponses à l’utilisateur. @app.route est un décorateur qui transforme une fonction Python ordinaire en une fonction d’affichage Flask, qui convertit la valeur de retour de la fonction en une réponse HTTP à afficher par un client HTTP, tel qu’un navigateur web. Vous passez à la valeur '/' à @app.route() pour indiquer que cette fonction répondra aux requêtes web pour l’URL /, qui est l’URL principale.

      La fonction d’affichage hello() renvoie la chaîne "Hello, World!" comme réponse.

      Enregistrez et fermez le fichier.

      Pour exécuter votre application web, vous devez d’abord indiquer à Flask où trouver l’application (le fichier hello.py dans votre cas) avec la variable d’environnement FLASK_APP :

      Ensuite, exécutez-la en mode développement avec la variable d’environnement FLASK_ENV :

      • export FLASK_ENV=development

      Pour terminer, exécutez l’application en utilisant la commande flask run :

      Une fois l’application lancée, la sortie sera quelque chose comme ceci :

      Output

      * Serving Flask app "hello" (lazy loading) * Environment: development * Debug mode: on * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Restarting with stat * Debugger is active! * Debugger PIN: 813-894-335

      La sortie précédente contient plusieurs éléments d’information, tels que :

      • Le nom de l’application que vous exécutez.
      • L’environnement dans lequel l’application est exécutée.
      • Debug mode: onsignifie que le débogueur Flask est en cours d’exécution. Ceci est utile lors du développement car il nous donne des messages d’erreur détaillés lorsque les choses tournent mal, ce qui facilite le dépannage.
      • L’application s’exécute localement sur l’URL http://127.0.0.1:5000/, 127.0.0.1 est l’IP qui représente le localhost de votre machine et :5000 est le numéro du port.

      Ouvrez un navigateur et tapez l’URL http://127.0.0.1:5000/, vous recevrez la chaîne de caractères Hello, World! en réponse, cela confirme que votre application fonctionne correctement.

      Warning Flask utilise un simple serveur web pour servir notre application dans un environnement de développement, ce qui signifie également que le débogueur Flask est en cours d’exécution pour faciliter la capture des erreurs. Ce serveur de développement ne doit pas être utilisé dans un déploiement de production. Consultez la page des options de déploiement dans la documentation Flask pour plus d’informations, vous pouvez également consulter ce tutoriel sur le déploiement de Flask.

      Vous pouvez maintenant quitter le serveur de développement en cours d’exécution dans le terminal et ouvrir une autre fenêtre du terminal. Déplacez-vous dans le dossier du projet où hello.py se trouve, activez l’environnement virtuel, définissez les variables d’environnement FLASK_ENV et FLASK_APP, et passez aux étapes suivantes. (Ces commandes sont énumérées plus haut dans cette étape).

      Remarque : lors de l’ouverture d’un nouveau terminal, il est important de se souvenir d’activer l’environnement virtuel et de définir les variables d’environnement FLASK_ENV et FLASK_APP.

      Pendant que le serveur de développement d’une application Flask est déjà en cours d’exécution, il n’est pas possible d’exécuter une autre application Flask avec la même commande flask run. En effet, flask run utilise le numéro de port 5000 par défaut, et une fois qu’il est pris, il devient indisponible pour exécuter une autre application de sorte que vous recevriez une erreur similaire à la suivante :

      Output

      OSError: [Errno 98] Address already in use

      Pour résoudre ce problème, vous pouvez soit arrêter le serveur qui tourne actuellement via CTRL+C, puis relancer flask run, soit, si vous voulez exécuter les deux en même temps, vous pouvez passer un numéro de port différent à l’argument -p; par exemple, pour exécuter une autre application sur le port 5001, utilisez la commande suivante :

      Vous disposez maintenant d’une petite application web Flask. Vous avez lancé votre application et affiché des informations sur le navigateur web. Ensuite, vous allez utiliser des fichiers HTML dans votre application.

      Étape 3 – Utilisation des modèles HTML

      Actuellement, votre application n’affiche qu’un simple message sans aucun HTML. Les applications web utilisent principalement le HTML pour afficher des informations à l’intention du visiteur. Vous allez donc maintenant travailler à l’incorporation de fichiers HTML à votre application, qui pourront être affichés sur le navigateur web.

      Flask fournit une fonction d’aide render_template() qui permet l’utilisation du moteur de modèle Jinja. Cela facilitera grandement la gestion du HTML en écrivant votre code HTML dans des fichiers .html et en utilisant la logique dans votre code HTML. Vous allez utiliser ces fichiers HTML (modèles) pour construire toutes les pages de votre application, comme la page principale où vous afficherez les articles de blog en cours, la page de l’article de blog, la page où l’utilisateur peut ajouter un nouvel article, etc.

      Dans cette étape, vous allez créer votre application Flask principale dans un nouveau fichier.

      Tout d’abord, dans votre répertoire flask_blog, utilisez nano ou votre éditeur préféré pour créer et modifier votre fichier app.py. Ce fichier contiendra tout le code que vous utiliserez pour créer l’application de blog :

      Dans ce nouveau fichier, vous allez importer l’objet Flask pour créer une instance d’application Flask comme vous l’avez déjà fait. Vous importerez également la fonction d’aide render_template() qui vous permet de rendre les fichiers de modèles HTML qui existent dans le dossier des modèles que vous êtes en train de créer. Le fichier aura une fonction d’affichage unique qui sera responsable de la gestion des demandes vers la principale route /. Ajoutez le contenu suivant :

      flask_blog/app.py

      from flask import Flask, render_template
      
      app = Flask(__name__)
      
      @app.route('/')
      def index():
          return render_template('index.html')
      

      La fonction d’affichage index() renvoie le résultat de l’appel de render_template() avec index.html en argument, ce qui indique à render_template() qu’il doit rechercher un fichier appelé index.html dans le dossier des modèles. Le dossier et le fichier n’existent pas encore, vous obtiendrez une erreur si vous deviez exécuter l’application à ce stade. Vous l’exécuterez néanmoins afin de vous familiariser avec cette exception couramment rencontrée. Vous la corrigerez ensuite en créant le dossier et le fichier nécessaires.

      Enregistrez et quittez le fichier.

      Arrêtez le serveur de développement dans votre autre terminal qui exécute l’application hello avec CTRL+C.

      Avant d’exécuter l’application, assurez-vous de spécifier correctement la valeur de la variable d’environnement FLASK_APP, puisque vous n’utilisez plus l’application hello :

      • export FLASK_APP=app
      • flask run

      En ouvrant l’URL http://127.0.0.1:5000/ dans votre navigateur, la page du débogueur vous informera que le modèle index.html n’a pas été trouvé. La ligne principale du code responsable de cette erreur sera mise en évidence. Dans ce cas, il s’agit de la ligne return render_template('index.html').

      Si vous cliquez sur cette ligne, le débogueur vous révélera plus de code afin que vous disposiez de plus de contexte pour vous aider à résoudre le problème.

      Le débogueur Flask

      Pour corriger cette erreur, créez un répertoire appelé templates à l’intérieur de votre répertoire flask_blog. Ensuite, à l’intérieur de ce répertoire, ouvrez un fichier appelé index.html pour l’éditer :

      • mkdir templates
      • nano templates/index.html

      Ensuite, ajoutez le code HTML suivant dans index.html :

      flask_blog/templates/index.html

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>FlaskBlog</title>
      </head>
      <body>
         <h1>Welcome to FlaskBlog</h1>
      </body>
      </html>
      

      Enregistrez le fichier et utilisez votre navigateur pour naviguer à nouveau sur http://127.0.0.1:5000/, ou actualisez la page. Cette fois, le navigateur doit afficher le texte Welcome to FlaskBlog dans une balise <h1>.

      En plus du dossier templates, les applications web de Flask disposent généralement d’un dossier static pour l’hébergement des fichiers statiques, tels que les fichiers CSS, les fichiers JavaScript et les images utilisées par l’application.

      Vous pouvez créer un fichier de feuille de style style.css pour ajouter du CSS à votre application. Tout d’abord, créez un répertoire appelé static à l’intérieur de votre répertoire principal flask_blog :

      Ensuite, créez un autre répertoire appelé css à l’intérieur du répertoire static pour héberger les fichiers .css. Cela est généralement fait pour organiser les fichiers statiques dans des dossiers dédiés, comme par exemple, les fichiers JavaScript se trouvent généralement dans un répertoire appelé js, les images sont placées dans un répertoire appelé images (ou img), etc. La commande suivante créera le répertoire css à l’intérieur du répertoire static :

      Ouvrez ensuite un fichier style.css à l’intérieur du répertoire css pour l’éditer :

      • nano static/css/style.css

      Ajoutez la règle CSS suivante à votre fichier style.css :

      flask_blog/static/css/style.css

      h1 {
          border: 2px #eee solid;
          color: brown;
          text-align: center;
          padding: 10px;
      }
      

      Le code CSS ajoutera une bordure, changera la couleur en marron, centrera le texte et ajoutera un peu de padding aux balises <h1>.

      Enregistrez et fermez le fichier.

      Ensuite, ouvrez le fichier de modèle index.html pour le modifier :

      • nano templates/index.html

      Vous ajouterez un lien vers le fichier style.css à l’intérieur de la section <head> du fichier modèle index.html :

      flask_blog/templates/index.html

      . . .
      <head>
          <meta charset="UTF-8">
          <link rel="stylesheet" href="https://www.digitalocean.com/{{ url_for("static', filename= 'css/style.css') }}">
          <title>FlaskBlog</title>
      </head>
      . . .
      

      Ici, vous utilisez la fonction d’aide url_for() pour générer l’emplacement approprié du fichier. Le premier argument spécifie que vous créez un lien vers un fichier statique et que le deuxième argument est le chemin du fichier à l’intérieur du répertoire static.

      Enregistrez et fermez le fichier.

      En rafraîchissant la page d’index de votre application, vous remarquerez que le texte Welcome to FlaskBlog est maintenant en brun, centré et entouré d’une bordure.

      Vous pouvez utiliser le langage CSS pour styliser l’application et la rendre plus attrayante en utilisant votre propre design. Toutefois, si vous n’êtes pas un concepteur de sites web ou si vous ne connaissez pas le langage CSS, vous pouvez utiliser la boîte à outils Bootstrap, qui fournit des composants faciles à utiliser pour styliser votre application. Dans ce projet, nous utiliserons Bootstrap.

      Vous pourriez penser que la création d’un autre modèle HTML impliquerait la répétition de la plupart du code HTML que vous avez déjà écrit dans le modèle index.html. Vous pouvez éviter la répétition inutile du code à l’aide d’un fichier de modèle de base, dont tous vos fichiers HTML hériteront. Pour plus d’informations, voir la section Héritage de modèles dans Jinja.

      Pour créer un modèle de base, créez d’abord un fichier appelé base.html dans votre répertoire templates :

      Tapez le code suivant dans votre modèle base.html :

      flask_blog/templates/base.html

      <!doctype html>
      <html lang="en">
        <head>
          <!-- Required meta tags -->
          <meta charset="utf-8">
          <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
      
          <!-- Bootstrap CSS -->
          <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
      
          <title>{% block title %} {% endblock %}</title>
        </head>
        <body>
          <nav class="navbar navbar-expand-md navbar-light bg-light">
              <a class="navbar-brand" href="https://www.digitalocean.com/{{ url_for('index')}}">FlaskBlog</a>
              <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
                  <span class="navbar-toggler-icon"></span>
              </button>
              <div class="collapse navbar-collapse" id="navbarNav">
                  <ul class="navbar-nav">
                  <li class="nav-item active">
                      <a class="nav-link" href="https://www.digitalocean.com/#">About</a>
                  </li>
                  </ul>
              </div>
          </nav>
          <div class="container">
              {% block content %} {% endblock %}
          </div>
      
          <!-- Optional JavaScript -->
          <!-- jQuery first, then Popper.js, then Bootstrap JS -->
          <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
          <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js" integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous"></script>
          <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
        </body>
      </html>
      

      Enregistrez et fermez le fichier une fois que vous avez terminé de le modifier.

      La majeure partie du code du bloc précédent est du HTML standard et du code requis pour Bootstrap. Les balises <meta> fournissent des informations pour le navigateur web, la balise <link> relie les fichiers CSS de Bootstrap, et les balises <script> sont des liens vers le code JavaScript qui permet certaines fonctionnalités supplémentaires de Bootstrap, consultez la documentation de Bootstrap pour en savoir plus.

      Cependant, les parties surlignées suivantes sont spécifiques au moteur de template Jinja :

      • {% block title %} {% endblock %}​​​ : un bloc qui sert d’emplacement pour un titre, vous l’utiliserez plus tard dans d’autres modèles pour donner un titre personnalisé à chaque page de votre application sans réécrire à chaque fois toute la section <head>.
      • {{ url_for('index')}}: un appel de fonction qui renvoie l’URL pour la fonction d’affichage index(). Il est différent de l’ancien appel url_for() que vous utilisiez pour lier un fichier CSS statique, car il ne prend qu’un seul argument, qui est le nom de la fonction de visualisation, et renvoie à la route associée à la fonction au lieu d’un fichier statique.
      • {% block content %} {% endblock %}: un autre bloc qui sera remplacé par un contenu dépendant du modèle enfant (modèles qui héritent de base.html) qui le remplacera.

      Maintenant que vous avez un modèle de base, vous pouvez en tirer profit grâce à l’héritage. Ouvrez le fichier index.html :

      • nano templates/index.html

      Ensuite, remplacez son contenu par le suivant :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
      {% endblock %}
      

      Dans cette nouvelle version du modèle index.html, vous utilisez la balise {% extends %} pour hériter du modèle base.html. Vous l’étendez ensuite en remplaçant le bloc de contenu dans le modèle de base par ce qui se trouve à l’intérieur du bloc de contenu dans le bloc de code précédent.

      Ce bloc de contenu contient une balise <h1> avec le texte Welcome to FlaskBlog à l’intérieur d’un bloc de titre, qui à son tour remplace le bloc de titre original dans le modèle base.html par le texte Welcome to FlaskBlog. De cette façon, vous pouvez éviter de répéter deux fois le même texte, car il fonctionne à la fois comme un titre pour la page et un titre qui apparaît sous la barre de navigation héritée du modèle de base.

      L’héritage du modèle vous donne également la possibilité de réutiliser le code HTML que vous avez dans d’autres modèles (base.html dans ce cas) sans avoir à le répéter chaque fois que nécessaire.

      Enregistrez et fermez le fichier et rafraîchissez la page d’index sur votre navigateur. Vous verrez votre page avec une barre de navigation et un titre stylisé.

      Page d'index avec Bootstrap

      Vous avez utilisé des modèles HTML et des fichiers statiques dans Flask. Vous avez également utilisé Bootstrap pour commencer à affiner l’apparence de votre page et un modèle de base pour éviter la répétition du code. Dans l’étape suivante, vous allez configurer une base de données qui va stocker les données de votre application.

      Étape 4 – Mise en place de la base de données

      Au cours de cette étape, vous allez créer une base de données pour stocker les données, c’est-à-dire les articles de blog de votre application. Vous allez également remplir la base de données avec quelques exemples d’entrées.

      Vous utiliserez un fichier de base de données SQLite pour stocker vos données, car le module sqlite3, que nous utiliserons pour interagir avec la base de données, est disponible dans la bibliothèque standard Python. Pour plus d’informations sur SQLite, consultez ce tutoriel.

      Tout d’abord, comme les données dans SQLite sont stockées dans des tableaux et des colonnes, et comme vos données consistent principalement en des articles de blog, vous devez d’abord créer un tableau appelé posts (articles) avec les colonnes nécessaires. Vous allez créer un fichier .sql qui contient des commandes SQL pour créer le tableau posts avec quelques colonnes. Vous utiliserez ensuite ce fichier pour créer la base de données.

      Ouvrez un fichier appelé schema.sql à l’intérieur de votre répertoire flask_blog :

      Tapez les commandes SQL suivantes dans ce fichier :

      flask_blog/schema.sql

      DROP TABLE IF EXISTS posts;
      
      CREATE TABLE posts (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
          title TEXT NOT NULL,
          content TEXT NOT NULL
      );
      

      Enregistrez et fermez le fichier.

      La première commande SQL est DROP TABLE IF EXISTS posts; elle supprime toutes les tables déjà existantes nommées posts afin de ne pas créer de confusion. Notez que cela supprimera tout le contenu que vous avez dans la base de données chaque fois que vous utiliserez ces commandes SQL, donc assurez-vous de ne pas écrire de contenu important dans l’application web avant d’avoir terminé ce tutoriel et d’avoir expérimenté le résultat final. Ensuite, CREATE TABLE posts est utilisé pour créer la table posts avec les colonnes suivantes :

      • id : nombre entier qui représente une clé primaire, à laquelle la base de données attribuera une valeur unique pour chaque entrée (c’est-à-dire un billet de blog).
      • created : l’heure où le billet de blog a été créé. NOT NULL signifie que cette colonne ne doit pas être vide et la valeur DEFAULT est la valeur CURRENT_TIMESTAMP, qui est le moment où l’article a été ajouté à la base de données. Tout comme id, vous n’avez pas besoin de spécifier une valeur pour cette colonne, car elle sera automatiquement remplie.
      • title : le titre de l’article.
      • content : le contenu de l’article.

      Maintenant que vous avez un schéma SQL dans le fichier schema.sql, vous allez l’utiliserez pour créer la base de données à l’aide d’un fichier Python qui génèrera un fichier de base de données SQLite .db. Ouvrez un fichier nommé init_db.py dans le répertoire flask_blog en utilisant votre éditeur préféré :

      Ensuite, ajoutez le code suivant.

      flask_blog/init_db.py

      import sqlite3
      
      connection = sqlite3.connect('database.db')
      
      
      with open('schema.sql') as f:
          connection.executescript(f.read())
      
      cur = connection.cursor()
      
      cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
                  ('First Post', 'Content for the first post')
                  )
      
      cur.execute("INSERT INTO posts (title, content) VALUES (?, ?)",
                  ('Second Post', 'Content for the second post')
                  )
      
      connection.commit()
      connection.close()
      

      Vous importez d’abord le module sqlite3 et ouvrez ensuite une connexion à un fichier de base de données nommé base de database.db, qui sera créé une fois que vous aurez lancé le fichier Python. Ensuite, vous utilisez la fonction open() pour ouvrir le fichier schema.sql. Ensuite, vous exécutez son contenu en utilisant la méthode executescript() qui exécute plusieurs instructions SQL en une seule fois, ce qui créera la table posts. Vous créez un objet Cursor qui vous permet d’utiliser sa méthode execute() pour exécuter deux instructions SQL INSERT afin d’ajouter deux articles de blog à votre table posts.  Enfin, vous validez les modifications et coupez la connexion.

      Enregistrez et fermez le fichier et exécutez-le dans le terminal en utilisant la commande python :

      Une fois l’exécution du fichier terminée, un nouveau fichier appelé database.db apparaîtra dans votre répertoire flask_blog. Cela signifie que vous avez configuré avec succès votre base de données.

      Dans l’étape suivante, vous récupérerez les articles de blog que vous avez insérés dans votre base de données et les afficherez sur la page d’accueil de votre application.

      Étape 5 – Afficher tous les articles

      Maintenant que vous avez configuré votre base de données, vous pouvez modifier la fonction d’affichage index() pour afficher tous les articles que vous avez dans votre base de données.

      Ouvrez le fichier app.py pour apporter les modifications suivantes :

      Pour votre première modification, vous importerez le module sqlite3 en haut du fichier :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template
      
      . . .
      

      Ensuite, vous allez créer une fonction qui crée une connexion à la base de données et la renvoie. Ajoutez-la directement après l’importation :

      flask_blog/app.py

      . . .
      from flask import Flask, render_template
      
      def get_db_connection():
          conn = sqlite3.connect('database.db')
          conn.row_factory = sqlite3.Row
          return conn
      
      . . .
      

      Cette fonction get_db_connection() ouvre une connexion au fichier de base de données database.db, et définit ensuite l’attribut row_factory à sqlite3. Row afin que vous puissiez avoir un accès par nom aux colonnes. Cela signifie que la connexion à la base de données renverra des lignes qui se comporteront comme des dictionnaires Python normaux. Enfin, la fonction renvoie l’objet de connexion conn que vous utiliserez pour accéder à la base de données.

      Après avoir défini la fonction get_db_connection(), modifier la fonction index() pour qu’elle ressemble à ce qui suit :

      flask_blog/app.py

      . . .
      
      @app.route('/')
      def index():
          conn = get_db_connection()
          posts = conn.execute('SELECT * FROM posts').fetchall()
          conn.close()
          return render_template('index.html"https://www.digitalocean.com/, posts=posts)
      

      Dans cette nouvelle version de la fonction index(), vous ouvrez d’abord une connexion à la base de données en utilisant la fonction get_db_connection() que vous avez définie précédemment. Ensuite, vous exécutez une requête SQL pour sélectionner toutes les entrées de la table posts. Vous implémentez la méthode fetchall() pour récupérer toutes les lignes du résultat de la requête, celle-ci renvoie une liste des articles que vous avez insérés dans la base de données à l’étape précédente.

      Vous fermez la connexion à la base de données en utilisant la méthode close() et vous retournez le résultat du rendu du modèle index.html. Vous passez également l’objet posts en argument, lequel contient les résultats que vous avez obtenus de la base de données, ce qui vous permettra d’accéder aux articles de blog dans le modèle index.html.

      Une fois ces modifications apportées, enregistrez et fermez le fichier app.py.

      Maintenant que vous avez passé les articles que vous avez extraits de la base de données au modèle index.html, vous pouvez utiliser une boucle for pour afficher chaque article sur votre page d’index.

      Ouvrez le fichier index.html :

      • nano templates/index.html

      Ensuite, modifiez-le pour qu’il ressemble à :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
          {% for post in posts %}
              <a href="https://www.digitalocean.com/#">
                  <h2>{{ post['title'] }}</h2>
              </a>
              <span class="badge badge-primary">{{ post['created'] }}</span>
              <hr>
          {% endfor %}
      {% endblock %}
      

      Ici, la syntaxe {% for post in posts %} est un Jinja pour boucle, qui est similaire à un Python pour boucle sauf qu’il doit être fermé plus tard avec la syntaxe {% endfor %}. Vous utilisez cette syntaxe pour boucler sur chaque élément de la liste des messages qui a été passé par la fonction index() dans la ligne return render_template('index.html', posts=posts). Dans cette boucle for, vous affichez le titre de l’article dans un titre <h2> à l’intérieur d’une balise <a> (vous utiliserez plus tard cette balise pour faire un lien vers chaque article individuellement).

      Vous affichez le titre en utilisant un délimiteur de variable littérale ({{ ... }}). N’oubliez pas que post sera un objet de type dictionnaire, vous pouvez donc accéder au titre de l’article avec la balise post['title']. Vous affichez également la date de création l’article en utilisant la même méthode.

      Une fois que vous avez fini d’éditer le fichier, enregistrez-le et fermez-le. Ensuite, naviguez vers la page d’index de votre navigateur. Vous verrez les deux articles que vous avez ajoutés à la base de données sur votre page.

      Page d'index avec les articles affichés

      Maintenant que vous avez modifié la fonction d’affichage index() pour afficher tous les articles que vous avez dans la base de données sur la page d’accueil de votre application, vous allez afficher chaque article sur une seule page et permettre aux utilisateurs de se relier à chaque article.

      Étape 6 – Afficher un article unique

      Au cours de cette étape, vous allez créer un nouvel itinéraire Flask avec une fonction d’affichage et un nouveau modèle HTML pour afficher un article de blog individuel par son ID.

      À la fin de cette étape, l’URL http://127.0.0.1:5000/1 sera une page qui affichera le premier article (parce qu’il a l’ID 1). L’URL http://127.0.0.1:5000/ID affichera l’article avec le numéro ID associé s’il existe.

      Ouvrez app.py pour le modifier :

      Comme vous devrez obtenir un article de blog par son ID à partir de la base de données à plusieurs endroits plus tard dans ce projet, vous créerez une fonction autonome appelée get_post(). Vous pouvez l’appeler en lui passant un ID et recevoir en retour le billet associé à l’ID fourni, ou faire en sorte que Flask réponde avec un message 404 Not Found si le billet n’existe pas.

      Pour répondre avec une page 404, vous devez importer la fonction abort() de la bibliothèque Werkzeug, qui a été installée avec Flask, en haut du fichier :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template
      from werkzeug.exceptions import abort
      
      . . .
      

      Ensuite, ajoutez la fonction get_post() juste après la fonction get_db_connection() que vous avez créée à l’étape précédente :

      flask_blog/app.py

      . . .
      
      def get_db_connection():
          conn = sqlite3.connect('database.db')
          conn.row_factory = sqlite3.Row
          return conn
      
      
      def get_post(post_id):
          conn = get_db_connection()
          post = conn.execute('SELECT * FROM posts WHERE id = ?',
                              (post_id,)).fetchone()
          conn.close()
          if post is None:
              abort(404)
          return post
      
      . . .
      

      Cette nouvelle fonction a un argument post_id qui détermine quel article de blog doit être renvoyé.

      À l’intérieur de la fonction, vous utilisez la fonction get_db_connection() pour ouvrir une connexion à la base de données et exécuter une requête SQL pour obtenir l’article de blog associé à la valeur post_id donnée. Vous ajoutez la méthode fetchone() pour obtenir le résultat et le stocker dans la variable post, puis fermez la connexion. Si la variable post a la valeur None, ce qui signifie qu’aucun résultat n’a été trouvé dans la base de données, vous utilisez la fonction abort() que vous avez importée précédemment pour répondre avec un code d’erreur 404 et la fonction terminera son exécution. Si toutefois, un article a été trouvé, vous retournez la valeur de la variable post.

      Ensuite, ajoutez la fonction d’affichage suivante à la fin du fichier app.py :

      flask_blog/app.py

      . . .
      
      @app.route('/<int:post_id>')
      def post(post_id):
          post = get_post(post_id)
          return render_template('post.html', post=post)
      

      Dans cette nouvelle fonction de visualisation, vous ajoutez une règle de variable <int:post_id> pour spécifier que la partie après la barre oblique (/) est un entier positif (marqué avec le convertisseur int) auquel vous devez accéder dans votre fonction de visualisation. Flask reconnaît cela et passe sa valeur à l’argument du mot-clé post_id de votre fonction de visualisation post(). Vous utilisez ensuite la fonction get_post() pour obtenir l’article de blog associé à l’ID spécifié et stocker le résultat dans la variable post, que vous passez à un modèle post.html que vous allez bientôt créer.

      Enregistrez le fichier app.py et ouvrez un nouveau fichier de modèle post.html pour le modifier :

      Tapez le code suivant dans ce nouveau fichier post.html. Celui-ci sera similaire au fichier index.html, sauf qu’il n’affichera qu’un seul article, en plus d’afficher également le contenu de l’article :

      flask_blog/templates/post.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h2>{% block title %} {{ post['title'] }} {% endblock %}</h2>
          <span class="badge badge-primary">{{ post['created'] }}</span>
          <p>{{ post['content'] }}</p>
      {% endblock %}
      

      Vous ajoutez le bloc title que vous avez défini dans le modèle base.html pour que le titre de la page reflète en même temps le titre de l’article qui est affiché dans un titre <h2>.

      Enregistrez et fermez le fichier.

      Vous pouvez maintenant naviguer vers les URL suivantes pour voir les deux articles que vous avez dans votre base de données, ainsi qu’une page qui indique à l’utilisateur que l’article de blog demandé n’a pas été trouvé (puisqu’il n’y a pas d’article avec un numéro d’identification de 3 pour l’instant) :

      http://127.0.0.1:5000/1
      http://127.0.0.1:5000/2
      http://127.0.0.1:5000/3
      

      En retournant à la page d’index, vous ferez en sorte que le titre de chaque article renvoie à sa page respective. Vous ferez cela en utilisant la fonction url_for(). Tout d’abord, ouvrez le modèle index.html pour le modifier :

      • nano templates/index.html

      Ensuite, changez la valeur de l’attribut href de # à {{ url_for('post', post_id=post['id']) }} pour que la boucle for se présente exactement comme suit :

      flask_blog/templates/index.html

      {% for post in posts %}
          <a href="https://www.digitalocean.com/{{ url_for('post', post_id=post['id']) }}">
              <h2>{{ post['title'] }}</h2>
          </a>
          <span class="badge badge-primary">{{ post['created'] }}</span>
          <hr>
      {% endfor %}
      

      Ici, vous passez « post » à la fonction url_for() comme un premier argument. C’est le nom de la fonction d’affichage post() et comme elle accepte un argument post_id, vous lui donnez la valeur post['id']. La fonction url_for() renvoie l’URL appropriée pour chaque article en fonction de son ID.

      Enregistrez et fermez le fichier.

      Les liens de la page d’index fonctionneront désormais comme prévu. Vous avez maintenant terminé la construction de la partie de l’application responsable de l’affichage des articles de blog dans votre base de données. Ensuite, vous allez ajouter à votre application la possibilité de créer, de modifier et de supprimer des articles de blog.

      Étape 7 – Modification d’articles

      Maintenant que vous avez fini d’afficher les articles de blog présents dans la base de données sur l’application web, vous devez permettre aux utilisateurs de votre application d’écrire de nouveaux articles de blog et de les ajouter à la base de données, de modifier les articles existants et de supprimer les articles de blog inutiles.

      Créer un nouvel article

      À ce stade, vous disposez d’une application qui affiche les messages dans votre base de données mais qui ne vous permet pas d’ajouter un nouveau message, sauf si vous vous connectez directement à la base de données SQLite et que vous en ajoutez un manuellement. Dans cette section, vous allez créer une page sur laquelle vous pourrez créer un article en fournissant son titre et son contenu.

      Ouvrez le fichier app.py pour le modifier :

      Tout d’abord, vous allez importer ce qui suit depuis le framework Flask :

      • L’objet request global pour accéder aux données de la requête entrante qui sera soumise via un formulaire HTML.
      • La fonction url_for() pour générer des URL.
      • La fonction flash() pour afficher un message lorsqu’une requête est traitée.
      • La fonction redirect() pour rediriger le client vers un autre emplacement.

      Ajoutez les importations à votre fichier comme suit :

      flask_blog/app.py

      import sqlite3
      from flask import Flask, render_template, request, url_for, flash, redirect
      from werkzeug.exceptions import abort
      
      . . .
      

      La fonction flash() stocke les messages flashs dans la session du navigateur du client, ce qui nécessite la définition d’une clé secrète. Cette clé secrète est utilisée pour sécuriser les sessions, ce qui permet à Flask de se souvenir des informations d’une requête à l’autre, comme passer de la page du nouveau message à la page d’index. L’utilisateur peut accéder aux informations stockées dans la session, mais ne peut pas les modifier s’il ne dispose pas de la clé secrète, de sorte que vous ne devez jamais autoriser quiconque à accéder à votre clé secrète. Pour plus d’informations, consultez la documentation Flask pour les sessions.

      Pour définir une clé secrète, vous ajouterez une configuration SECRET_KEY à votre application via l’objet app.config. Ajoutez-la directement après la définition de l’app avant de définir la fonction de visualisation index() :

      flask_blog/app.py

      . . .
      app = Flask(__name__)
      app.config['SECRET_KEY'] = 'your secret key'
      
      
      @app.route('/')
      def index():
          conn = get_db_connection()
          posts = conn.execute('SELECT * FROM posts').fetchall()
          conn.close()
          return render_template('index.html', posts=posts)
      
      . . .
      

      N’oubliez pas que la clé secrète doit être une longue chaîne aléatoire.

      Après avoir défini une clé secrète, vous allez créer une fonction de visualisation qui rendra un modèle affichant un formulaire que vous pouvez remplir pour créer un nouveau article de blog. Ajoutez cette nouvelle fonction au bas du fichier :

      flask_blog/app.py

      . . .
      
      @app.route('/create', methods=('GET', 'POST'))
      def create():
          return render_template('create.html')
      

      Cela crée une route /create qui accepte les demandes GET et POST. Les requêtes GET sont acceptées par défaut. Pour accepter également les requêtes POST, qui sont envoyées par le navigateur lors de la soumission des formulaires, vous passerez un tuple avec les types de requêtes acceptés à l’argument methods du décorateur @app.route().

      Enregistrez et fermez le fichier.

      Pour créer le modèle, ouvrez un fichier appelé create.html dans votre dossier templates :

      • nano templates/create.html

      Ajoutez le code suivant dans ce nouveau fichier :

      flask_blog/templates/create.html

      {% extends 'base.html' %}
      
      {% block content %}
      <h1>{% block title %} Create a New Post {% endblock %}</h1>
      
      <form method="post">
          <div class="form-group">
              <label for="title">Title</label>
              <input type="text" name="title"
                     placeholder="Post title" class="form-control"
                     value="{{ request.form['title'] }}"></input>
          </div>
      
          <div class="form-group">
              <label for="content">Content</label>
              <textarea name="content" placeholder="Post content"
                        class="form-control">{{ request.form['content'] }}</textarea>
          </div>
          <div class="form-group">
              <button type="submit" class="btn btn-primary">Submit</button>
          </div>
      </form>
      {% endblock %}
      

      La majorité de ce code est du HTML standard. Il affichera une zone de saisie pour le titre du message, une zone de texte pour le contenu du message et un bouton pour soumettre le formulaire.

      La valeur du titre de l’article est {{ request.form['title'] }} et la zone de texte a la valeur {{ request.form['content'] }}, ceci afin que les données que vous entrez ne soient pas perdues si quelque chose se passe mal.  Par exemple, si vous écrivez un long article et que vous oubliez de lui donner un titre, un message s’affiche pour vous informer que le titre est requis. Cela se produira sans perdre le message que vous avez écrit puisqu’il sera stocké dans l’objet request global auquel vous avez accès dans vos modèles.

      Maintenant que le serveur de développement tourne, utilisez votre navigateur pour accéder à la route /create :

      http://127.0.0.1:5000/create
      

      Vous verrez une page Create a New Post avec une boîte pour un titre et un contenu.

      Créer une nouvelle page d'article

      Ce formulaire soumet une demande POST à votre fonction create() view. Cependant, il n’y a pas encore de code pour traiter une demande POST dans la fonction, donc rien ne se passe après avoir rempli le formulaire et l’avoir soumis.

      Vous traiterez la requête POST entrante lorsqu’un formulaire sera soumis. Vous ferez cela à l’intérieur de la fonction de visualisation create(). Vous pouvez traiter la demande POST séparément en vérifiant la valeur de request.method. Lorsque sa valeur est réglée sur 'POST', elle signifie que la requête est une requête POST, vous allez ensuite continuer à extraire les données soumises, le valider et l’insérer dans votre base de données.

      Ouvrez le fichier app.py pour le modifier :

      Modifiez la fonction de visualisation create() pour qu’elle ressemble exactement à ce qui suit :

      flask_blog/app.py

      . . .
      
      @app.route('/create', methods=('GET', 'POST'))
      def create():
          if request.method == 'POST':
              title = request.form['title']
              content = request.form['content']
      
              if not title:
                  flash('Title is required!')
              else:
                  conn = get_db_connection()
                  conn.execute('INSERT INTO posts (title, content) VALUES (?, ?)',
                               (title, content))
                  conn.commit()
                  conn.close()
                  return redirect(url_for('index'))
      
          return render_template('create.html')
      

      Dans la déclaration if, vous devez vous assurer que le code qui suit n’est exécuté que lorsque la demande est une demande POST via la comparaison request.method == 'POST'.

      Vous extrayez ensuite le titre et le contenu soumis de l’objet request.form qui vous donne accès aux données du formulaire dans la demande. Si le titre n’est pas fourni, la condition if not title serait remplie, en affichant un message à l’utilisateur l’informant que le titre est requis. Si, en revanche, le titre est fourni, vous ouvrez une connexion avec la fonction get_db_connection() et insérez le titre et le contenu que vous avez reçu dans le tableau posts.

      Vous validez ensuite les modifications dans la base de données et coupez la connexion. Après avoir ajouté l’article de blog à la base de données, vous redirigez le client vers la page d’index en utilisant la fonction redirect() en lui passant l’URL générée par la fonction url_for() avec la valeur 'index' en argument.

      Enregistrez et fermez le fichier.

      Maintenant, naviguez vers la route /create en utilisant votre navigateur web :

      http://127.0.0.1:5000/create
      

      Remplissez le formulaire avec un titre de votre choix et un peu de contenu. Une fois que vous avez soumis le formulaire, vous verrez le nouveau article listé sur la page d’index.

      Enfin, vous afficherez des messages clignotants et ajouterez un lien vers la barre de navigation dans le modèle base.html pour accéder facilement à cette nouvelle page. Ouvrez le fichier modèle :

      Modifiez le fichier en ajoutant une nouvelle balise <li> à la suite du lien “About” à l’intérieur de la balise <nav>. Ensuite, ajoutez un nouveau for loop directement au-dessus du bloc content pour afficher les messages clignotants sous la barre de navigation. Ces messages sont disponibles dans la fonction spéciale get_flashed_messages() que Flask fournit :

      flask_blog/templates/base.html

      <nav class="navbar navbar-expand-md navbar-light bg-light">
          <a class="navbar-brand" href="https://www.digitalocean.com/{{ url_for("index')}}">FlaskBlog</a>
          <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
              <span class="navbar-toggler-icon"></span>
          </button>
          <div class="collapse navbar-collapse" id="navbarNav">
              <ul class="navbar-nav">
              <li class="nav-item">
                  <a class="nav-link" href="https://www.digitalocean.com/#">About</a>
              </li>
              <li class="nav-item">
                  <a class="nav-link" href="https://www.digitalocean.com/{{url_for("create')}}">New Post</a>
              </li>
              </ul>
          </div>
      </nav>
      <div class="container">
          {% for message in get_flashed_messages() %}
              <div class="alert alert-danger">{{ message }}</div>
          {% endfor %}
          {% block content %} {% endblock %}
      </div>
      

      Enregistrez et fermez le fichier. La barre de navigation comportera désormais un élément New Post qui renvoie à la route /create.

      Éditer un message

      Pour qu’un blog soit à jour, vous devez être en mesure de modifier vos articles existants. Cette section vous guidera dans la création d’une nouvelle page dans votre application afin de simplifier le processus de modification d’un article.

      Tout d’abord, vous allez ajouter une nouvelle route au fichier app.py. Sa fonction de visualisation recevra l’ID du message qui doit être édité, l’URL sera au format /post_id/edit avec la variable post_id étant l’ID du message. Ouvrez le fichier app.py pour le modifier :

      Ensuite, ajoutez la fonction d’affichage edit() suivante à la fin du fichier. L’édition d’un article existant est similaire à la création d’un nouvel article, donc cette fonction de visualisation sera similaire à la fonction de visualisation create() :

      flask_blog/app.py

      . . .
      
      @app.route('/<int:id>/edit', methods=('GET', 'POST'))
      def edit(id):
          post = get_post(id)
      
          if request.method == 'POST':
              title = request.form['title']
              content = request.form['content']
      
              if not title:
                  flash('Title is required!')
              else:
                  conn = get_db_connection()
                  conn.execute('UPDATE posts SET title = ?, content = ?'
                               ' WHERE id = ?',
                               (title, content, id))
                  conn.commit()
                  conn.close()
                  return redirect(url_for('index'))
      
          return render_template('edit.html', post=post)
      

      L article que vous éditez est déterminé par l’URL et Flask passera le numéro d’identification à la fonction edit() via l’argument id. Vous ajoutez cette valeur à la fonction get_post() pour récupérer le message associé à l’ID fourni de la base de données. Les nouvelles données seront envoyées dans une requête POST, qui est traitée dans la condition if request.method == 'POST'.

      Tout comme lorsque vous créez un nouveau message, vous extrayez d’abord les données de l’objet request.form, puis vous envoyez un message si le titre a une valeur vide, sinon, vous ouvrez une connexion à la base de données. Ensuite, vous mettez à jour le tableau posts en définissant un nouveau titre et un nouveau contenu où l’ID de l’article dans la base de données est égal à l’ID qui se trouvait dans l’URL.

      Dans le cas d’une requête GET, vous rendez un modèle edit.html en passant dans la variable post qui contient la valeur retournée par la fonction get_post(). Vous l’utiliserez pour afficher le titre et le contenu existants sur la page d’édition.

      Enregistrez et fermez le fichier, puis créez un nouveau modèle edit.html :

      Ecrivez le code suivant dans ce nouveau fichier :

      flask_blog/templates/edit.html

      {% extends 'base.html' %}
      
      {% block content %}
      <h1>{% block title %} Edit "{{ post['title'] }}" {% endblock %}</h1>
      
      <form method="post">
          <div class="form-group">
              <label for="title">Title</label>
              <input type="text" name="title" placeholder="Post title"
                     class="form-control"
                     value="{{ request.form['title'] or post['title'] }}">
              </input>
          </div>
      
          <div class="form-group">
              <label for="content">Content</label>
              <textarea name="content" placeholder="Post content"
                        class="form-control">{{ request.form['content'] or post['content'] }}</textarea>
          </div>
          <div class="form-group">
              <button type="submit" class="btn btn-primary">Submit</button>
          </div>
      </form>
      <hr>
      {% endblock %}
      

      Enregistrez et fermez le fichier.

      Ce code suit le même modèle, à l’exception de la syntaxe {{ request.form['title'] ou post['title'] }} et {{ request.form['content'] ou post['content'] }}. Cela affiche les données stockées dans la requête si elles existent, sinon, cela affiche les données de la variable post qui a été passée au modèle contenant les données actuelles de la base de données.

      Maintenant, naviguez vers l’URL suivante pour modifier le premier article :

      http://127.0.0.1:5000/1/edit
      

      Vous verrez une page Edit “First Post”.

      Modifier la page d'un article

      Modifiez l’article et soumettez le formulaire, puis assurez-vous que l’article a été mis à jour.

      Vous devez maintenant ajouter un lien qui pointe vers la page d’édition pour chaque article sur la page d’index. Ouvrez le fichier modèle index.html :

      • nano templates/index.html

      Modifiez le fichier pour qu’il ressemble exactement à ce qui suit :

      flask_blog/templates/index.html

      {% extends 'base.html' %}
      
      {% block content %}
          <h1>{% block title %} Welcome to FlaskBlog {% endblock %}</h1>
          {% for post in posts %}
              <a href="https://www.digitalocean.com/{{ url_for("post', post_id=post['id']) }}">
                  <h2>{{ post['title'] }}</h2>
              </a>
              <span class="badge badge-primary">{{ post['created'] }}</span>
              <a href="https://www.digitalocean.com/{{ url_for("edit', id=post['id']) }}">
                  <span class="badge badge-warning">Edit</span>
              </a>
              <hr>
          {% endfor %}
      {% endblock %}
      

      Enregistrez et fermez le fichier.

      Ici, vous ajoutez une balise <a> pour faire un lien vers la fonction de visualisation edit(), en passant la valeur post['id'] pour faire un lien vers la page d’édition de chaque article avec le lien Edit.

      Suppression d’un article

      Parfois, un article n’a plus besoin d’être accessible au public, c’est pourquoi la fonctionnalité de suppression d’un article est cruciale. Au cours de cette étape, vous allez ajouter la fonctionnalité de suppression à votre application.

      Tout d’abord, vous allez ajouter une nouvelle route /ID/delete qui accepte les requêtes POST, similaire à la fonction de visualisation edit(). Votre nouvelle fonction de visualisation delete() recevra l’ID du message à supprimer de l’URL. Ouvrez le fichier app.py :

      Ajoutez la fonction de visualisation suivante au bas du fichier :

      flask_blog/app.py

      # ....
      
      @app.route('/<int:id>/delete', methods=('POST',))
      def delete(id):
          post = get_post(id)
          conn = get_db_connection()
          conn.execute('DELETE FROM posts WHERE id = ?', (id,))
          conn.commit()
          conn.close()
          flash('"{}" was successfully deleted!'.format(post['title']))
          return redirect(url_for('index'))
      

      Cette fonction de visualisation n’accepte que les requêtes POST. Cela signifie que la navigation vers la route /ID/delete sur votre navigateur renvoie une erreur, car les navigateurs web acceptent par défaut les requêtes GET.

      Cependant, vous pouvez accéder à cette route via un formulaire qui envoie une requête POST passant l’ID de l’article que vous voulez supprimer. La fonction recevra la valeur de l’ID et l’utilisera pour récupérer l’article dans la base de données avec la fonction get_post().

      Ensuite, vous ouvrez une connexion à la base de données et exécutez une commande SQL DELETE FROM pour supprimer l’article. Vous validez la modification dans la base de données et fermez la connexion tout en faisant clignoter un message pour informer l’utilisateur que le message a été supprimé avec succès et le rediriger vers la page d’index.

      Notez que vous ne rendez pas un fichier modèle, ceci est dû au fait que vous allez juste ajouter un bouton Delete à la page d’édition.

      Ouvrez le fichier modèle edit.html :

      Ensuite, ajoutez la balise <form> suivante après la balise <hr> et directement avant la ligne {% endblock %} :

      flask_blog/templates/edit.html

      <hr>
      
      <form action="https://www.digitalocean.com/{{ url_for("delete', id=post['id']) }}" method="POST">
          <input type="submit" value="Delete Post"
                  class="btn btn-danger btn-sm"
                  onclick="return confirm('Are you sure you want to delete this post?')">
      </form>
      
      {% endblock %}
      

      Vous utilisez la méthode confirm() pour afficher un message de confirmation avant de soumettre la demande.

      Maintenant, naviguez à nouveau vers la page d’édition d’un article de blog et essayez de le supprimer :

      http://127.0.0.1:5000/1/edit
      

      À la fin de cette étape, le code source de votre projet ressemblera au code de cette page.

      Grâce à cela, les utilisateurs de votre application peuvent maintenant écrire de nouveaux articles de blog et les ajouter à la base de données, modifier et supprimer des articles existants.

      Conclusion

      Ce tutoriel a introduit les concepts essentiels du framework Flask Python. Vous avez appris à créer une petite application web, à l’exécuter dans un serveur de développement et à permettre à l’utilisateur de fournir des données personnalisées via des paramètres d’URL et des formulaires web. Vous avez également utilisé le moteur de modèles Jinja pour réutiliser les fichiers HTML et y utiliser la logique. À la fin de ce tutoriel, vous disposez maintenant d’un blog web entièrement fonctionnel qui interagit avec une base de données SQLite pour créer, afficher, modifier et supprimer des articles de blog en utilisant le langage Python et des requêtes SQL.

      Vous pouvez développer davantage cette application en ajoutant l’authentification des utilisateurs afin que seuls les utilisateurs enregistrés puissent créer et modifier des articles de blog, vous pouvez également ajouter des commentaires et des balises pour chaque article de blog, et ajouter des téléchargements de fichiers pour donner aux utilisateurs la possibilité d’inclure des images dans l’article. Pour plus d’informations, consultez la documentation Flask.

      Flask possède de nombreuses extensions Flask créées par sa communauté. Voici une liste d’extensions que vous pourriez envisager d’utiliser pour faciliter votre processus de développement :

      • Flask-Login : gère la session utilisateur et gère la connexion et la déconnexion ainsi que la mémorisation des utilisateurs connectés.
      • Flask-SQLAlchemy : simplifie l’utilisation de Flask avec SQLAlchemy, une boîte à outils SQL Python et un ORM (mappeur relationnel d’objets) pour interagir avec les bases de données SQL.
      • Flask-Mail : aide à l’envoi de messages électroniques dans votre application Flask.



      Source link