Jonathan SAEZ

Content Security Policy (CSP) : contrôler les ressources chargées par votre site

2026-04-06T00:00:00+00:00

Vous développez une application web, vous avez mis en place HTTPS, peut-être même HSTS. Votre serveur est à jour, vos dépendances aussi. Et pourtant, une simple faille XSS peut suffire à compromettre vos utilisateurs. Un script malveillant injecté dans une page, et c’est le vol de session, le redirect vers un site de phishing ou l’exfiltration de données sensibles.

Les failles Cross-Site Scripting (XSS) restent parmi les vulnérabilités les plus fréquentes sur le web. Elles exploitent un principe simple : le navigateur fait confiance à tout ce que le serveur lui envoie. Si un attaquant parvient à glisser du code dans votre page, le navigateur l’exécute sans poser de questions.

C’est précisément là qu’intervient la Content Security Policy. CSP permet de dire au navigateur : “voici les sources autorisées pour charger des scripts, des styles, des images, des fonts… tout le reste, tu bloques.” Historiquement pensée pour contrer les XSS, la CSP va en réalité bien au-delà : contrôle du chargement des iframes, protection contre le clickjacking, détection du mixed content HTTP/HTTPS, et même surveillance des violations via un système de reporting.

Nous allons voir ensemble comment fonctionne CSP, quelles directives utiliser, comment la déployer progressivement sans casser votre site, et surtout quelles erreurs éviter.

Sommaire

Pourquoi vos pages web sont vulnérables
Content Security Policy : le principe
Les directives CSP essentielles
Tester sans casser : le mode Report-Only
Les erreurs qui rendent votre CSP inutile
Mettre en place CSP concrètement

Pourquoi vos pages web sont vulnérables

Par défaut, un navigateur charge et exécute tout ce qu’une page HTML lui demande. Un <script> inline ? Exécuté. Une image chargée depuis un domaine inconnu ? Affichée. Un iframe pointant vers un site tiers ? Rendu. Le navigateur ne fait aucune distinction entre le contenu légitime et le contenu injecté par un attaquant.

Les failles XSS exploitent exactement ce comportement. On distingue généralement trois variantes :

XSS Stored (persistant) : le code malveillant est stocké côté serveur (en base de données par exemple) et servi à chaque visiteur. Un commentaire piégé sur un forum en est l’exemple classique.
XSS Reflected : le code est injecté via l’URL ou un paramètre de requête, puis renvoyé dans la réponse du serveur sans être stocké. Typiquement via un lien piégé envoyé par email.
XSS DOM-based : l’injection se produit côté client, directement dans le DOM, sans passer par le serveur. Le JavaScript de la page manipule des données non fiables (fragment d’URL, document.referrer…) sans les assainir.

Dans les trois cas, le résultat est le même : du code JavaScript arbitraire s’exécute dans le contexte de votre page, avec accès aux cookies, au DOM, et potentiellement aux tokens d’authentification de vos utilisateurs.

La validation et l’échappement des entrées utilisateur restent évidemment la première ligne de défense. Mais une seule erreur, un seul oubli dans un template, et la porte est ouverte. CSP agit comme un filet de sécurité supplémentaire : même si du code malveillant parvient à s’injecter dans votre HTML, le navigateur refusera de l’exécuter si la politique ne l’autorise pas.

Content Security Policy : le principe

CSP fonctionne de manière très simple. Votre serveur envoie un en-tête HTTP Content-Security-Policy avec la réponse. Cet en-tête contient une liste de directives qui indiquent au navigateur quelles sources sont autorisées pour chaque type de ressource.

Concrètement, quand le navigateur reçoit cet en-tête :

Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.exemple.com

Il comprend : “pour cette page, charge les ressources uniquement depuis l’origine du site ('self'), et autorise les scripts depuis le site lui-même et depuis https://cdn.exemple.com. Tout le reste est bloqué.”

Si un attaquant injecte un <script src="https://evil.com/malware.js"> dans votre page, le navigateur le bloquera car evil.com n’est pas dans la liste des sources autorisées pour les scripts. Idem pour un <script>alert('xss')</script> inline : par défaut, CSP interdit l’exécution de scripts inline.

Il existe deux façons de déclarer une CSP :

Via l’en-tête HTTP (recommandé) : le serveur ajoute Content-Security-Policy dans les headers de la réponse.
Via une balise <meta> : directement dans le HTML avec <meta http-equiv="Content-Security-Policy" content="...">.

Personnellement je vous conseille l’en-tête HTTP. La balise <meta> a des limitations : elle ne supporte pas certaines directives comme frame-ancestors ou report-uri, et elle peut être contournée si l’attaquant parvient à injecter du HTML avant la balise <meta>.

Les directives CSP essentielles

CSP propose un ensemble de directives, chacune contrôlant un type de ressource spécifique. Nous n’allons pas toutes les lister ici, mais voici celles que vous utiliserez le plus souvent :

Directive	Contrôle	Exemple
`default-src`	Politique par défaut pour toutes les ressources non spécifiées	`default-src 'self'`
`script-src`	Sources autorisées pour les scripts JavaScript	`script-src 'self' https://cdn.exemple.com`
`style-src`	Sources autorisées pour les feuilles de style CSS	`style-src 'self' 'unsafe-inline'`
`img-src`	Sources autorisées pour les images	`img-src 'self' data: https:`
`connect-src`	Cibles autorisées pour les requêtes XHR, Fetch, WebSocket	`connect-src 'self' https://api.exemple.com`
`font-src`	Sources autorisées pour les polices de caractères	`font-src 'self' https://fonts.gstatic.com`
`frame-ancestors`	Qui peut intégrer votre page dans une iframe	`frame-ancestors 'none'`
`object-src`	Sources pour les plugins (Flash, Java…)	`object-src 'none'`
`base-uri`	Valeurs autorisées pour la balise `<base>`	`base-uri 'self'`

La directive default-src est fondamentale. Elle sert de politique de repli : si vous ne définissez pas script-src, c’est default-src qui s’applique aux scripts. Personnellement je vous conseille de toujours commencer par default-src 'self' puis d’ouvrir au cas par cas.

Les valeurs les plus courantes que vous pouvez attribuer à ces directives :

'self' : autorise les ressources provenant de la même origine (même schéma, domaine et port).
'none' : bloque tout. Utile pour object-src par exemple, puisque les plugins sont rarement nécessaires aujourd’hui.
https://domaine.com : autorise un domaine spécifique.
data: : autorise les ressources en data URI (images en base64 par exemple).
'unsafe-inline' : autorise les scripts ou styles inline. À éviter autant que possible (nous y reviendrons).

Un exemple de CSP raisonnablement stricte pour un site classique :

Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' https://fonts.gstatic.com; object-src 'none'; frame-ancestors 'self'; base-uri 'self'

Tester sans casser : le mode Report-Only

Déployer une CSP sur un site existant sans préparation, c’est la garantie de casser des fonctionnalités. Un script tiers oublié, un style inline dans un vieux template, une image chargée depuis un CDN non listé, et voilà des éléments de votre page qui disparaissent silencieusement.

C’est pour ça que l’en-tête Content-Security-Policy-Report-Only existe. Il fonctionne exactement comme Content-Security-Policy, mais au lieu de bloquer les ressources non conformes, il se contente de signaler les violations. Votre site continue de fonctionner normalement, et vous collectez les informations nécessaires pour affiner votre politique.

Content-Security-Policy-Report-Only: default-src 'self'; script-src 'self'; report-uri /csp-report

Avec cette configuration, le navigateur envoie un rapport JSON à /csp-report à chaque fois qu’une ressource viole la politique. Voici à quoi ressemble un rapport typique :

{
  "csp-report": {
    "document-uri": "https://monsite.com/page",
    "referrer": "",
    "violated-directive": "script-src 'self'",
    "effective-directive": "script-src",
    "original-policy": "default-src 'self'; script-src 'self'; report-uri /csp-report",
    "blocked-uri": "https://cdn.tracker-inconnu.com/analytics.js",
    "status-code": 200
  }
}

Ce rapport nous dit clairement que la page /page a tenté de charger un script depuis cdn.tracker-inconnu.com, ce qui viole la directive script-src 'self'. À partir de là, deux choix : soit vous ajoutez ce domaine à votre politique parce que c’est un script légitime (un outil analytics par exemple), soit vous confirmez que c’est bien un chargement non désiré et vous gardez la restriction.

Collecter les rapports

Pour réceptionner ces rapports, il vous faut un endpoint capable de recevoir du JSON en POST. Un exemple minimaliste en Node.js :

app.post('/csp-report', express.json({ type: 'application/csp-report' }), (req, res) => {
  console.log('Violation CSP :', req.body['csp-report']);
  res.status(204).end();
});

En pratique, sur un site avec du trafic, vous allez recevoir beaucoup de rapports (les extensions navigateur déclenchent souvent des violations). Personnellement je vous conseille de stocker les rapports en base et de les agréger par blocked-uri et violated-directive pour repérer rapidement les patterns significatifs et filtrer le bruit.

L’approche progressive

Déployez votre CSP en mode Report-Only.
Analysez les rapports pendant quelques jours ou semaines.
Ajustez les directives en fonction des violations légitimes.
Une fois la politique stabilisée, passez en mode actif avec Content-Security-Policy.

Vous pouvez d’ailleurs utiliser les deux en-têtes simultanément : garder votre CSP active en production et tester une politique plus stricte en Report-Only. C’est l’approche incrémentale idéale pour renforcer progressivement votre sécurité sans jamais prendre le risque de casser des fonctionnalités.

Les erreurs qui rendent votre CSP inutile

Avoir un en-tête CSP ne signifie pas que votre site est protégé. Une CSP mal configurée donne un faux sentiment de sécurité. Voici les erreurs les plus fréquentes.

Utiliser unsafe-inline pour les scripts

C’est l’erreur la plus courante et la plus grave. script-src 'unsafe-inline' autorise l’exécution de n’importe quel script inline dans votre page. Or, c’est exactement le vecteur d’attaque principal des XSS. Avec cette directive, votre CSP ne protège plus contre grand-chose.

/* À ne surtout pas faire */
Content-Security-Policy: script-src 'self' 'unsafe-inline'

Si vous avez besoin d’exécuter des scripts inline (et c’est souvent le cas avec des frameworks ou des outils analytics), préférez l’approche par nonce ou par hash plutôt que d’ouvrir la porte avec unsafe-inline.

Le nonce est une valeur aléatoire générée à chaque requête par le serveur. Elle est ajoutée à la fois dans l’attribut nonce du script et dans la directive CSP. Le navigateur n’exécute que les scripts dont le nonce correspond :

<script nonce="abc123random">
  // Ce script sera autorisé car le nonce correspond
</script>

Content-Security-Policy: script-src 'self' 'nonce-abc123random'

Le nonce doit impérativement être unique à chaque réponse HTTP. Si vous réutilisez le même nonce, un attaquant qui le découvre peut l’exploiter pour injecter ses propres scripts.

Le hash fonctionne différemment : au lieu d’un token aléatoire, vous calculez l’empreinte SHA du contenu exact du script. Le navigateur compare le hash du script inline avec celui déclaré dans la CSP. Si ça correspond, le script s’exécute.

<script>
  var message = "Bienvenue";
</script>

Pour générer le hash, vous calculez le SHA-256 du contenu du script (ici var message = "Bienvenue";) puis vous l’encodez en base64. La directive ressemble à ça :

Content-Security-Policy: script-src 'self' 'sha256-xyz...base64...'

Quand utiliser l’un ou l’autre ? Le nonce est plus adapté quand vos scripts inline changent régulièrement ou sont générés dynamiquement côté serveur. Le hash convient mieux aux scripts inline qui ne changent jamais (un snippet analytics figé, par exemple). Dans les deux cas, c’est nettement plus sûr que unsafe-inline.

Utiliser unsafe-eval

unsafe-eval autorise les fonctions comme eval(), new Function(), ou setTimeout avec une chaîne de caractères. Ces fonctions permettent d’exécuter du code JavaScript généré dynamiquement, ce qui est un vecteur d’attaque classique. Il faut éviter cette directive sauf nécessité absolue.

Oublier default-src

Sans default-src, toute directive non explicitement définie n’a aucune restriction. Si vous définissez script-src et style-src mais oubliez default-src, les images, polices, iframes et connexions réseau ne sont pas contrôlées. Un attaquant pourrait par exemple utiliser un élément <object> pour exécuter du code malveillant.

Utiliser des wildcards trop larges

script-src * ou script-src https: reviennent à ne rien restreindre du tout. Même script-src *.cdn.com peut poser problème si l’attaquant trouve un sous-domaine vulnérable ou un endpoint JSONP sur ce CDN.

Soyez aussi spécifique que possible dans vos sources autorisées. Listez les domaines exacts plutôt que d’utiliser des patterns trop permissifs.

Mettre en place CSP concrètement

La configuration se fait au niveau du serveur web. Voici les exemples les plus courants.

Nginx

add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none'; frame-ancestors 'self';" always;

Apache

Header set Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none'; frame-ancestors 'self';"

Balise meta (alternative)

<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none';">

Gardez en tête que la balise meta ne supporte pas frame-ancestors ni les directives de reporting. L’en-tête HTTP reste la méthode à privilégier.

L’approche itérative

Il faut éviter de vouloir tout verrouiller d’un coup. Voici une approche pragmatique :

Commencez large : Content-Security-Policy-Report-Only: default-src 'self' https: 'unsafe-inline'. Ça ne bloque rien mais vous donne une base de départ.
Analysez les rapports : identifiez les scripts tiers, les styles inline, les ressources externes légitimes.
Restreignez progressivement : remplacez https: par les domaines exacts, remplacez 'unsafe-inline' par des nonces si possible.
Passez en mode actif : une fois la politique stabilisée, basculez sur Content-Security-Policy.
Surveillez en continu : gardez le reporting actif même après le déploiement.

Maintenant que nous avons vu les bases, n’oubliez pas que CSP ne fonctionne pas en isolation. C’est une couche de défense parmi d’autres. Combinée avec HTTPS, HSTS, la validation des entrées, et des headers comme X-Frame-Options ou X-Content-Type-Options, elle participe à une stratégie de sécurité cohérente. CSP n’empêchera pas toutes les attaques, mais elle réduit considérablement la surface d’exploitation, et c’est déjà beaucoup.

Obsidian : le second cerveau taillé pour les développeurs

2026-02-08T00:00:00+00:00

Nous avons tous le même problème : des notes éparpillées entre des fichiers texte, des signets oubliés, des bouts de documentation perdus dans Slack et des idées griffonnées quelque part qu’on ne retrouve jamais. En tant que développeur, la quantité d’informations techniques à retenir est colossale. Langages, frameworks, configurations serveur, commandes obscures qu’on utilise deux fois par an… Impossible de tout garder en tête.

C’est exactement là qu’intervient le concept de second cerveau : un système externe pour capturer, organiser et retrouver ses connaissances. Et parmi les outils disponibles, Obsidian se démarque nettement pour les profils techniques. Pas parce qu’il est à la mode, mais parce que sa philosophie colle parfaitement avec notre façon de travailler.

Sommaire

C’est quoi Obsidian exactement
Le second cerveau : pourquoi c’est pertinent pour un développeur
Repenser le classement : les liens plutôt que les dossiers
La vue graphe : visualiser ses connaissances
Obsidian vs Notion : comparaison pragmatique
Les plugins essentiels pour les développeurs
Ce qui peut manquer
Pour qui Obsidian est fait, et pour qui il ne l’est pas

C’est quoi Obsidian exactement

Obsidian est un éditeur de notes basé sur le Markdown. Jusque-là, rien de révolutionnaire. Ce qui change la donne, c’est son approche : vos notes sont de simples fichiers .md stockés en local sur votre machine, dans un dossier classique. Pas de base de données propriétaire, pas de cloud obligatoire, pas de format fermé.

Concrètement, votre vault (coffre-fort en anglais) est un répertoire sur votre disque. Vous pouvez l’ouvrir avec n’importe quel éditeur de texte, le versionner avec Git, le synchroniser comme vous voulez. Et c’est là que réside la vraie force du modèle : même si Obsidian disparaît demain, vos fichiers restent parfaitement lisibles. Tant que vous avez l’application, tout tourne en local sans aucune dépendance extérieure. Et au pire, sans l’application, vos fichiers .md sont du texte brut que vous pouvez ouvrir avec n’importe quel éditeur. Vous ne perdez jamais rien.

L’interface est sobre et rapide. On lance l’application, on écrit en Markdown, on crée des liens entre les notes avec la syntaxe [[nom de la note]], et c’est parti. Pas besoin de passer trois heures à configurer des bases de données ou des templates avant de commencer à écrire.

Le second cerveau : pourquoi c’est pertinent pour un développeur

Le concept de second cerveau, popularisé par Tiago Forte, repose sur une idée simple : externaliser sa mémoire dans un système fiable et interrogeable. Au lieu de compter sur sa mémoire pour retenir une commande Docker, une config Nginx ou les subtilités d’une requête SQL, on les capture dans un système qu’on peut fouiller instantanément.

Pour un développeur, c’est particulièrement puissant parce que notre métier consiste à jongler entre des dizaines de technologies. Personnellement je vous conseille de voir votre second cerveau comme une documentation vivante. Pas un wiki figé qu’on met à jour une fois par trimestre, mais un espace organique où chaque note peut se connecter à une autre.

Prenons un exemple concret. Vous tombez sur un problème de performance MySQL. Vous creusez, vous trouvez la solution, vous la notez dans Obsidian. Trois mois plus tard, vous travaillez sur l’optimisation d’une API et vous tombez sur cette note en cherchant autre chose. Vous créez un lien. Six mois après, vous rédigez un article sur les bonnes pratiques SQL et vous avez déjà toute une toile de notes interconnectées sur le sujet. C’est ça, un second cerveau : une base de connaissances qui grandit et se structure au fil du temps.

Repenser le classement : les liens plutôt que les dossiers

C’est un changement de paradigme qui déstabilise au début. Dans un système classique, on passe un temps fou à se demander “je range cette note où ?”. Est-ce que ma note sur l’optimisation MySQL va dans le dossier “Base de données”, “Performance” ou “Projet X” ? Avec Obsidian, cette question perd de son importance.

Le vrai classement se fait par les liens entre les notes, pas par l’arborescence de dossiers. Une note sur l’optimisation MySQL peut être liée à votre fiche projet, à votre note sur les index SQL, et à votre checklist de performance. Elle existe dans plusieurs contextes à la fois sans avoir besoin d’être dupliquée. C’est la vue graphe qui révèle ces relations, pas l’explorateur de fichiers.

Cela ne veut pas dire qu’il faut abandonner toute structure de dossiers. En pratique, une organisation de base reste utile pour s’y retrouver. Voici un exemple d’architecture de vault qui fonctionne bien :

01_INBOX : point d’entrée de toutes les nouvelles notes, à trier ensuite
02_RESSOURCES : documentation technique, références, fiches outils
03_PROJECT : notes liées à des projets en cours
04_PERMANENT : notes mûries, retravaillées, qui constituent le cœur du second cerveau
05_MOC : Maps of Content, des notes d’index qui regroupent des liens thématiques
06_ARCHIVES : projets terminés, notes obsolètes
07_TEMPLATE : modèles de notes réutilisables
08_ASSETS : images, pièces jointes, fichiers annexes
09_READWISE : notes importées depuis vos lectures (si vous utilisez Readwise)

Le tout chapeauté par une note 00_Index qui sert de point d’entrée vers les MOC principaux.

L’idée c’est que les dossiers servent de grandes zones de travail, mais c’est le réseau de liens et les MOC (Maps of Content) qui assurent la vraie navigation. Une note dans 04_PERMANENT peut être reliée à trois projets dans 03_PROJECT et référencée dans deux MOC différents. Le dossier devient secondaire, le lien devient primaire.

La vue graphe : visualiser ses connaissances

C’est probablement la fonctionnalité la plus impressionnante d’Obsidian et celle qui donne tout son sens au concept de second cerveau. La vue graphe affiche toutes vos notes sous forme de nœuds reliés entre eux par des traits. Chaque lien [[interne]] que vous créez dessine une connexion visible.

Maintenant que nous avons vu comment les notes se connectent individuellement, imaginez le résultat avec des centaines de notes. La vue graphe révèle des clusters thématiques : vous voyez émerger des groupes autour de vos sujets principaux. Un cluster Docker, un cluster sécurité, un cluster JavaScript… Et surtout, vous repérez les ponts entre ces clusters, ces notes qui font le lien entre deux domaines que vous n’aviez pas consciemment associés.

Pour un développeur, cette visualisation est précieuse pour plusieurs raisons :

Elle identifie les zones de connaissance denses et les zones vides, ce qui aide à orienter sa veille technique.
Elle met en lumière les connexions transversales entre des technologies différentes.
Elle révèle les notes orphelines, ces fichiers isolés qu’on a créés sans jamais les relier au reste.
Elle donne une vue d’ensemble de son expertise technique d’un seul coup d’œil.

La vue graphe supporte aussi les filtres et la coloration par dossier ou par tag, ce qui permet de se concentrer sur un sous-ensemble de notes quand le vault grossit.

Exemple concret : cartographie applicative et réseau

La vue graphe peut servir de cartographie légère pour documenter une infrastructure. Imaginons que vous créez une note par composant de votre stack : une note [[API Gateway]], une note [[Service Auth]], une note [[Service Paiement]], une note [[PostgreSQL Production]], une note [[Redis Cache]]. Dans chaque note, vous décrivez le composant et vous liez les notes entre elles selon les dépendances : l’API Gateway appelle le Service Auth, le Service Paiement tape dans PostgreSQL, le Redis Cache est utilisé par les deux services.

Le même principe fonctionne pour une cartographie réseau : une note par serveur, par VLAN ou par service. Vous notez les IP, les ports exposés, les règles firewall, et vous reliez le tout. La vue graphe vous montre alors d’un coup d’œil quel serveur communique avec quel autre et vous repérez rapidement un service isolé ou un point de convergence critique.

Il faut être honnête : pour une cartographie complète et maintenue en production, des outils dédiés comme Netbox, DrawIO ou des solutions d’ITSM feront un meilleur travail. Mais pour une documentation personnelle rapide, un mapping mental de votre infra ou la compréhension d’un nouveau SI quand vous arrivez sur un projet, Obsidian et sa vue graphe sont redoutablement efficaces. Le ratio effort/valeur est imbattable.

Obsidian vs Notion : comparaison pragmatique

Impossible de parler d’Obsidian sans évoquer Notion. Les deux outils sont souvent comparés, mais ils répondent à des philosophies radicalement différentes.

Critère	Obsidian	Notion
Stockage	Local (fichiers .md)	Cloud (propriétaire)
Format	Markdown standard	Format propriétaire
Hors-ligne	Natif, toujours disponible	Limité, dépend du cache
Vitesse	Très rapide	Peut être lent sur gros espaces
Versioning Git	Natif (ce sont des fichiers)	Impossible
Collaboration	Possible mais limitée	Excellente
Courbe d'apprentissage	Modérée	Faible
Personnalisation	Totale (CSS, plugins JS)	Limitée aux blocs natifs
Propriété des données	Totale	Chez Notion

Notion excelle pour le travail collaboratif et la gestion de projet en équipe. Il faut être honnête là-dessus. Si vous cherchez un espace partagé avec votre équipe pour gérer des sprints ou un wiki d’entreprise, Notion fait très bien le travail.

Mais pour un usage personnel de base de connaissances technique, Obsidian gagne sur quasiment tous les critères qui comptent pour un développeur : rapidité, hors-ligne, Git, Markdown pur, et surtout la certitude que vos données ne dépendent de personne. Le jour où Notion change ses tarifs, son API ou ferme boutique, vos données sont coincées. Avec Obsidian, ce problème n’existe pas.

Et la collaboration avec Obsidian ?

La collaboration est possible mais il faut être lucide : ce n’est pas le point fort d’Obsidian. Vous pouvez partager un vault via Google Drive, Dropbox ou un dépôt Git partagé. Ça fonctionne, mais ce n’est pas toujours simple. Avec un partage cloud type Drive, les conflits de fichiers peuvent arriver si deux personnes éditent la même note en même temps. Avec Git, c’est plus propre grâce à la gestion des merges, mais ça suppose que tous les collaborateurs soient à l’aise avec Git.

Pour un usage en binôme ou en petite équipe technique, le partage via Git reste la meilleure option. Pour de la vraie collaboration temps réel avec des profils non-techniques, il vaut mieux garder Notion ou un autre outil collaboratif à côté.

Les plugins essentiels pour les développeurs

La force d’Obsidian réside aussi dans son écosystème de plugins communautaires. Il en existe des centaines, mais voici ceux qui font la différence pour un profil technique.

Dataview

Dataview transforme votre vault en une base de données interrogeable. Vous écrivez des requêtes en pseudo-SQL directement dans vos notes pour afficher des tableaux dynamiques. Par exemple, lister toutes vos notes taguées #bug créées ce mois-ci, ou afficher un tableau de vos projets en cours avec leur statut. Pour quelqu’un qui pense en SQL, c’est naturel.

Git (Obsidian Git)

Ce plugin automatise les commits et pushs de votre vault vers un dépôt Git. Vous configurez un intervalle (toutes les 10 minutes par exemple), et votre vault est versionné automatiquement. Historique complet, branches, diff… Tout ce qu’on aime avec Git, appliqué à ses notes. Cela dit, le plugin n’est pas obligatoire : vous pouvez très bien gérer vos commits manuellement en ligne de commande ou via un script cron. Le plugin ajoute simplement le confort de l’automatisation dans l’interface.

Templater

Templater va plus loin que le système de templates natif, ce qui permet d’automatiser la création de notes avec des dates dynamiques etc. Idéal pour standardiser ses notes de debug, ses comptes-rendus de veille ou ses fiches projet.

Calendar et Periodic Notes

Calendar affiche un calendrier dans la barre latérale qui permet de naviguer rapidement entre vos notes quotidiennes. Couplé à Periodic Notes, vous pouvez mettre en place un système de journaling technique : une note par jour, par semaine ou par mois, générée automatiquement depuis un template. Pratique pour garder une trace de ce qu’on a fait, débugué ou appris chaque jour.

Les plugins du quotidien

Quelques plugins plus discrets mais qui améliorent le confort au quotidien : Copy Button for Code Blocks ajoute un bouton de copie sur chaque bloc de code (indispensable quand on documente des commandes), Editor Syntax Highlight améliore la coloration syntaxique dans l’éditeur, Sliding Panes permet d’afficher plusieurs notes côte à côte en panneaux glissants pour comparer ou croiser des informations, Tracker permet de suivre des données au fil du temps (habitudes, métriques, objectifs), et Advanced Tables rend l’écriture de tableaux Markdown supportable avec la navigation par tabulation et le formatage automatique.

Si vous utilisez Readwise pour centraliser vos highlights de lecture, le plugin Readwise Official synchronise automatiquement vos annotations dans votre vault, prêtes à être liées au reste de vos notes.

Ce qui peut manquer

Obsidian n’est pas parfait et il y a des points qui peuvent manquer selon votre usage. La recherche et remplacement globale sur l’ensemble du vault est basique comparée à ce que propose un IDE. Le support mobile fonctionne mais reste moins fluide que sur desktop, surtout avec un vault volumineux. Il n’y a pas de tableaux de bord natifs comme dans Notion : il faut passer par Dataview pour obtenir quelque chose d’approchant, ce qui demande un temps d’apprentissage.

Le partage de notes vers l’extérieur n’est pas simple non plus. Si vous voulez publier une note en ligne, il faut soit payer pour Obsidian Publish, soit mettre en place un pipeline d’export (vers Jekyll, Hugo ou autre). Pas insurmontable, mais c’est du travail en plus.

Enfin, la gestion des pièces jointes et images peut vite devenir désordonnée si on ne configure pas un dossier dédié dès le départ (comme le dossier 08_ASSETS mentionné plus haut). Par défaut, Obsidian colle les images à la racine du vault, ce qui devient vite le bazar.

Pour qui Obsidian est fait, et pour qui il ne l’est pas

Il faut éviter de tomber dans le piège du “c’est l’outil parfait pour tout le monde”. Obsidian a ses limites et il vaut mieux les connaître avant de migrer toutes ses notes.

Obsidian est fait pour vous si :

Vous êtes à l’aise avec le Markdown.
Vous voulez garder le contrôle total sur vos données.
Vous cherchez un espace de notes personnel, pas un outil collaboratif.
Vous aimez personnaliser vos outils (CSS, plugins, raccourcis).
Vous avez besoin de travailler hors-ligne régulièrement.

Obsidian n’est probablement pas pour vous si :

Vous avez besoin de collaboration en temps réel avec une équipe.
Vous ne voulez pas toucher au Markdown.
Vous cherchez un outil clé en main sans configuration.
Vous avez besoin de bases de données relationnelles complexes (Notion fait mieux ici).

Personnellement, après plus de trois ans d’utilisation, le plus gros avantage reste la pérennité. Mes notes d’il y a plusieurs années sont toujours là, toujours lisibles, toujours connectées. Aucun changement de tarif, aucune migration forcée, aucune fonctionnalité supprimée du jour au lendemain. Pour un second cerveau, la durabilité est un critère fondamental.

Obsidian ne va pas transformer votre façon de travailler du jour au lendemain. Il faut accepter de construire son vault progressivement, note après note, lien après lien. Mais une fois que la masse critique est atteinte et que la vue graphe commence à dessiner les contours de votre expertise, l’outil devient indispensable. Le meilleur moment pour commencer, c’est maintenant. Créez un vault, prenez votre première note technique, et laissez votre second cerveau grandir avec vous.

Feature Flags : Maîtrisez le déploiement et l'activation de vos fonctionnalités

2025-04-13T00:00:00+00:00

Déployer de nouvelles fonctionnalités sans risquer de déstabiliser tout votre système peut rapidement devenir un casse-tête pour les équipes de développement. Les feature flags offrent une solution élégante à ce problème en permettant d’activer ou désactiver des portions de code à la demande, même en environnement de production. Grâce à cette technique, les développeurs peuvent intégrer du code dans la branche principale tout en gardant le contrôle sur son activation, facilitant ainsi les tests utilisateurs et accélérant le cycle de déploiement des applications.

En résumé

🚀 Accélérez vos déploiements grâce aux feature flags : activez ou désactivez vos fonctionnalités sans risque.
✅ Réduisez les incidents en production avec les déploiements progressifs et sécurisés.
📊 Améliorez l’expérience utilisateur grâce aux tests A/B et à l’expérimentation continue.
🔑 Gérez précisément l’accès aux nouvelles fonctionnalités avec des contrôles avancés (accès anticipé, fonctionnalités premium).
🛡️ Protégez votre produit grâce à la désactivation immédiate des fonctionnalités critiques (kill switch).
⚠️ Anticipez les défis techniques liés aux feature flags (complexité du code, dette technique, impact sur les performances).

Sommaire

Qu’est-ce que les feature flags ?
Avantages et cas d’usage des feature flags
Implémentation des feature flags
Outils et solutions pour gérer les feature flags
Cas d’usage avancés des feature flags
Limitations et défis des feature flags

Qu'est-ce que les feature flags ?

Définition et principe de fonctionnement

Les feature flags sont une technique de développement permettant d’activer ou désactiver des fonctionnalités à la demande, sans nécessiter de nouveau déploiement de code en production.

Le principe technique derrière les feature flags repose sur des structures conditionnelles intégrées dans le code source de l’application. Ces interrupteurs virtuels vérifient l’état d’un flag (activé ou désactivé) et exécutent ensuite le code approprié selon cette condition.

Terminologie et appellations alternatives

Dans l’industrie du développement logiciel, les feature flags sont également connus sous d’autres appellations comme “feature toggles”, “feature switches” ou “feature flippers”.

Ces différentes terminologies désignent fondamentalement le même concept technique, mais peuvent refléter des nuances dans leur utilisation selon les contextes d’entreprise ou les communautés de développeurs qui les emploient.

Types de feature flags

Type de Feature Flag	Objectif Principal	Cas d’Usage
Release Flags	Séparer déploiement du code et mise en production	Déploiements progressifs, versions Canary
Experimentation Flags	Tests A/B et validation des changements	Tests A/B, analyse de l’impact des fonctionnalités
Operational Flags	Contrôle des aspects opérationnels du système	Gestion des incidents, maintenance du système
Permission Flags	Gestion des accès aux fonctionnalités	Accès anticipé, tests bêta, fonctionnalités premium

Légende : Ce tableau compare les différents types de feature flags en fonction de leur objectif principal et de leurs cas d’usage typiques.

Feature flags vs branching

La différence fondamentale entre feature flags et branching réside dans la manière dont le code est géré pendant le développement et le déploiement des fonctionnalités.

Les feature flags présentent un avantage majeur dans un contexte DevOps car ils permettent d’intégrer le code plus fréquemment dans la branche principale. Cette approche réduit considérablement les conflits de fusion tout en permettant aux équipes de tester en production de manière sécurisée grâce à l’activation sélective des fonctionnalités.

Avantages et cas d'usage des feature flags

L’utilisation des feature flags transforme profondément la façon dont les équipes abordent le développement logiciel :

Réduction des risques : minimise les risques associés aux déploiements.
Collaboration améliorée : améliore la collaboration entre les équipes.
Gain de temps : accélère les tests en production.

Les feature flags permettent notamment de découpler la livraison du code de l’activation des fonctionnalités, facilitant ainsi les campagnes marketing et la gestion des incidents.

Implémentation des feature flags

Comment intégrer les feature flags dans le code

L’implémentation consiste à placer des mécanismes conditionnels pour activer ou désactiver des fonctionnalités. Il faut éviter les imbrications complexes qui rendent le code difficile à maintenir.

Bonnes pratiques pour la gestion des feature flags

Nommer efficacement : convention claire pour les flags.
Nettoyer régulièrement : éliminer les flags obsolètes.
Documenter : garder une documentation précise de chaque flag.

Gérer le cycle de vie des feature flags

Étape	Description
Définition	Création du feature flag, aucune métrique détectée
Développement	Métriques reçues en environnement de test
Production	Premiers utilisateurs exposés au feature flag
Nettoyage	Suppression après réalisation de l’objectif
Archivage	Conservation pour référence future

Légende : Cycle complet de gestion d’un feature flag.

Tests et monitoring avec les feature flags

Un monitoring rigoureux est nécessaire pour évaluer l’impact des activations en production, en surveillant performances et engagements utilisateurs.

Outils et solutions pour gérer les feature flags

Solutions open-source

Solution	Description	Avantages
Unleash	Plateforme de gestion des fonctionnalités	Déploiement progressif, tests en production
OpenFeature	API indépendante du fournisseur	Flexibilité, changement de fournisseur facile

Solutions SaaS et commerciales

Pour des besoins avancés, plusieurs plateformes SaaS offrent intégration et analyses poussées.

Intégration avec les environnements DevOps

Intégration transparente avec GitLab, GitHub, Jira pour une gestion complète depuis l’environnement habituel des équipes.

Développer sa propre solution

Option pertinente uniquement lorsque les solutions existantes ne répondent pas à des exigences spécifiques.

Cas d'usage avancés des feature flags

Déploiement progressif : réduit les risques en activant progressivement les fonctionnalités.
Tests A/B et expérimentation : optimise l’engagement utilisateur grâce aux tests multiples.
Gestion des accès utilisateurs : contrôle précis des accès aux fonctionnalités.
Kill switch : désactivation immédiate d’une fonctionnalité en cas d’incident critique.

Limitations et défis des feature flags

Complexité technique : difficulté croissante du code et des tests.
Dette technique : nécessité d’une gestion stricte des flags obsolètes.
Impact sur les performances : surcharge potentielle due à l’évaluation constante.
Considérations organisationnelles : besoin d’une collaboration étroite entre équipes.

Bonnes pratiques pour réduire ces défis :

Utilisation de la mise en cache
Évaluation conditionnelle limitée
Planification stratégique de l’intégration

Les feature flags apportent flexibilité et sécurité au processus de déploiement, à condition d’être gérés rigoureusement pour éviter toute complexité inutile.

Gophish : Guide complet pour simuler des campagnes de phishing et renforcer la sécurité de votre entreprise

2025-03-21T00:00:00+00:00

⚠️ Avertissement :

Cet article présente l’outil Gophish dans un objectif strictement pédagogique et préventif, visant exclusivement à sensibiliser les utilisateurs aux risques liés au phishing.
L’usage de cet outil doit impérativement se faire dans un cadre légal précis, avec l’autorisation explicite de l’organisation concernée et en conformité totale avec la réglementation en vigueur (notamment le RGPD et le Code pénal).
Toute utilisation à des fins malveillantes ou hors du cadre autorisé de sensibilisation constitue un délit et expose son auteur à des poursuites et sanctions pénales lourdes.

L’auteur décline toute responsabilité en cas d’usage abusif ou illégal de l’information fournie dans cet article.

Le phishing, véritable fléau de la cybersécurité, constitue une menace persistante pour les organisations. Comment mesurer concrètement la sensibilité de vos collaborateurs à ces attaques ? Nous vous présentons ici Gophish, solution open source permettant de simuler des campagnes d'hameçonnage et d'améliorer la vigilance collective. De l'installation à l'analyse des résultats, cet outil offre une approche pragmatique pour tester vos dispositifs de sécurité. Vous verrez notamment comment adapter les paramètres selon votre infrastructure et interpréter les statistiques pour des actions ciblées.

Sommaire

Gophish : outil de simulation phishing à visée éducative
Configuration et déploiement de Gophish
Création de campagnes de simulations réalistes
Analyse des résultats et mesures d'amélioration
Bonnes pratiques de sécurité opérationnelle
Alternatives et outils complémentaires
Optimisation avancée et veille technologique

Gophish : outil de simulation phishing à visée éducative

Définition et objectifs de la solution

Gophish est une solution conçue pour évaluer et améliorer la sensibilisation des utilisateurs aux risques de phishing. Son rôle ? Aider les entreprises à organiser des simulations d'attaques réalistes, permettant d'identifier les vulnérabilités humaines et techniques. Un atout précieux pour les équipes en charge de la sécurité des mails et des données sensibles.

Signalons que Gophish se distingue par ses fonctionnalités techniques orientées vers l'action concrète :

Interface web intuitive : La plateforme simplifie la configuration des campagnes grâce à un tableau de bord centralisé. Les entreprises peuvent ainsi créer des pages de phishing réalistes en quelques clics.
Personnalisation des mails : L'outil permet d'adapter chaque message aux spécificités des utilisateurs ciblés. Une fonctionnalité particulièrement utile pour simuler des attaques réaliste.
Gestion des destinataires : L'outil propose des fonctionnalité pour importer et gérer des listes de destinataires, facilitant ainsi le ciblage des campagnes. Les campagnes peuvent ainsi segmenter les départements ou niveaux hiérarchiques pour des tests plus pertinents. Gophish ne propose pas nativement l'intégration avec Active Directory. Cependant, des scripts tiers, comme GoLDAP, permettent d'importer des utilisateurs depuis Active Directory via le protocole LDAP.
Analyse des résultats : Chaque campagne génère des rapports détaillés sur les taux d'ouverture de mails et les interactions avec les pages frauduleuses. Ces données servent de base aux formations correctives.
Étalement des campagnes : Une campagne peut s'exécuter rapidement, mais également être étalée sur une période plus longue.

En pratique, les entreprises utilisent souvent Gophish en complément de tutoriels de sensibilisation. Cette combinaison permet de transformer chaque simulation en opportunité pédagogique.

Cadre légal et bonnes pratiques d'utilisation

Attention : les simulations de phishing doivent respecter strictement le RGPD ainsi que les règles et conventions internes à l'entreprise. Les collaborateurs doivent être informés clairement de la nature, des objectifs pédagogiques des tests, ainsi que du traitement prévu de leurs données personnelles. Cette information préalable peut prendre la forme de clauses contractuelles, de tutoriels ou de communications explicatives régulières.
La collecte des données personnelles lors des simulations doit se limiter strictement aux informations nécessaires à l'objectif poursuivi (principe de minimisation). De même, la durée de conservation de ces données doit être la plus courte possible, afin de réduire significativement les risques en cas de fuite ou d'accès non autorisé. Enfin, il est recommandé d'anonymiser systématiquement les résultats des campagnes afin de protéger la vie privée des utilisateurs et d'éviter toute stigmatisation individuelle.

Bonnes pratiques recommandées :

Parmi les conseils utiles il y'a les suivant :

Anonymisation des résultats : Pour préserver la transparence tout en évitant la stigmatisation individuelle, il est recommandé d'anonymiser les résultats des simulations. Cette approche permet aux équipes de considérer les résultats de façon collective, sans pointer du doigt les erreurs individuelles
Absence de sanctions : Il est déconseillé de sanctionner les employés ayant échoué aux tests de phishing. Des sanctions pourraient décourager les collaborateurs de signaler de véritables tentatives de phishing par crainte de représailles, compromettant ainsi la sécurité globale de l'entreprise. En revanche, il est recommandé d'accompagner systématiquement les échecs d'une sensibilisation complémentaire afin de prévenir la répétition des erreurs.
Formation : En parallèle il faut continuer la formation et la sensibilisation

Intégration dans une stratégie de sécurité

Les résultats des campagnes alimentent directement les plans de formation. En croisant les données serveur et les comportements utilisateur, les équipes sécurité peuvent prioriser les actions correctives. On regardera le profils des utilisateurs n'ayant pas réussi la simulation (compte a risque etc), les métriques de base (ouvertures, clic, remplissage) mais aussi les remontées. En effet la durée entre la premiere reception et la premiere remonté est un indicateur utile en cas de réelle attaque. Cela permet de voir le délais avant de pouvoir communiquer voire même couper l'accès a certains liens malveillant.

Configuration et déploiement de Gophish

Le déploiement de Gophish sur un serveur dédié nécessite une préparation minutieuse de l'environnement technique. Avant de lancer une campagne, vérifiez la compatibilité des systèmes d'exploitation (Linux, Windows, macOS) et les ressources mémoire requises. Signalons que de nombreuses entreprises intègrent désormais cet outil à leurs infrastructures Microsoft existantes.

Comparatif des méthodes d'installation de Gophish
Méthode d'installation	Avantages	Inconvénients
Manuelle	Contrôle maximal sur le paramétrage et personnalisation avancée. Idéal pour les serveurs critiques.	Nécessite une formation technique poussée (dépendances système, configurations réseau).
Docker	Déploiement accéléré via une image pré-configurée. Mises à jour simplifiées, comme le précise le tutoriel officiel.	Implique une maîtrise préalable de l'écosystème Docker.
Binaires pré-packagés	Opération rapide par simple extraction de fichier. Parfait pour des tests mail immédiats.	Options de personnalisation réduites comparé à l'approche manuelle.

Pour sécuriser l'interface d'administration, un reverse proxy comme Nginx s'avère utile - particulièrement pour le chiffrement SSL. Notons que cette configuration protège aussi les interactions utilisateur lors des campagnes de simulation.

Il ne faut toutefois pas oublier l'aspect technique emailing telles que SPF, DKIM et DMARC. Un email non conforme risque de ne pas arriver en INBOX.

Pensez à configurer correctement vos enregistrements SPF, DKIM et DMARC pour garantir la bonne délivrabilité des mails lors des campagnes. Une politique DMARC stricte limite aussi considérablement le risque que votre domaine soit utilisé à des fins malveillantes. Vous trouverez plus d'information sur l'article : DMARC : Sécurisez vos emails contre le phishing

Création de campagnes de simulations réalistes

Paramétrage des modèles d'emails

La personnalisation des messages de phishing reste une technique clé pour renforcer le réalisme des simulations. L'ajout de variables dynamiques et de pièces jointes crédibles rend les mails plus persuasifs pour les utilisateurs, surtout lorsqu'on imite des formats Microsoft Outlook.

Vous pouvez vous inspirer d'un mail légitime, d'un mail de phishing reçu ou partir de zero.

Pour accélérer la préparation des campagnes, certaines solutions/répo github proposent des bibliothèques de templates sectoriels. Ces modèles prédéfinis s'adaptent rapidement aux spécificités métiers, tout en permettant des ajustements manuels si nécessaire.

Construction des pages de capture

Créer des interfaces convaincantes nécessite souvent de reproduire des pages web officielles. L'intégration de logos authentiques et le choix d'outils de design adaptés contribuent à tromper la vigilance des utilisateurs moins avertis.

Signalons que la sécurisation des données collectées devient indispensable. Le chiffrement des identifiants dès la saisie sur le serveur, couplé à leur anonymisation ultérieure, limite les risques de fuite accidentelle pendant la campagne.

Pour des raisons éthiques et légales, il est fortement conseillé de ne jamais capturer de mots de passe réels lors des simulations. Si vous devez inclure un champ "mot de passe", assurez-vous qu'il ne stocke aucune donnée sensible.

L'activation de l'option qui permet de rediriger l'utilisateur sur une page précise dans le cas d'un remplissage est importante voire essentielle : de mon coté c'est un slide de sensibilisation et d'explication.

Administration des listes de destinataires

Différencier le niveau de difficulté selon les profils permet d'adapter les simulations. Un commercial recevra par exemple un mail différent d'un comptable, avec des scénarios plus réalistes pour chaque utilisateur.

Planification et déclenchement

Éviter les envois massifs simultanés s'avère payant. En espaçant les mails sur plusieurs jours avec des horaires aléatoires, on reproduit mieux les tactiques des vraies attaques phishing. Creer une situation d'urgence et d'importance a un impact fort sur les résultats.

Les dashboards de suivi en temps réel offrent une vision claire de l'avancement de la campagne. Couplés à des alertes paramétrables, ils permettent d'intervenir rapidement pour corriger un taux d'ouverture trop faible ou un problème technique sur une page de capture.

Bon à savoir : de nombreux tutoriels existent pour maîtriser ces fonctionnalités. Les entreprises investissant dans ce type de formation voient généralement leur résilience augmenter.

Analyse des résultats et mesures d'amélioration

Interprétation des rapports détaillés

L'évaluation du taux de vulnérabilité constitue une méthode centrale pour mesurer les risques organisationnels. Le risque relatif par département révèle notamment les zones critiques face aux campagnes de phishing par mail.

L'analyse des comportements à risque met en lumière des habitudes récurrentes, comme l'ouverture systématique des pièces jointes. Curieusement, les postes exposés varient selon les pages consultées sur l'intranet. Ces données guident l'adaptation des tutoriels pour les prochaines campagnes de sensibilisation.

Conception de modules de remédiation

La création de contenus pédagogiques ciblés s'appuie sur les erreurs fréquentes observées dans les simulations de mail frauduleux. Le format des tutoriels vidéo peut etre pas mal si vous avez le temps. Un exemple concret ? Les quiz interactifs peuvent faire des miracles.

Mesure d'impact des formations

Le suivi des performances s'appuie sur des indicateurs concrets : temps de signalement des mails douteux, taux d'erreur lors des simulations. Les entreprises peuvent comparer ces données d'un mois sur l'autre afin de voir une avancé de la sensibilisation.

D'expérience j'ai tendance a voir de belles progressions et ce faire avoir rend le risque plus tangible. Dans la sensibilisation n'hesitez pas a citer des exemples d'impact ayant eu lieu, si possible dans votre secteur d'activité

Bonnes pratiques de sécurité opérationnelle

Suivi des vulnérabilités

La surveillance des CVE liés à Gophish doit être intégrée au processus de formation des administrateurs. Plutôt que de se contenter des mises à jour automatiques, établissez un calendrier de vérification mensuel.

Alternatives et outils complémentaires

Explorer des solutions complémentaires à Gophish permet d'enrichir votre campagne de sensibilisation au phishing. Voyons les principaux éléments à considérer pour choisir des outils adaptés à vos besoins en matière de sécurité mail.

Pour optimiser vos simulations de phishing, il est utile de comparer différentes options disponibles.

Solutions open source : Des outils comme SET (Social-Engineer Toolkit) ou KingPhisher permettent de créer des campagnes de phishing réalistes. Certains tutoriels recommandent de les tester sur un serveur dédié pour évaluer leur efficacité.
Spécificités fonctionnelles : La personnalisation des mails tests, le suivi des interactions utilisateur et l'analyse des statistiques varient selon les outils. Un tutoriel détaillé aide souvent à choisir.

En pratique, cela implique de tester plusieurs options avant de lancer une campagne à grande échelle.

Pour les entreprises, l'enjeu consiste à articuler ces solutions avec leur existant technique. Vérifiez notamment la capacité à exporter des rapports depuis le serveur vers vos outils de supervision.

Optimisation avancée et veille technologique

Automatisation via l'API REST

Gophish propose une API REST vous pouvez donc établir des workflows automatisés qui simplifient notamment la création de campagnes de phishing simulées sur plusieurs serveurs.

Toutefois l'interface etant simple sur des petits volumes vous pouvez n'utiliser que celle ci.

Veille sur les nouvelles techniques de phishing

Surveiller l'évolution des attaques par mail reste indispensable pour maintenir des simulations réalistes. Les équipes doivent identifier des sources fiables pour adapter leurs pages de simulation aux dernières tendances.

Adapter les scénarios aux vecteurs récents nécessite une formation régulière. Signalons que la fréquence des mises à jour des templates dépend directement de l'activité détectée sur les serveurs de collecte de données.

Contributions à la communauté open source

Soumettre des améliorations à Gophish encourage son évolution collaborative. Les entreprises peuvent notamment partager leurs tutoriels ou modules complémentaires, à condition de respecter les guidelines techniques pour serveurs d'entreprise.

Traiter les retours utilisateurs et publier une roadmap transparente favorise l'engagement communautaire. La communication via les canaux officiels permet d'ailleurs aux utilisateurs de proposer des formations ou des cas d'usage concrets.

Linux 101 : Le guide accessible pour maîtriser les permissions

2025-02-15T00:00:00+00:00

Linux offre un contrôle très personnalisé et fin sur l’accès aux fichiers et aux répertoires grâce à un système de permissions reposant sur des valeurs numériques et des attributs spécifiques.

Ce guide vous expliquera comment fonctionnent les permissions classiques et avancées, comment les calculer avec les valeurs numériques, et vous alertera sur les risques associés à l’utilisation d’attributs comme le setuid et le setgid.

1. Comprendre les permissions classiques

Chaque fichier ou répertoire est associé à un ensemble de permissions qui définissent trois actions fondamentales :

Read (r) : Lire le contenu d’un fichier ou lister un répertoire.
Write (w) : Modifier ou supprimer un fichier, ou ajouter/supprimer dans un répertoire.
Execute (x) : Exécuter un fichier ou accéder à un répertoire.

Structure des permissions

Les permissions sont attribuées à trois catégories d’utilisateurs :

User (u) : Le propriétaire.
Group (g) : Un groupe d’utilisateurs partageant des droits communs.
Others (o) : Tous les autres utilisateurs.

Notation numérique : 4, 2, 1

Chaque permission est représentée par une valeur :

Lecture = 4
Écriture = 2
Exécution = 1

Additionnez ces valeurs pour chaque catégorie. Par exemple, pour un fichier avec les permissions 644 :

Propriétaire : 6 = 4 (lecture) + 2 (écriture)
Groupe et autres : 4 = lecture seule

Cette méthode offre un moyen rapide de définir des droits précis et reste très utilisée en administration système. C’est la notation de base vous devez vous y habituer même si l’on retrouve souvent les meme valeurs

Affectation de permission

Pour changer les permissions d’un fichier nous utiliserons la commande chmod

Par exemple, si l’on souhaite que le proprietaire ait tous les droits, les même du groupe associé au fichier uniquement la lecture et l’execution et la lecture uniquement pour les autres on devra affecter la valeur 754.

7 (4+2+1) pour le propriétaire : lecture, écriture, exécution.
5 (4+0+1) pour le groupe : lecture et exécution.
4 pour les autres : lecture seule.

On utilisera donc :

chmod 754 mon_fichier

Vous pouvez utiliser également comme notation non chiffré avec les modificateur suivant :

+ ajout
- retrait
= affectation

Et en precisant si besoin si c’est pour les autres (o), groupe (g) ou proprietaire u. Personellement je vous conseille de rester sur la version chiffré.

Rappel : Pour changer le proprietaire ou le groupe d’un fichier on utilisera la commande chown.

2. Les permissions avancées

Linux propose aussi des attributs avancés pour répondre à des besoins spécifiques.

Sticky Bit

Le sticky bit, activé sur un répertoire, empêche les utilisateurs de supprimer ou renommer des fichiers qui ne leur appartiennent pas, même s’ils ont accès au répertoire.
Par exemple, /tmp utilise le sticky bit pour éviter les suppressions accidentelles ou malveillantes.

chmod +t /tmp

Setuid et Setgid

Ces attributs modifient le comportement d’exécution, ne les utilisez pas a tout va car une mauvaise utilisation peut entrainer des failes de sécurité. Si vous avez besoin des droits root, sudo est votre ami dans la majeure partie des cas.

Setuid

Lorsqu’un exécutable possède le setuid, il s’exécute avec les privilèges du propriétaire, et non de l’utilisateur qui lance le programme.

chmod u+s /usr/bin/passwd

Risques :
Si un programme setuid comporte une vulnérabilité, un attaquant peut l’exploiter pour obtenir des privilèges élevés.
Conseils :

Utilisez le setuid uniquement sur les exécutables indispensables.
Mettez régulièrement à jour et auditez le code.
Si le setuid est mis, il ne faut pas :
- Que des utilisateurs non proprietaires puissent modifier le script - sinon les modifications seront exécuté avec les droits du proprietaire
- Utiliser d’alias dans le script, la encore une modification au niveau de l’alias peut permettre de changer un comportement meme sans modifier le fichier

Setgid

Pour les fichiers, le setgid fonctionne comme le setuid mais pour le groupe. Pour les répertoires, il fait en sorte que tous les fichiers et sous-répertoires héritent du groupe du répertoire parent.

chmod g+s /var/www

Risques :
Le setgid sur un répertoire partagé peut faciliter l’accès à des fichiers sensibles si la gestion des groupes n’est pas rigoureuse.
Conseils :

Limitez l’appartenance aux groupes sensibles.
Revoyez régulièrement les droits et les membres des groupes.

3. Calcul et application des permissions

Exemples de calcul

Commande chmod 755 fichier :
- Propriétaire : 7 = 4+2+1 (lecture, écriture, exécution)
- Groupe : 5 = 4+0+1 (lecture, exécution)
- Autres : 5 = 4+0+1 (lecture, exécution)
Commande chmod 644 fichier :
- Propriétaire : 6 = 4+2 (lecture, écriture)
- Groupe et autres : 4 = lecture seule

Scénarios d’utilisation

Serveur web

Pour un site web, séparez les fichiers accessibles publiquement de ceux sensibles :

chmod 755 /var/www/html
chmod 640 /etc/nginx/nginx.conf
chown root:www-data /etc/nginx/nginx.conf

Répertoire partagé

Dans un répertoire où chacun peut déposer des fichiers sans risque de suppression par autrui :

chmod 1777 /srv/partage

Outils systèmes

Certains outils, comme /usr/bin/passwd, utilisent le setuid pour permettre aux utilisateurs de changer leur mot de passe en toute sécurité. Ces applications doivent être surveillées de près pour éviter toute faille.

4. Risques et vulnérabilités

Risques du Setuid

Escalade de Privilèges :
Un programme vulnérable avec setuid peut permettre à un attaquant d’obtenir des droits root.
Mesures de Protection :
- Limitez le nombre de programmes setuid.
- Auditez régulièrement ces exécutables.
- Appliquez les mises à jour de sécurité.

Risques du Setgid

Propagation des Droits :
Les fichiers héritant du groupe d’un répertoire peuvent exposer des données sensibles.
Mesures de Protection :
- Contrôlez strictement l’appartenance aux groupes.
- Utilisez le principe du moindre privilège.

Risques généraux

Permissions trop libres :
Évitez les permissions excessives (ex. 777) qui peuvent mener à des modifications ou suppressions non désirées. Typiquement si il y’a une faille coté application un attaquant pourrait s’en servir.
Utilisation incorrecte du Sticky Bit :
Assurez-vous que le sticky bit soit appliqué sur des répertoires où il apporte réellement une valeur ajoutée.

5. Bonnes Pratiques pour la gestion des permissions

Principe du Moindre Privilège :
Attribuez uniquement les droits nécessaires à chaque utilisateur ou groupe.
Audit Régulier :
Utilisez des outils comme find et ls -l pour vérifier les permissions sur les fichiers sensibles.
Documentation et Formation :
Tenez une documentation à jour et formez vos équipes sur les meilleures pratiques.
Outils de Sécurité :
Intégrez des solutions telles que SELinux ou AppArmor pour renforcer les contrôles d’accès.
Utilisation des ACL :
Pour des contrôles plus granulaires, envisagez d’utiliser les ACL (Access Control Lists).

6. Conclusion

Maîtriser les permissions sous Linux est indispensable pour sécuriser vos environnements. En comprenant la notation numérique (4, 2, 1) et en appliquant correctement les permissions classiques et avancées, vous réduisez significativement les risques d’escalade de privilèges et de mauvaises configurations.

En appliquant les bonnes pratiques et en surveillant régulièrement vos configurations, vous garantissez une meilleure protection des données et une stabilité accrue de vos systèmes. Testez toujours vos configurations dans un environnement de test avant de les déployer en production, et restez à jour avec les recommandations de sécurité de votre distribution Linux.

N’hésitez pas à laisser vos commentaires ou questions pour approfondir ce sujet !

Certificate Transparency: Surveillez TLS via crt.sh & CertStream

2025-01-26T00:00:00+00:00

1. Contexte et enjeux

La sécurité des communications numériques ne se limite pas seulement à la navigation web. Même si l’on parle souvent de HTTPS – qui encapsule le protocole HTTP dans une couche TLS (Transport Layer Security) –, la TLS peut être utilisée pour bien d’autres protocoles : messagerie (IMAP, SMTP), transfert de fichiers (FTPS), VPN, etc.

Dans tous ces scénarios, les certificats TLS jouent un rôle primordial pour assurer l’authentification du serveur (ou du client) et le chiffrement des données échangées. Cependant, le système de confiance fondé sur ces certificats a déjà montré ses failles (certificats malveillants, erreurs d’émission, etc.). C’est ici qu’intervient la Certificate Transparency (CT), un mécanisme rendant publiques toutes les émissions de certificats afin de faciliter la détection d’anomalies.

2. Certificate Transparency : le principe

Fondements
- Les Autorités de Certification (CA) doivent consigner tout certificat émis dans des journaux publics append-only.
- Une preuve d’enregistrement (SCT – Signed Certificate Timestamp) est nécessaire pour que les certificats soient considérés valides par les principaux navigateurs web (Chrome, Firefox, etc.).
Pourquoi c’est crucial
- Transparence universelle : Toute personne (ou machine) a la possibilité de vérifier les certificats émis pour un domaine donné, qu’il s’agisse d’un site web, d’un serveur de messagerie ou d’un autre service.
- Détection rapide : Si un certificat est délivré de manière frauduleuse ou sans autorisation, il devient plus aisé de le repérer et de le révoquer avant qu’il ne cause des dégâts.
- Amélioration du système de confiance : La CT rend le processus d’émission plus vérifiable, ce qui diminue les risques d’abus liés aux autorités de certification.
HTTPS vs. TLS : une nuance importante
- HTTPS : Protocole web sécurisant la navigation entre un serveur et un navigateur.
- TLS : Protocole plus général, qui peut protéger de nombreux autres services (email, transfert de fichiers, etc.).
- Les principes de Certificate Transparency s’appliquent tout particulièrement à l’écosystème HTTPS, mais le contrôle des certificats vaut aussi pour d’autres usages de TLS.

3. crt.sh : l’outil de référence

crt.sh, maintenu par Sectigo (ex-Comodo), s’impose comme un portail majeur d’accès aux journaux de Certificate Transparency :

Interface Web
- Recherche par nom de domaine : Entrez mondomaine.fr pour afficher l’historique de tous les certificats associés, qu’ils soient actifs ou expirés.
- Informations détaillées : Numéro de série, émetteur, date d’émission/expiration, algorithme de chiffrement, etc.
API non officielle
- Permet d’automatiser la requête de la base de données.
- Nécessite souvent des requêtes SQL adaptables en HTTP.
- Avantage : Intégrer directement dans un pipeline CI/CD ou un script de supervision pour surveiller vos certificats en continu.
- Limite : Puisqu’elle est non officielle, des changements soudains peuvent casser les scripts en production.
Cas d’usage DevOps
- Surveillance d’infrastructure : Vérifier la création de nouveaux certificats (par ex. sous-domains, environnements de test) et éviter des surprises ou des sous-domaines “fantômes”.
- Cycle de vie Let’s Encrypt : S’assurer que les certificats générés par ACME sont bien enregistrés et qu’aucun certificat indésirable n’a été émis.
- Audit de la concurrence : Surveiller les domaines de vos concurrents pour repérer l’apparition de nouveaux services (sous-domaines révélateurs de tests ou de futures offres).

4. CertStream : la surveillance en temps réel

Outre les recherches ponctuelles ou régulières sur crt.sh, vous pouvez automatiser une surveillance temps réel via CertStream :

Qu’est-ce que CertStream ?
- Un service offrant un flux en direct de tous les certificats ajoutés aux journaux de Certificate Transparency.
- Agrège plusieurs sources, couvrant la plupart des CA (Let’s Encrypt, DigiCert, Sectigo, etc.).
Comment ça marche ?
- API WebSocket : Vous pouvez vous y connecter depuis un script ou un programme, et recevoir automatiquement chaque nouvel événement (certificat émis).
- Filtrage : Surveillez spécifiquement les domaines ou expressions régulières qui vous intéressent (ex. *.mondomaine.fr), afin d’être alerté en quasi temps réel.
Bénéfices
- Réactivité : Identifier un certificat émis de manière abusive ou un sous-domaine non autorisé quelques instants après son apparition.
- Complémentarité : Comparé à crt.sh où la requête est “pull” (vous interrogez le service), CertStream fonctionne en “push” (vous recevez immédiatement les infos).

5. Au-delà du web : TLS dans d’autres environnements

Messagerie
- Protocoles IMAP, POP, SMTP peuvent être protégés par TLS.
- Les certificats émis pour ces services sont également enregistrés dans les journaux CT s’ils sont signés par une CA publique.
- Le même principe de détection s’applique : un certificat SMTP frauduleux serait immédiatement repérable.
VPN, FTP, etc.
- TLS peut aussi chiffrer des connexions VPN (OpenVPN, par exemple) ou FTP (FTPS).
- Qu’il s’agisse du web ou non, tant que vous utilisez un certificat public, il apparaîtra dans les logs CT.
- Les risques de fraude existent aussi dans ce contexte, d’où l’intérêt de la Certificate Transparency.
Let’s Encrypt et ACME
- Même si Let’s Encrypt est très utilisé pour les sites web, il peut aussi fournir des certificats pour d’autres usages (comme un serveur IMAP, un reverse proxy SSL, etc.).
- Tous ces certificats figureront de la même façon dans les journaux CT, avec la même transparence.

6. Cas pratiques : surveiller ses certificats et sa concurrence

Détection de sous-domaines inconnus
- En interrogeant régulièrement crt.sh ou via CertStream, vous pouvez découvrir rapidement des sous-domaines inattendus (par exemple, dev.mondomaine.fr).
- Utile pour vérifier qu’aucun service n’a été créé en dehors des procédures internes.
Analyse concurrentielle
- Appliquez la même méthode aux domaines de vos concurrents.
- Vous pourriez repérer un sous-domaine révélant un projet en cours, comme beta.concurrent.fr.
- À manier avec discernement : la transparence vaut dans les deux sens, vos sous-domaines aussi sont visibles.
Scripts et notifications
- Via l’API non officielle de crt.sh, vous pouvez créer un cron job qui interroge la base toutes les heures, puis envoie un e-mail Slack/Teams si de nouveaux certificats sont détectés.
- Avec CertStream, recevez des webhooks en temps réel, facilitant une réaction instantanée en cas de menace.

7. Limites, bonnes pratiques et optimisations

Limites
- Délai de propagation : Même avec CertStream, il peut y avoir quelques secondes ou minutes de décalage.
- Faux positifs : Certains certificats émis pour des tests internes ou expirés peuvent apparaître. Vérifier avant de tirer la sonnette d’alarme.
- API non officielle (crt.sh) : Peut changer sans préavis, nécessitant une maintenance régulière de vos scripts.
Bonnes pratiques
- Revue périodique : Mettre en place un processus de vérification (journalier ou hebdomadaire) pour votre domaine, vos sous-domaines et vos services non-web.
- Politique de cycle de vie : Consolider les pratiques de renouvellement (via Let’s Encrypt ou un autre CA) et s’assurer que chaque certificat émis est connu et validé.
- Sensibilisation : Informer vos équipes que toute émission de certificat TLS public (web, mail, VPN…) sera visible publiquement dans la CT.

Conclusion

La Certificate Transparency a marqué un tournant dans la gestion et la surveillance des certificats TLS. Qu’il s’agisse de sites web (HTTPS) ou de services divers (mail, VPN, FTP…), l’ensemble des certificats émis par des CA publics se retrouve dans des journaux consultables par tous.

Des outils comme crt.sh et CertStream permettent aux professionnels de la sécurité, aux DevOps et aux administrateurs système de :

Surveiller en continu leur propre domaine, en repérant de nouveaux sous-domaines ou des certificats non autorisés.
Analyser la concurrence pour anticiper les éventuels lancements de nouveaux services.
Renforcer la posture de sécurité globale en réagissant instantanément à toute anomalie.

Dans un contexte où la confiance et la sécurité sont indispensables, la CT contribue à la fiabilité de l’écosystème TLS bien au-delà de la seule sphère du web.

Pour completer je vous conseille de lire cette récente publication de l’ANSSI sur : Automatisation de la gestion des certificats avec ACME

FAQ

Q : Qu’est-ce que la Certificate Transparency (CT) ?
R : C’est un ensemble de journaux publics append-only où les CA publient les certificats qu’ils émettent. Cela facilite la détection d’anomalies ou de fraudes.

Q : À quoi sert CertStream ?
R : CertStream fournit un flux en temps réel des nouveaux certificats ajoutés aux journaux CT. Il permet de réagir très rapidement à l’émission d’un certificat suspect.

Q : TLS est-il uniquement pour le web ?
R : Non. TLS peut aussi sécuriser des protocoles comme SMTP, IMAP, FTPS, VPN, etc. Dès lors qu’un certificat public est émis, il peut apparaître dans les logs CT.

TickTick Avis : L'application ultime pour une organisation sans faille ?

2024-12-29T00:00:00+00:00

S’organiser efficacement devient souvent un casse-tête quand nos tâches s’accumulent dans tous les sens. TickTick attire l’attention comme solution pour gérer ce chaos quotidien, mais cette application de gestion de tâches est-elle vraiment à la hauteur des attentes ? Dans cet avis complet sur TickTick, nous examinerons ses fonctionnalités principales, son interface et son rapport qualité-prix pour déterminer si elle mérite sa réputation d’outil d’organisation performant. À travers notre évaluation détaillée, vous découvrirez si cette application pourrait transformer votre productivité ou si d’autres alternatives répondraient mieux à vos besoins.

Sommaire

Résumé de notre avis sur TickTick
Tarifs de TickTick
TickTick : pour qui ?
Liste des fonctionnalités
Avis clients
Comparatif avec d'autres outils de productivité
Avis final
Comment commencer avec TickTick ?

Résumé de notre avis sur TickTick

TickTick se présente comme un gestionnaire de tâches complet qui aide à structurer votre quotidien personnel et professionnel. Cette application multiplateforme offre une synchronisation cloud efficace entre tous vos appareils. Sa force réside dans son interface intuitive, son calendrier intégré et son timer Pomodoro qui favorisent une meilleure organisation.

Découvrez dès maintenant comment TickTick peut booster votre productivité !

Avantages et inconvénients de TickTick

Avantages	Inconvénients
✅ Interface conviviale et intuitive	❌ Service payant pour accéder aux fonctionnalités avancées (non essentiel)
✅ Disponible sur plus de 10 plateformes	❌ Service client parfois peu réactif
✅ Synchronisation cloud efficace
✅ Calendrier intégré et Pomodoro Timer
✅ Copie facile des listes de tâches depuis emails
✅ Fonctionnalités de collaboration et partage

Tarifs de TickTick

Les différentes formules

TickTick propose deux options tarifaires pour répondre aux besoins variés des utilisateurs. La version gratuite offre déjà de nombreuses fonctionnalités importantes pour commencer à gérer vos tâches efficacement. Pour les utilisateurs ayant besoin d’outils plus avancés, la formule Premium est disponible au prix de 35,99 $ par an, soit moins de 3 $ par mois.

Comparaison des fonctionnalités : Version Gratuite vs. Version Premium de TickTick

Fonctionnalité	Version Gratuite	Version Premium
Nombre de listes	Jusqu’à 9	Jusqu’à 299 (listes fermées exclues)
Tâches par liste (tâches fermée exclues)	Jusqu’à 99	Jusqu’à 999
Sous-tâches par tâche	Jusqu’à 19	Jusqu’à 199
Rappels par tâche	2	5
Membres par liste partagée	1	29 par liste
Pièces jointes par jour	1	99
Filtres	Non	Oui
Vues du calendrier	Vue Liste	Toutes les vues (Liste, Mois, Jour, 3-Jours, Semaine)
Planification des tâches	2 planifications par semaine	Planification illimitée

La version Premium débloque des fonctionnalités exclusives qui améliorent notablement l’expérience utilisateur. Vous accédez aux vues de calendrier avancées, aux filtres personnalisés pour organiser vos tâches selon vos critères, et au suivi détaillé de vos habitudes. Les listes intelligentes permettent également de filtrer automatiquement vos tâches selon des paramètres comme les dates d’échéance ou les priorités.

Toutefois, l’utilisation est largement utilisable même gratuitement.

Testez TickTick ici ✔

Mon avis sur le prix de TickTick

Comparé à d’autres applications de productivité similaires, TickTick offre un excellent rapport qualité-prix. Pour moins de 3 $ par mois (ou 36 $ à l’année), les utilisateurs obtiennent un outil complet de gestion de tâches avec des fonctionnalités avancées qui justifient amplement l’investissement. La note de 4,6/5 sur GetApp pour le rapport qualité-prix confirme cette impression partagée par de nombreux utilisateurs.

TickTick : pour qui ?

TickTick s’adresse particulièrement aux professionnels cherchant à optimiser leur gestion des tâches quotidiennes. Cette application de productivité offre un système d’organisation efficace avec ses différentes vues de calendrier et sa technique Pomodoro qui divise le travail en intervalles de 25 minutes. Sa bibliothèque d’habitudes permet également de suivre vos progrès quotidiens dans l’atteinte de vos objectifs personnels et professionnels.

Pour bien cerner qui profitera le plus de TickTick, voici une liste des profils types :

Professionnels occupés : TickTick est idéal pour les professionnels qui jonglent avec de nombreux projets et tâches. L’application permet une gestion efficace de l’emploi du temps et aide à maintenir une organisation rigoureuse au quotidien.
Étudiants : organiser cours, devoirs et examens. L’application favorise également le développement de bonnes habitudes d’étude et permet de mieux gérer le temps.
Indépendants : TickTick offre aux indépendants la possibilité de se fixer des objectifs clairs et de séparer leur vie personnelle de leur vie professionnelle. L’application aide à éviter de trop s’éparpiller et à maintenir une discipline de travail régulière.
Personnes atteintes de TDAH : L’interface simple et personnalisable de TickTick, ainsi que ses rappels constants, peuvent être particulièrement utiles pour les personnes atteintes de TDAH. L’application aide à structurer les tâches, à définir des échéances et à suivre les progrès au fil du temps.

Les personnes atteintes de TDAH trouvent dans TickTick un outil utile grâce à son interface simple qui maintient l’ordre sans nécessiter une configuration complexe. Les rappels persistants sont particulièrement utiles pour ceux qui ont des difficultés à se souvenir des tâches, tandis que la vue structurée aide à organiser les pensées et responsabilités.

Dans le monde de l’entreprise, TickTick facilite la collaboration en permettant le partage de listes avec collègues et collaborateurs. La synchronisation en temps réel sur toutes les plateformes (téléphone, ordinateur, tablette) garantit que chaque membre de l’équipe reste connecté et informé des avancements de projets communs.

Liste des fonctionnalités

Gestion des tâches et des listes

TickTick propose un système complet de gestion des tâches qui constitue le cœur de cette application. Vous pouvez créer rapidement des tâches avec différents niveaux de priorité et des échéances personnalisables. L’application reconnaît même le langage naturel pour définir automatiquement les dates lorsque vous tapez. Les sous-tâches permettent de découper vos projets en étapes plus digestes tandis que les options de répétition s’avèrent idéales pour les activités récurrentes. Cette organisation intuitive vous aide à garder la vue d’ensemble sur tous vos projets sans jamais vous sentir débordé.

Les listes intelligentes représentent l’une des fonctionnalités les plus appréciées de TickTick Premium. Elles filtrent automatiquement vos tâches selon des critères comme les dates d’échéance, les étiquettes ou les priorités. Par exemple, vous pouvez créer une liste qui affiche uniquement les tâches à haute priorité devant être accomplies cette semaine. Les tags permettent quant à eux de catégoriser vos tâches par thème ou par contexte, facilitant leur recherche ultérieure.

Calendrier intégré et planification

Le calendrier intégré se synchronise parfaitement avec les tâches que vous créez. Chaque nouvelle échéance apparaît automatiquement dans votre agenda, offrant une vision claire de votre emploi du temps. Vous pouvez également faire glisser vos tâches directement sur le calendrier pour planifier votre journée ou votre semaine. La synchronisation bidirectionnelle avec Google Calendar ou Outlook permet de centraliser tous vos rendez-vous et obligations.

Types de vues calendrier disponibles dans TickTick et leurs utilisations

Vue du Calendrier	Description	Utilisation Optimale
Liste	Affiche les tâches sous forme de liste chronologique.	Visualiser rapidement les tâches à venir et leur échéance.
Mois	Offre un aperçu général de l’ensemble du mois.	Planification à long terme et identification des périodes chargées.
Jour	Se concentre sur les tâches et événements d’une seule journée.	Organisation détaillée de la journée et gestion du temps.
3-Jours	Présente les tâches et événements sur une période de trois jours.	Avoir une vue d’ensemble des prochains jours et de leur charge de travail.
Semaine	Fournit une vue d’ensemble de la semaine en cours.	Planification hebdomadaire et suivi des progrès.

Technique Pomodoro et suivi du temps

Le Timer Pomodoro intégré à TickTick divise votre travail en sessions de 25 minutes pour améliorer votre concentration. Cette technique vous encourage à vous consacrer pleinement à une tâche pendant un court intervalle, suivi d’une pause bien méritée. Vous pouvez associer le minuteur directement à vos tâches pour suivre le temps consacré à chaque projet et identifier vos moments de productivité optimale.

L’application propose également des outils d’analyse qui mesurent le temps passé sur chaque catégorie de tâches. Ces données révèlent comment vous distribuez vos efforts entre vos activités personnelles et professionnelles. Les graphiques visuels montrent votre progression au fil du temps et vous aident à identifier les tendances dans votre productivité.

Suivi des habitudes et objectifs

La fonction de suivi des habitudes dans TickTick va au-delà d’une simple liste de tâches en vous aidant à développer des routines positives. Vous pouvez définir des objectifs quotidiens, hebdomadaires ou mensuels, puis suivre votre constance via des visualisations claires. L’application propose même une bibliothèque d’habitudes préétablies pour vous inspirer, des plus basiques comme boire suffisamment d’eau aux plus ambitieuses comme apprendre une nouvelle langue.

Pour bien comprendre comment TickTick peut vous aider, voici une liste des habitudes et objectifs que vous pouvez suivre efficacement :

Suivi des habitudes quotidiennes : Suivez facilement des habitudes quotidiennes comme faire de l’exercice, lire, méditer ou boire de l’eau. Définissez des objectifs pour chaque habitude et suivez vos progrès.
Gestion des objectifs à long terme : Définissez des objectifs à long terme, tels que terminer un projet, apprendre une nouvelle compétence ou atteindre un certain niveau de forme physique. L’application vous aide à décomposer ces objectifs en étapes plus petites.
Amélioration de la productivité : Suivez votre temps de travail et identifiez les tâches qui prennent le plus de temps. Utilisez le minuteur Pomodoro pour améliorer votre concentration.
Développement de routines positives : Développez des routines en recevant des rappels pour les tâches importantes et en suivant vos progrès. Créez des listes de contrôle pour vos routines quotidiennes et hebdomadaires.

Fonctionnalités collaboratives

TickTick facilite le travail en équipe grâce à ses options de partage de listes. Vous pouvez inviter des collaborateurs ou des membres de votre famille à accéder à des listes spécifiques, puis assigner des tâches à différentes personnes. La version Premium autorise jusqu’à 30 membres par liste partagée, contre seulement 2 dans la version gratuite. Les mises à jour se synchronisent en temps réel, garantissant que tous les participants disposent des informations les plus récentes.

Avis clients

TickTick récolte des notes impressionnantes sur les plateformes d’évaluation spécialisées. Sur GetApp, l’application obtient une moyenne de 4,7 étoiles basée sur 124 avis d’utilisateurs. Cette même note se retrouve sur Capterra, confirmant la satisfaction générale des utilisateurs envers ce logiciel de gestion de tâches.

Les utilisateurs apprécient particulièrement l’interface intuitive de TickTick qui facilite la gestion des projets. La possibilité d’organiser les tâches avec des étiquettes et des dates d’échéance est souvent citée comme un point fort. Le calendrier intégré et la matrice d’Eisenhower pour prioriser les tâches sont également très appréciés dans les évaluations.

Parmi les points négatifs mentionnés, on trouve principalement les limitations de la version gratuite. Certains utilisateurs regrettent que les fonctionnalités avancées, comme les vues de calendrier complètes ou les filtres personnalisés, soient réservées à la version Premium. D’autres signalent des problèmes occasionnels avec le service client.

“TickTick est un logiciel de gestion et de suivi de tâches avec une interface très conviviale et surtout multiplateforme”, note un utilisateur sur Capterra.
“C’est le meilleur rapport qualité-prix. Il offre tout ce dont vous avez besoin d’une application de tâches, plus de nombreuses fonctionnalités utiles”, commente un autre.
Un troisième apprécie particulièrement la facilité de copier des listes depuis les emails : “L’application sépare automatiquement toutes les lignes en tâches distinctes”.

Comparatif avec d'autres outils de productivité

Fonctionnalité	TickTick	Todoist	Microsoft To Do
Gestion des sous-tâches	Oui	Oui	Oui
Timer Pomodoro	Oui	Non	Non
Suivi d’habitudes	Oui	Non	Non
Intégration calendrier	Oui	Oui	Oui
Version gratuite complète	Oui	Oui	Oui

Ce comparatif permet d’illustrer clairement les atouts spécifiques de TickTick par rapport à ses concurrents.

Avis final

TickTick se distingue par sa polyvalence remarquable en matière d’organisation. L’application excelle grâce à son interface intuitive et sa synchronisation multiplateforme. Ses fonctionnalités de gestion des tâches permettent de structurer efficacement projets personnels et professionnels. Le calendrier intégré et la technique Pomodoro constituent des atouts majeurs pour améliorer la productivité quotidienne. La version gratuite offre déjà une expérience complète, tandis que l’abonnement Premium débloque des options avancées pour les utilisateurs exigeants.

Malgré ses nombreux points forts, TickTick présente quelques limitations. Le service client peut manquer de réactivité face aux problèmes signalés, et certains utilisateurs mentionnent des soucis occasionnels avec la facturation. Pour les équipes nécessitant des fonctionnalités collaboratives avancées, d’autres logiciels comme Asana ou ClickUp pourraient mieux convenir. La courbe d’apprentissage peut également sembler un peu raide pour les débutants.

Pour conclure, TickTick représente véritablement un outil performant pour améliorer son organisation personnelle et professionnelle. Son approche équilibrée entre simplicité et fonctionnalités avancées en fait une solution idéale pour la plupart des utilisateurs. L’application répond particulièrement aux besoins des professionnels occupés, des étudiants et des personnes souffrant de TDAH grâce à ses rappels et sa planification. La version gratuite permet déjà d’expérimenter l’essentiel de ses capacités, offrant une bonne introduction avant éventuellement de passer à l’abonnement Premium.

Testez Ticktick ici

Comment commencer avec TickTick ?

Pour démarrer rapidement et exploiter pleinement l’application, suivez ces quelques étapes :

Téléchargez l’application sur votre plateforme préférée (iOS, Android, Windows, macOS ou via le web).
Créez un compte gratuit ou connectez-vous avec votre compte Google, Facebook ou Apple.
Commencez par créer une première liste, par exemple « Tâches quotidiennes » pour organiser vos priorités.
Explorez les fonctionnalités Premium grâce à l’essai gratuit proposé lors de l’inscription.

Profitez de TickTick gratuitement !

FAQ

TickTick est-il sûr pour mes données personnelles ?

La sécurité des données personnelles avec TickTick suscite certaines interrogations, notamment en raison de son origine chinoise et d’un manque de transparence perçu. Bien que TickTick utilise Amazon Web Services (AWS) pour le stockage des données – garantissant une infrastructure sécurisée –, cela ne signifie pas nécessairement que l’entreprise ne peut pas consulter les données des utilisateurs.

Certains utilisateurs craignent que TickTick ne soit un “programme espion chinois” et hésitent à y confier des informations sensibles. Le manque d’informations claires sur l’entreprise et sa direction alimente également ces inquiétudes.

Quelles sont les options de partage et de collaboration de TickTick ?

TickTick propose des options de partage et de collaboration efficaces. Il permet le partage de listes avec des amis et des collègues, facilitant ainsi l’attribution et le suivi des tâches.
Les utilisateurs peuvent suivre l’avancée des travaux, assigner ou récupérer des tâches, et mettre à jour le statut en temps réel selon l’évolution des projets.

TickTick est-il totalement gratuit ou y a-t-il des coûts cachés ?

TickTick propose une version gratuite qui offre de nombreuses fonctionnalités permettant d’organiser, gérer et collaborer sur les tâches. Toutefois, pour accéder à des fonctionnalités plus avancées, il est nécessaire de passer à la version Premium payante.
La version Premium offre notamment un nombre accru de listes et de tâches, la possibilité d’ajouter plus de rappels par tâche, le partage de listes avec davantage de membres, ainsi que l’accès à des vues de calendrier avancées.

Gestion des dates et timezones MySQL : optimisation et index

2024-11-30T00:00:00+00:00

La gestion des dates et des timezones dans MySQL est une problématique incontournable pour les applications modernes. Que ce soit pour synchroniser des données entre plusieurs régions ou optimiser vos requêtes, une approche réfléchie est essentielle.

Combien de fois vos requêtes SQL ont-elles ralenti à cause d’un mauvais filtre sur les dates ? Dans cet article, nous explorons les subtilités des dates et des timezones, en abordant des exemples pratiques, des astuces d’optimisation et des solutions avancées comme la création d’index dérivés.

1. Pourquoi la gestion des dates et timezones est cruciale

Dans les bases de données modernes, travailler avec des dates implique souvent de jongler avec des fuseaux horaires différents.

Cela peut devenir problématique lorsque :

Vous devez afficher les dates dans le fuseau horaire de l’utilisateur.
Les comparaisons ou filtrages impliquent des transformations sur des colonnes datetime.
Les performances de vos requêtes se dégradent à cause de la perte d’indexation.

MySQL offre des outils puissants pour gérer ces problématiques, mais leur mauvaise utilisation peut entraîner des impacts significatifs sur les performances.

2. Les timezones dans MySQL

2.1 Utiliser `CONVERT_TZ()`

La fonction CONVERT_TZ() permet de convertir une date d’un fuseau horaire à un autre.

C’est une fonctionnalité essentielle pour s’assurer que vos dates sont interprétées correctement en fonction du contexte utilisateur.

SELECT CONVERT_TZ('2024-11-30 12:00:00', 'UTC', 'Europe/Paris') AS converted_date;

Pour que cette fonction fonctionne correctement, assurez-vous que vos tables time_zone sont configurées dans MySQL :

mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql

2.2 Vérifier et modifier les timezones

Vous pouvez vérifier la timezone actuelle utilisée par le serveur MySQL :

SELECT @@global.time_zone, @@session.time_zone;

Pour changer la timezone au niveau session ou global :

SET time_zone = 'Europe/Paris';

2.3 `NOW()` vs `UTC_TIMESTAMP()`

NOW() : retourne la date/heure locale selon la timezone du serveur MySQL.
UTC_TIMESTAMP() : retourne toujours la date/heure en UTC.

3. Optimiser les formats de date avec `DATE_FORMAT()`

La fonction DATE_FORMAT() permet de personnaliser le format de vos dates pour les rendre plus lisibles.

Exemple d’utilisation :

SELECT DATE_FORMAT('2024-11-30', '%W, %D %M %Y') AS formatted_date;
-- Résultat : Saturday, 30th November 2024

Spécificateurs utiles :

%Y : Année sur quatre chiffres.
%m : Mois sur deux chiffres.
%d : Jour du mois sur deux chiffres.
%H : Heure (24h).
%i : Minutes.
%s: Secondes

4. Impact sur les index

Lorsque vous utilisez DATE_FORMAT() ou CONVERT_TZ() dans une clause WHERE, MySQL ne peut pas tirer parti des index sur la colonne datetime. Cela peut entraîner des ralentissements, notamment sur des tables volumineuses.

Exemple problématique :

SELECT * FROM orders WHERE DATE_FORMAT(order_date, '%Y-%m-%d') = '2024-11-30';

Dans cet exemple, l’utilisation de DATE_FORMAT() force MySQL à effectuer une transformation sur chaque ligne, ce qui empêche l’utilisation d’un index.

Les performences sont dont fortement dégradé des l’augmentation du volume.

5. Optimisations

5.1 Utiliser un pre-filtre

Pour optimiser vos requêtes tout en tenant compte des timezones, il est souvent plus efficace d’utiliser une approche en deux étapes. D’abord, filtrez avec une plage plus large qui utilise l’index, puis affinez le résultat avec une conversion de timezone.

Par exemple pour passer de UTC jusqu’a Europe/Paris on sait qu’on va avoir un décalage de une ou deux heures (en fonction de la periode).

Petit tips : Faites attention le changement d’heure change en fonctions des années et ca n’a pas toujours été régis par une regle fixe comme dernier samedi de mars ou d’octobre

Pour eviter tout soucis je vous conseille de voir toujours un peu plus large

SELECT * FROM events 
WHERE event_date >= '2024-11-30 08:10:00' 
  AND event_date <= '2024-11-30 16:10:00'
  AND CONVERT_TZ(event_date, 'UTC', 'Europe/Paris') >= '2024-11-30 12:00:00';
  AND CONVERT_TZ(event_date, 'UTC', 'Europe/Paris') < '2024-11-30 14:00:00';

Il s’agit d’une solution que j’utilise régulierement de mon coté quand je dois transformer des dates pour des resultats statistique.

5.2 Créer des index dérivés pour optimiser les transformations

Pour pallier les limitations des fonctions comme DATE_FORMAT() ou CONVERT_TZ(), il est également possible de créer des colonnes calculées et de leur appliquer un index. Cette méthode permet de conserver des requêtes rapides tout en manipulant facilement les dates.

5.2.1 Ajouter une colonne calculée

Ajoutez une colonne dérivée pour stocker le résultat de DATE_FORMAT() ou CONVERT_TZ() et indexez-la.

ALTER TABLE orders 
ADD COLUMN formatted_date VARCHAR(10) GENERATED ALWAYS AS (DATE_FORMAT(order_date, '%Y-%m-%d')) STORED;
CREATE INDEX idx_formatted_date ON orders(formatted_date);

Dans cet exemple :

formatted_date contient le résultat de DATE_FORMAT(order_date, '%Y-%m-%d').
L’index idx_formatted_date optimise les recherches sur cette colonne.

5.2.1 Utilisation dans une requête

Une fois l’index appliqué, vos requêtes sont bien plus performantes :

SELECT * FROM orders WHERE formatted_date = '2024-11-30';

Avantages et inconvénients

Avantages :
- Les requêtes sont optimisées grâce à l’index sur la colonne dérivée.
- Moins de transformations sont effectuées lors de l’exécution des requêtes.
Inconvénients :
- Cela augmente légèrement la taille de la table.
- Nécessite de recalculer la colonne dérivée lors des mises à jour.

Personellement je n’utilise quasiment jamais cette solution.

6. Conseils pratiques pour maximiser les performances

Évitez d’utiliser des fonctions sur les colonnes indexées dans vos clauses WHERE.
- Préférez les colonnes dérivées ou des solutions de filtre en deux etapes.
Stockez les dates en UTC dans la base de données.
- Cela garantit une cohérence globale et simplifie les conversions.
Maintenez vos timezones à jour.
- Les règles de fuseau horaire évoluent (changements d’heure, nouvelles lois). Assurez-vous que vos tables MySQL sont à jour avec :
```
mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
```
Ajoutez des colonnes supplémentaires si nécessaire.
- Par exemple, une colonne pré-calculée avec la timezone locale pour accélérer les requêtes fréquemment exécutées.
Usez et abusez de EXPLAIN
- Ca vous permettra de verifier la bonne utilisation de vos index (je vous conseille de toujours vous en servir)

FAQ : gestion des dates et timezones en MySQL

Pour répondre rapidement aux questions fréquentes sur ce sujet, voici une FAQ résumant les points essentiels de l’article.

Comment MySQL gère-t-il les timezones par défaut ?

Par défaut, MySQL utilise la timezone du système d’exploitation. Vous pouvez la modifier avec une commande comme :

SET time_zone = 'Europe/Paris';

Quelle est la meilleure pratique pour stocker des dates dans MySQL ?

Toujours stocker les dates en UTC et effectuer les conversions nécessaires au niveau de l’application. Cela garantit la cohérence des données et simplifie leur gestion dans des systèmes distribués.

Pourquoi utiliser EXPLAIN dans vos requêtes SQL ?

EXPLAIN est un outil essentiel pour vérifier si vos requêtes utilisent les index efficacement. Il permet d’identifier les goulots d’étranglement et d’optimiser vos requêtes en conséquence.

6. Conclusion

La gestion des dates et des timezones en MySQL nécessite une attention particulière pour garantir la précision des données tout en optimisant les performances. En adoptant des solutions comme les colonnes dérivées indexées, vous pouvez :

Gérer efficacement les fuseaux horaires.
Maintenir une base de données performante même avec de gros volumes de données.
Éviter les pièges classiques des transformations sur colonnes datetime.

Avec ces bonnes pratiques, vous serez prêt à relever les défis liés à la gestion des dates et timezones dans vos projets SQL.

5 outils gratuits pour booster votre productivité en dev web

2024-11-21T00:00:00+00:00

En tant que développeur web, il est crucial d’utiliser les bons outils pour optimiser votre temps et améliorer vos performances. Heureusement, il existe des solutions gratuites qui couvrent tous les aspects du développement : édition de code, gestion de projets, collaboration ou encore tests d’API. Voici ma sélection des 5 outils gratuits incontournables pour tout développeur web.

1. Visual Studio Code (VS Code)

Pourquoi l’utiliser ?

Cet éditeur de code gratuit est une référence dans le monde du développement grâce à sa légèreté et ses nombreuses extensions. Que vous travailliez sur du PHP, du JavaScript ou d’autres langages, VS Code s’adapte parfaitement à vos besoins.

C’est probablement le meilleur IDE gratuit, en alternative payante les outils jetbrains sont vraiment incroyable.

Fonctionnalités clés :

Intégration Git native pour un suivi des versions.
Extensions comme Prettier (formatage automatique) ou PHP Intelephense (autocomplétion avancée).
Mode collaboratif avec Live Share pour coder simultanément avec vos collègues.

Astuce : Personnalisez votre environnement avec des thèmes comme Dracula ou One Dark Pro pour un confort visuel optimal.

2. Trello

Pourquoi l’utiliser ?

Trello est un outil simple et visuel basé sur des tableaux Kanban. Il est parfait pour organiser vos tâches et suivre l’avancement de vos projets de développement.

Fonctionnalités clés :

Création de tableaux pour gérer vos tâches par étape (ex. : “À faire”, “En cours”, “Terminé”).
Intégrations avec des outils comme Slack ou Google Drive.
Version gratuite suffisante pour la plupart des projets individuels ou en équipe.

Astuce : Utilisez des étiquettes colorées pour prioriser vos tâches selon leur urgence ou leur importance.

3. Postman

Pourquoi l’utiliser ?

Postman est un outil incontournable pour tester et déboguer vos API. Il permet d’envoyer facilement des requêtes HTTP et d’analyser les réponses.

Fonctionnalités clés :

Testez des requêtes GET, POST, PUT ou DELETE en quelques clics.
Créez et partagez des collections d’API avec votre équipe.
Simulez différents environnements (local, staging, production).

Astuce : Automatisez vos tests directement dans Postman pour vérifier la stabilité de vos API après chaque mise à jour.

J’ai eu la chance de faire une présentation au /dev/var de l’outil : Découvrir la présentation de postman

4. Figma

Pourquoi l’utiliser ?

Pour les développeurs front-end ou ceux qui collaborent avec des designers, Figma est une solution collaborative puissante pour créer et partager des maquettes interactives.

Fonctionnalités clés :

Travaillez en temps réel avec votre équipe sur les mêmes designs.
Exportez facilement les assets nécessaires au développement front-end.
Accédez à une bibliothèque communautaire de templates gratuits via Figma Community.

Astuce : Utilisez Figma pour créer rapidement des wireframes avant de vous lancer dans le code.

5. GitHub

Pourquoi l’utiliser ?

GitHub n’est pas seulement une plateforme de gestion de version ; c’est aussi un outil collaboratif puissant pour partager votre code et travailler en équipe sur des projets open source ou privés.

Fonctionnalités clés :

Hébergez gratuitement vos dépôts publics ou privés.
Utilisez les Issues et Projects pour gérer les tâches liées à chaque projet.
Automatisez vos workflows avec GitHub Actions (tests CI/CD).

Astuce : Explorez les dépôts open source populaires sur GitHub pour apprendre de nouvelles techniques et contribuer à la communauté.

Conclusion

Ces outils gratuits sont essentiels pour tout développeur web souhaitant améliorer sa productivité. Ils couvrent tous les aspects critiques du métier : édition de code, gestion de projet, test d’API, conception UI/UX et collaboration. Essayez-les dès aujourd’hui et transformez votre workflow !

Et vous ? Quels sont vos outils préférés ? Partagez-les dans les commentaires ! 😊

DMARC : Sécurisez vos emails contre le phishing

2024-10-27T00:00:00+00:00

DMARC, SPF, DKIM : Les Clés de la Sécurité de l’Emailing

Les attaques de phishing sont un problème majeur en cybersécurité, affectant des milliers d’entreprises et d’individus chaque année par des e-mails frauduleux. Une bonne gestion de la sécurité des e-mails est essentielle pour prévenir ces menaces, et cela passe par la mise en place de protocoles tels que DMARC, SPF, et DKIM. Ces technologies, lorsque bien configurées, permettent de renforcer la crédibilité de vos communications par email et de protéger votre domaine contre les attaques.

Qu’est-ce que DMARC, SPF et DKIM ?

SPF (Sender Policy Framework)

SPF est un protocole qui permet de définir les serveurs autorisés à envoyer des emails en votre nom. Cela empêche les attaquants d’utiliser votre domaine pour envoyer des e-mails malveillants, réduisant ainsi les risques d’usurpation d’identité.

SPF Policy Types :
- -all : Rejette tous les emails non autorisés.
- ~all : Soft fail (les e-mails non autorisés seront marqués comme suspects).
- ?all : Neutre (aucune action spécifique, laisse le serveur du destinataire décider).

Pour tester et vérifier votre configuration SPF, vous pouvez utiliser des outils en ligne comme MXToolbox.

DKIM (DomainKeys Identified Mail)

DKIM ajoute une signature numérique unique à chaque email envoyé, permettant au destinataire de vérifier que l’email est bien authentique et qu’il n’a pas été modifié durant son transit. Cette authentification assure l’intégrité des messages et contribue à établir la confiance.

DKIM Configuration : La signature est générée par une paire de clés publique/privée. La clé publique est publiée dans les enregistrements DNS, et la clé privée est utilisée par le serveur d’envoi pour signer les emails.

DMARC (Domain-based Message Authentication, Reporting & Conformance)

DMARC se base sur les protocoles SPF et DKIM pour offrir une politique de validation unifiée. Il permet au propriétaire du domaine de définir la manière dont les emails non conformes doivent être traités (par exemple, rejeter, mettre en quarantaine). En plus de cette validation, DMARC fournit des rapports sur les échecs de vérification, ce qui permet une meilleure supervision et ajustement de la sécurité.

Exemples de Configuration pour DMARC, SPF et DKIM

Exemple de Configuration SPF

Pour configurer SPF, vous devez ajouter un enregistrement TXT à votre DNS. Voici un exemple :

"v=spf1 include:_spf.google.com -all"

Dans cet exemple :

v=spf1 indique la version du SPF.
include:_spf.google.com signifie que Google est autorisé à envoyer des e-mails au nom de votre domaine.
-all définit que tout autre serveur non spécifié sera rejeté.

Exemple de Configuration DKIM

DKIM implique de générer une paire de clés publique/privée. La clé publique doit être ajoutée à vos enregistrements DNS :

"v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC... (clé publique abrégée)"

v=DKIM1 : Version du DKIM.
k=rsa : Type de chiffrement utilisé.
p= : La clé publique qui sera utilisée pour vérifier la signature DKIM.

La clé privée est installée sur le serveur de messagerie, qui signe les e-mails sortants.

Exemple de Configuration DMARC

Pour DMARC, un enregistrement TXT doit être ajouté à votre DNS, comme ci-dessous :

"v=DMARC1; p=reject; rua=mailto:dmarc-reports@votre-domaine.com; ruf=mailto:dmarc-failures@votre-domaine.com; pct=100"

v=DMARC1 : Version de DMARC.
p=reject : Politique appliquée aux e-mails non conformes (ici, rejet total des e-mails non validés).
rua : Adresse e-mail de rapport agrégé.
ruf : Adresse pour les rapports de forensic (rapports détaillés).
pct=100 : Pourcentage d’e-mails auxquels appliquer la politique.

Comprendre les Différentes Politiques DMARC

Lors de la configuration de DMARC, vous avez le choix entre trois politiques : none, quarantine, et reject. Une politique en “none” est souvent utilisée lors des premières phases de mise en place, car elle permet de collecter des informations sans impacter la délivrabilité des e-mails. Cette phase est cruciale pour évaluer les résultats et ajuster la configuration des protocoles SPF et DKIM. Cependant, une politique en “none” n’offre aucune protection réelle contre les e-mails frauduleux.

None : Le domaine n’exige aucune action sur les e-mails non conformes, mais reçoit des rapports pour observer le trafic. Cela permet de comprendre la provenance des problèmes avant de passer à des mesures plus strictes.
Quarantine : Les e-mails non conformes sont mis en quarantaine (par exemple, redirigés vers le dossier spam).
Reject : Les e-mails non conformes sont tout simplement rejetés et n’atteignent jamais la boîte de réception du destinataire.

Il est recommandé de passer progressivement de “none” à “reject” afin d’assurer une protection maximale contre les cyberattaques par e-mail, tout en évitant les interruptions involontaires de la délivrabilité.

DMARC et la Cybersécurité : Prévenir les Attaques de Phishing

Une des principales menaces pour les entreprises aujourd’hui est le phishing, où des attaquants envoient des e-mails qui semblent provenir de sources fiables dans le but de voler des informations sensibles. DMARC joue un rôle essentiel dans la prévention du phishing en évitant que des attaquants n’usurpent votre domaine pour envoyer ces faux e-mails.

Un exemple récent de campagne de phishing concerne les e-mails frauduleux visant les usagers de l’ANTS (Agence Nationale des Titres Sécurisés). Ces messages étaient conçus pour ressembler à des communications officielles afin de soutirer des informations personnelles. Si l’ANTS avait mis en place une politique stricte DMARC (comme “reject”), il aurait été possible d’empêcher la grande majorité de ces e-mails frauduleux d’atteindre leur cible.

En effet, de par la politique dmarc en none de france-identite.gouv.fr les attaquant on eu la possibilité d’envoyer des mails avec en expéditeur noreply@france-identite.gouv.fr ce qui est vraiment sensible. En effet le domaine utilisé est le bon et a part en regardant les headers c’est difficile de le voir (meme si gmail montre le relais de mémoire).

Lien vers l’alerte officielle ANTS concernant cette campagne de phishing.

Bonnes Pratiques en Emailing pour une Meilleure Sécurité

Pour assurer la sécurité de vos campagnes d’emailing et éviter que votre domaine soit utilisé à des fins malveillantes, il est important de suivre certaines bonnes pratiques :

Commencez par une phase de surveillance avec une politique DMARC en “none”, pour analyser les rapports et identifier les problèmes. Evidement si vous êtes sur un nouveaux domaine vous pouvez directement passer en reject (il n’ya pas de soucis de potentiellement casser l’existant).
Configurez correctement SPF et DKIM afin de garantir l’authenticité de vos e-mails.
Passez progressivement à une politique de “quarantine” puis de “reject”, pour renforcer la sécurité de vos e-mails et minimiser les risques de phishing.
Vérifiez régulièrement les rapports DMARC afin de maintenir une bonne délivrabilité et assurer une protection optimale.

Notons qu’actuellement DMARC est obligatoire pour envoyer des mails vers gmail ou yahoo (il faut l’enregistrement même en none)

Conclusion

La mise en place de DMARC, SPF, et DKIM est essentielle pour protéger les communications par email et améliorer la cybersécurité de votre organisation. En suivant une approche progressive, vous pouvez renforcer votre emailing et réduire considérablement les risques d’attaques par phishing. Comme l’illustre l’exemple de l’ANTS, des mesures strictes peuvent éviter des conséquences importantes pour les utilisateurs et les entreprises.

Partitionnement MySQL : Optimiser les performances des tables

2018-12-31T00:00:00+00:00

Avec le temps, de nombreuses tables MySQL deviennent volumineuses, ce qui rallonge les temps de recherche, même avec des index bien choisis. Une solution efficace à ce problème est le partitionnement.

Partitionnement MySQL : Qu’est-ce que c’est ?

Imaginez une bibliothèque avec toutes les informations dans un seul livre. Malgré un bon index, la recherche reste lente.

Si le livre est divisé en plusieurs tomes et que vous ne cherchez que dans un seul, l’index devient beaucoup plus rapide. Le partitionnement MySQL fonctionne de la même manière, mais pour les tables.

Cet article se concentre sur le partitionnement horizontal (par ligne).

Quand et comment appliquer le partitionnement à vos tables ?

Pour vérifier si le partitionnement est activé :

SHOW PLUGINS;

Vous devez voir “partition” avec le statut ACTIVE. Certaines tables ne peuvent pas être partitionnées :

Tables avec un index full text
Tables avec des clés étrangères
Tables qui sont des références de clés étrangères pour d’autres tables

Choisir la clé de partitionnement

La clé de partitionnement doit respecter ces conditions :

Être numérique
Faire partie de la clé primaire

Types de Partitionnement MySQL

Partitionnement par Range

Les lignes sont réparties selon des zones définies. On ne peut pas utiliser directement de dates, mais des fonctions MySQL comme YEAR sont autorisées.

CREATE TABLE example (
  id INT NOT NULL
)
PARTITION BY RANGE (id) (
  PARTITION p0 VALUES LESS THAN (6),
  PARTITION p1 VALUES LESS THAN (11),
  PARTITION p2 VALUES LESS THAN (16),
  PARTITION p3 VALUES LESS THAN MAXVALUE
  );

Partitionnement par List

Les valeurs de la clé de partitionnement doivent correspondre à une des valeurs définies dans la liste. Si la valeur n’est présente dans aucune liste, alors l’insertion est perdue.

Il n’y a pas de valeur de catch !

Cette methode s’adapte bien pour des clefs fixes et bien définies.

CREATE TABLE example (
    id INT NOT NULL,
    store_id INT
)
PARTITION BY LIST(store_id) (
    PARTITION pNorth VALUES IN (3,5,6,9,17),
    PARTITION pEast VALUES IN (1,2,10,11,19,20),
    PARTITION pWest VALUES IN (4,12,13,14,18),
    PARTITION pCentral VALUES IN (7,8,15,16)
);

Partitionnement par Hash

La valeur dans le HASH doit etre entière. On peut utiliser une fonction mysql mais pour une valeur précise la valeur de sortie doit être identique.

L’expression de la partition est calculée par valeurDuHash % nombreDePartitions.

CREATE TABLE example (
    id INT NOT NULL,
    example_date DATE NOT NULL DEFAULT '1970-01-01',
    store_id INT
)
PARTITION BY HASH(YEAR(example_date))
PARTITIONS 4;
);

Partitionnement par Key

La clef n’est pas obligatoirement numérique, key utilise une fonction de hash propre a mysql (basé sur password).

CREATE TABLE example (
    id INT NOT NULL PRIMARY KEY,
    store_id INT
)
PARTITION BY KEY()
PARTITIONS 4;
);

Partitionnement Linear

Le calcul de la partition se fait différemment via la fonction suivante :

    V = POWER(2, CEILING(LOG(2, num)))
    N = F(column_list) & (V - 1).

    While N >= num:
        Set V = CEIL(V / 2)
        Set N = N & (V - 1)

Ou :

num : nombre de partitions
F(column_list) : Valeur de la fonction de hashage
N : partition selectionné

Contrairement a ce que dit le nom la répartition n’est pas linéaire.

Pruning des partitions

Le pruning des partitions permet à MySQL d’ignorer certaines partitions lors de l’exécution d’une requête, réduisant ainsi le volume de données à traiter. Seulement les partitions utiles seront lues. Cela se traduit par un temps d’exécution plus rapide et une utilisation mémoire optimisée.

Actions sur les partitions

Optimisation des partitions

Lors suppression de ligne ou changement de taille des colonnes, il peut y avoir une fragmentation des données on peu alors lancer une optimisation par partition.

ALTER TABLE my_table_partitioned 
OPTIMIZE PARTITION partition_name_to_optimize;

Réparation des partitions

En cas d’erreur sur les données ou les index on peut reparer par partion

ALTER TABLE my_table_partitioned 
CHECK PARTITION p0,p1

Suppression de Partition

Grâce au partitionnement on peut supprimer des partitions directement. Ainsi la suppression d’un enregistrement par rapport a la date peut se faire rapidement même sur des gros volumes de données.

ALTER TABLE my_table_partitioned 
DROP PARTITION partition_name_to_drop;

Ajout de partition

On peut aussi ajouter des partitions

ALTER TABLE my_table_partitioned 
ADD PARTITION partition_name (PARTITION_DESCRIPTION);

Note : Sur du partitionnement par range on ne peut pas ajouter de participation apres notre partition fourre-tout (celle en MAXVALUE ). Il faudra dont la supprimer au préalable, puis ajouter la nouvelle et la recréer. Bien sûr, il faut faire cela avec quelle ne commence a se remplir.

Contraintes mémoires

Dans le cas des tables MyISAM, chaque partition utilise deux file descriptor qui doivent être ouvertes pour accéder aux données, et ceci est bien sûr par partition.

Voici un petit aperçu du partitionnement, de son utilisation pour augmenter les performances sur des tables assez volumineuse.

Migration de Blog vers Jekyll : Guide et Avantages

2017-04-12T00:00:00+00:00

Comme je l’ai évoqué dans l’article bilan du début d’année j’ai migré ce blog de wordpress vers Jekkyl. Je vais dès à présent vous donner plus d’information sur ce choix ainsi que sa mise en oeuvre.

Pourquoi migrer ?

Le blog était sous wordpress, l’un des projets de blogging open source parmi les plus utilisés. Wordpress c’est bien, il y a pas mal de plugins, thèmes et j’en passe. L’éditeur est pas mal, la programmation d’article existe, des mises à jour régulières…

Jusque là on peut se demander pourquoi quitter cette solution.

Mais wordpress c’est aussi, plus ou moins lent, selon les plugins. Une surveillance constante des mises à jour (par rapport aux potentiels problèmes de sécurité). Pour résumer il y avait pas mal d’entretien à faire.

J’ai alors décidé de partir sur un blog statique, via l’utilisation de jekyll. Alors, certes je perds l’interface d’admin et son éditeur, mais étant le seul rédacteur passer sur l’écriture d’article au format markdown n’est pas un soucis. De plus, ça me permet d’avoir un site assez léger et rapide (notamment via le fait que j’utilise cloudflare) et peu couteux (hébergement en github page - je paye donc uniquement le nom de domaine).

Étapes de migration

Ce blog n’ayant que peu de commentaire j’ai pris la décision de ne pas les exporter lors de la migration, de ce fait je ne traiterai pas de cette partie dans cet article. N’hésitez pas à demander en commentaire (je sais que c’est assez ironique ) si vous voulez plus d’information à propos de ce sujet.

Export des articles

Pour exporter mes articles j’ai utilisé le plugin Jekyll Exporter. C’est assez simple, dans le menu “Outils” il y a un lien Export to Jekyll. Ça vous fait télécharger une archive zip avec vos articles et médias

Nettoyage de l’export

Bien que l’export via le plugin fasses quasiment 90 % du travail il faut effectuer une relecture pour corriger divers problèmes.

Pour ma part j’ai eu des problèmes sur les articles possédant des shortcodes, en effet lors de l’export il y avait le shortcode au format texte uniquement. De même certains articles ayant des scripts inline (dans mon cas gist) ont eu un export sans le script.

Enfin je suis aussi repassé sur les urls, afin de leur donner une structure correcte vis a vis de jekyll - à savoir via le fichier de configuration etc.

C’est l’étape la plus longue de la migration, surtout si vous avez beaucoup d’articles à vérifier.

Sécuriser les données en JS : Chiffrement et confidentialité

2017-01-22T00:00:00+00:00

Lors de cet article je vais faire un compte rendu (que je compléterai en partie) d’un article du MISC 88 concernant la sécurité et confidentialité des données en JavaScript.

Vous pouvez bien entendu trouver l’article complet sur le site de l’éditeur.

Les enjeux de la sécurité des données en JavaScript

Avec le développement des nouvelles API JavaScript les sites web possèdent de plus en plus de données personnelles et critiques sur les utilisateurs.

Certes parmi ces API nombreuses requièrent l’utilisation d’un certificat SSL pour pouvoir être utilisé - et encore cela dépend des navigateurs - il convient de constater que les informations ne sont pas toujours gérées de manière sécurisées côté serveur.

En effet, même si cela semble impensable de nombreux sites web stockes les mots de passe en clair. Et même dans les rares cas où il y a du chiffrement côté serveur la confidentialité n’est pas pour autant totalement assuré. Maintenant imaginons que le serveur ne fait que stocker une partie des informations sans pouvoir les manipuler ou interpréter directement, car le chiffrement serait effectué côté client. On pourrait avoir dans ce cas-ci un niveau de confidentialité plus élevé.

Optimisation des performances avec ASM.js

ASM.js est un sous ensemble de JavaScript ayant pour but de manipuler des structures de données avec des performances correctes s’approchant de celles obtenues par du code natif dans l’idéal. Toutefois, il faut prendre en compte que cet ensemble dépends du navigateur et du moteur JavaScript utilisé.

Concrètement ASM.js nous permet d’allouer un buffer pour ensuite le manipuler via des vues typées ce qui sera essentiel pour l’utilisation d’api de chiffrement JavaScript

WebCrypto API : Chiffrement, authentification et gestion des clés

Il est possible depuis peu d’utiliser l’api Web Cryptography API dans les cas suivants :

Authentification multiples facteurs
Échange de documents
Stockage de données dans le cloud
Signature de document électronique
Protection de l’intégrité des données
Messagerie sécurisée
JavaScript Object Signing and Encryption (JOSE)

Cette API est basé sur le concept de future c’est-à-dire une interface qui définie un contrat asynchrone (ECMAScript 6). Les communications sont faites via deux paramètres de callback - un en cas du succès et l’autre pour l’échec.

On peut accéder à cette interface via le bout de code suivant

    window.crypto.subtle

Cette interface permet d’accéder à quatre familles d’opérations :

hashage
gestion des clés cryptographiques
chiffrement
authentification

De plus, l’api window.crypto permet de générer un vecteur de valeur aléatoire. Par exemple si nous voulons 10 valeurs aléatoire nous pouvons utiliser le code suivant

    // get a vector of 10 unsigned int value (32bits)

    var randomValues = new Uint32Array(10);
    // randomize values

    window.crypto.getRandomValues(randomValues)

Nous allons à présent voir les différentes familles d’opération plus en détail.

Hashage avec WebCrypto : SHA-256 et autres algorithmes

Pour utiliser les fonctions de hash nous devons utiliser la méthode digest qui permet le hashage via les méthodes suivantes :

~~SHA-1~~ à ne pas utiliser !
SHA-256
SHA-384
SHA-512

Je vais donner un exemple que j’avais réalisé en SHA-256

function sha256(str) {
  var buffer = new TextEncoder("utf-8").encode(str);
  return crypto.subtle.digest("SHA-256", buffer).then(function (hash) {
    return hex(hash);
  });
}
function hex(buffer) {
  var hexCodes = [];
  var view = new DataView(buffer);
  for (var i = 0; i < view.byteLength; i += 4) {
    var value = view.getUint32(i);
    var stringValue = value.toString(16);
    var padding = '00000000';
    var paddedValue = (padding + stringValue).slice(-padding.length);
    hexCodes.push(paddedValue);
  }
  return hexCodes.join("");
}
sha256("test").then(function(digest) {
  console.log(digest);
});

On remarque que le simple fait de faire un sha-256 neccessite plusieurs fonctions et se relève complexe avec notamment un traitement des données.

Comprendre la gestion des clés dans les applications sécurisées

Nous entrons maintenant dans la partie qui concerne les clés cryptographique. Ces clés seront utilisées dans pour les opérations suivantes il convient de voir leur gestion plus en détail.

Attention il y a une politique de même origine sur les clés, c’est-à-dire que deux sites ne peuvent se partager les clés directement

Nous avons donc les méthodes suivantes :

generateKey : génère une paire de clés pour l’algorithme ciblé
deriveKey : applique un algorithme de dérivation de clés (ECDH, DH, PBKDF2 et HKDF-CTR)
importKey importe une clé dans un format spécifique
- Algo Symétrique : En plus du format JWK on peut importer en raw via un arrayBuffer
- Algo Asymétrique : On a JWK et PKCS8
exportKey : exporte les clés dans l’un des formats ci-dessus

Nous pouvons faire transiter les clés dans du JSON au format JWK (voir JOSE).

Chiffrement des données avec WebCrypto API

L’utilisation de l’api de web cryptographie nous permet de chiffrer des données, bien entendu il faut au préalable importer les clés avant.

Nous pouvons effectuer du chiffrement symétrique et asymétrique.

Le chiffrement symétrique est de l’AES-256 avec les modes CTR, CBC, GCM, CFB tandis qu’en asymétrique nous avons à disposition du RSA (attention les données en entrée doivent être dans un ArrayBuffer).

Méthodes d’authentification en JavaScript : Signatures et vérification

Nous avons bien entendu la possibilité avec cette API d’effectuer de l’authentification de données. Pour cela nous pouvons signer et vérifier les données via les méthodes respectivement sign et verify .

Là encore il convient de différencier le mode symétrique (HMAC et AES-CMAC) du mode asymétrique. En asymétrique nous avons à disposition trois algorithmes (2 basé sur RSA et le dernier sur des courbes elliptiques) :

RSA SSA-PK CS1-v1.5
RSA - PSS
ECDSA

Résumé et perspectives sur la sécurité des données en JavaScript

Nous pouvons voir que le web évolue de plus en plus vers une augmentation de la sécurité et confidentialité des clients toutefois ces API bien qu’utiles semblent à mon avis hélas trop complexe pour y voir une intégration massive dans les diverses applications que nous pouvons utiliser.

Rétrospective 2016 : Projets, Avancées et Objectifs

2017-01-15T00:00:00+00:00

Je profite que l’année 2016 soit terminé afin de pouvoir commencer une retrospective sur celle ci et fixer mes objectifs pour 2017.

Retrospective 2016

En 2016 j’ai continué à travailler bénévolement sur le projets Blizzheart, en particulier lors de la migration de serveur en aout où j’ai pu utiliser de manière plus approfondi l’outil ansible.

En parallèle à ce projet j’ai commencé une réflexion sur un projet de site dans le dommaine du cosplay, le but étant de proposer une alternative solide à facebook pour souder la communauté. Recherche de groupe, partages, aide par rapport aux présences lors des divers salons…

En tant que développeur il convient aussi de regarder mon année par rapport aux divers commits effectués :

On remarque que j’ai ete plus actif en début et fin d’année, ce qui corresponds essentiellement à mes phases de travails sur les projets ci-dessus.

Autre point qui est important de souligné est la migration de ce blog de wordpress vers Jekyll, ce qui me permet d’avoir une gestion de celui ci plus simple et moins couteuse le tout étant hébergé en temps que page github. La migration fût relativement simple, en effet à l’aide du plugin Jekyll Exporter j’ai pu obtenir l’ensemble de mes articles et assets. Il m’a resté à checker que la mise en page était bonne, modifier les url des assets et point plus génant remettre en place les partie utilisant gist ou slideshare (en effet les script semble avoir disparu et logiquement les customs posts n’ont pas pu etre utilisés).

Programme pour 2017

Je profite de cet article afin de pouvoir écrire mes principaux objectifs pour cette année - ce qui me servira de base pour un futur bilan en 2018.

Tout d’abord, j’ai prévu d’être plus actif sur ce blog, écrire plus d’article (au moins un par mois) principalement orienté vers de la technique.

De même je compte continuer à contribuer à participer au sein de l’équipe Blizzheart (fan de jeux blizzard je vous conseille de jeter un oeil), il y’a pas mal de nouveauté à venir (nouvelle version du site, nouvelles fonctionnalités etc.).

Bien entendue j’ai aussi prévu d’avancer sur mon projet de site relié au cosplay avec l’intention de pouvoir sortir une beta dans la première partie de l’année.

Postman : L'outil essentiel pour tester et documenter vos APIs

2016-11-01T15:54:03+00:00

Postman est une plateforme puissante et intuitive dédiée au développement, au test et à la documentation des APIs. Utilisé par des millions de développeurs dans le monde, cet outil simplifie la gestion des APIs tout au long de leur cycle de vie.

Qu’est-ce que Postman ?

Postman permet aux développeurs de concevoir, tester et documenter des APIs grâce à une interface graphique conviviale. Il prend en charge différents types d’APIs comme REST, GraphQL ou SOAP, et offre des fonctionnalités qui facilitent la collaboration entre les équipes.

Avantages de Postman

Interface intuitive : Créez facilement des requêtes HTTP sans expertise technique avancée.
Tests automatisés : Scripts en JavaScript pour garantir la fiabilité des APIs.
Documentation intégrée : Génération automatique de documentations claires et détaillées.
Mock servers : Simulez des réponses API pour tester sans backend actif.
Collaboration d’équipe : Partagez des collections et travaillez efficacement en équipe.
Intégration CI/CD : Automatisez les tests dans vos pipelines de déploiement.

Inconvénients de Postman

Consommation de ressources : Peut ralentir les systèmes avec des collections volumineuses.
Fonctionnalités payantes : Certaines options avancées nécessitent un abonnement.
Support limité pour les APIs non-REST : Moins performant avec SOAP ou GraphQL.
Pas de tests de performance natifs : Nécessite des outils tiers pour les tests de charge.

Pourquoi choisir Postman ?

Postman est parfait pour centraliser la gestion des APIs, que ce soit pour leur conception, leur test ou leur documentation. Si vos besoins incluent une collaboration efficace et une interface accessible, cet outil est un choix incontournable. Toutefois, pour des tests intensifs de performance ou un support avancé d’APIs non-REST, envisagez des outils complémentaires.

En conclusion, Postman se distingue par sa flexibilité, son écosystème riche et sa capacité à répondre aux besoins variés des développeurs modernes.

Vous pouvez également voir mes slides de présentation de postman lors du dev/var.

Git Workflow : bonnes pratiques pour vos projets

2016-02-28T16:33:58+00:00

De nos jours se lancer dans un projet sans outil de versionning est proche d’une folie. Toutefois ces outils ne sont pas toujours utilisé de manière optimale. Je vais donc présenter dans cet article une sorte de workflow que nous pouvons mettre en place avec un projet versionné par exemple sur github.

Présentation générale :

Pour ce ne connaissant pas git, il s’agit d’une solution permettant de versionner du code. Ainsi l’on a accès a toute les modifications ayant été faite sur le code. On peut donc aisément revenir en arrière etc.

Les forks

Chaque projet sur github est hébergé en dans un dépôt, lorsque vous voulez avoir votre version vous pouvez soit :

Copier le contenu (zip) dans un nouveau dépôt – on perds alors la dépendance avec le projet initial
Faire une copie qui est toujours relié au dépôt d’origine : on parle de fork.

C’est grâce a ce lien que l’on peut proposer ses modifications. Ceci est possible en utilisant le mécanisme de pull request que nous allons expliquer un peu plus bas.

Il est important de noter que si vous faites un fork d’un dépôt privé et que l’on vous retire les droits de lecture sur le dépôt d’origine, votre fork disparaîtra obligatoirement.

Nos aurons donc trois principaux dépôt qu’il faudra prendre en compte :

le dépôt local (physique sur la machine)
le dépôt distant (on le nommera origin)
le dépôt distant d’origine (on le nommera upstream)

L’un des principaux avantage à l’utilisation des fork est que chaque développeur possède a la fois un dépôt local et distant qui lui sont dédié – ses modifications n’impacte que lui. Le troisième sert juste de base commune.

Les branches

Une vision simpliste est de s’imaginer un projet comme ayant une unique avancé. En réalité des fonctionnalités sont ajouté sur des version parallèle (sorte de copie n’affectant pas la version principale) avant d’être fusionné avec la base principale. On parle de branche – chaque branche est une évolution différente du projet qui peuvent s’éloigner mais aussi se rejoindre (on parle de merge).

Le nombre de branche varie totalement en fonction des projets, on retrouve généralement :

La branche principale (codé utilisé en production) appelle master
Une branche de développement

Il s’ajoute a ces branches quelquefois des branches dédié a l’étape de pre-prod et de test. Sur certain projet plus actif on a aussi une branche par fonctionnalité en cours de développement plutôt qu’une seule. Enfin des vieilles versions possède leurs propre branche – par exemple pour avoir toujours des mise a jour de sécurité.

Afin de fusionner deux branches on utilise souvent le processus de merge. On fait un nouveau commit qui aura pour parent le dernier commit de chaque branche. A l’inverse on peu aussi utiliser le système de rebase qui lui prend les commit d’une branche et les “joue” a la suite de l’autre branche.

Personnellement je préfère utilisé les rebase pour deux raisons :

on garde un historique linéaire
la gestion de conflit étant commit par commit est relativement plus aisé

Pull Request :

Lorsque vous voulez que les modifications faites sur votre copie soient disponible pour tout le monde vous allez surement utiliser le principe de pull request. Vous choisissez une branche de votre distant, une du distant d’origine et proposez un merge entre les deux. Les personnes ayant les droits d’écriture sur le dépôt d’origine peuvent accepter votre pull request ou vous demandez de faire quelques modifications avant. Dans certains cas votre demande sera refusé et votre pull request sera fermé.

Quelques conseil pour avoir plus de chance de voir votre demande accepté :

Respecter les normes du projet ( souvent dans le wiki ou un fichier CONTRIBUTING)
Vérifier que les tests passent bien
Pull le dépôt upstream sur votre branche avant – ca évitera d’avoir des conflits et voir votre pull request impossible a accepter

Votre code sera potentiellement critiqué, analysé etc, n’hésitez pas a vous justifier quand besoin et voyez y une chance de vous améliorer. En effet il y’a beaucoup a apprendre des diverses codes review que l’on peut avoir.

Les tags

La notion de branche ne suffit pas à définir un point particulier de l’évolution du code, on pourrait certes utiliser le numéro de commit mais il y’a un système bien plus pratique : les tags. Il s’agit de marqueur sur un état du code – a un commit bien précis. On peut se servir ce système comme systeme permettant de numéroter les versions. Cela à plusieurs avantages :

On peut voir facilement la date de création de chaque version
Idem pour les ajouts d’une version si la description est complète
On peut aussi gérer facilement le choix de version avec des outils d’import de librairies (composer …)
Si on utilise des numéro de version sémantique voir l’implication d’une mise a jour de version

Pour ceux n’étant pas au courant de ce qu’est un numéro de version sémantique il s’agit d’un numéro sous la forme de trois partie Major.Minor.Patch

Le patch est un fix sans problème d’incompatibilité

Le Minor est un ajout de fonctionnalité toujours sans incompatibilité

Le Major implique de grande modification avec de potentiel problème d’incompatibilité.

Vous pouvez avoir plus d’information sur ce site Gestion sémantique de version

WebHook et deploy key

Il s’agit la plus de fonctionnalités supplémentaires que l’on retrouve sur de nombreux service (github, bitbucket, gitlab etc).

Le webhook sont des appels fait lors d’interaction spécifique, par exemple a chaque commit, pull request etc un appel est fait a un service externe qui pourra par exemple exécuter les tests. Ceci permet de faire des actions de manière automatique. La deploy key est comme son nom l’indique une clef qui sera utilisé pour le déploiement uniquement. Je m’explique cette clef ssh permet d’avoir un accès en lecture au dépôt ainsi le serveur possédant la clef privé associé pourra récupérer le code avec celle ci – les serveurs n’ont donc pas besoin de compte et peuvent quand même être identifié a l’aide de leurs clef. Ce système est utile quand le déploiement est automatisé et qu’aucun compte utilisateur ne pourra être utilisé.

Conclusion

Pour conclure nous allons voir un exemple ou l’ensemble des méthodes décrite ci-dessus sont assemblé pour former une procédure complete dans un projet.

Nous avons donc le projet dans son dépôt officiel, seul quelques personnes peuvent écrire sur ce dépôt – typiquement les core développeur (souvent le lead dev en entreprise). Le reste des développeur ont un accès en lecture. Il font donc un fork qui leurs permet d’avoir leurs copies. Ils peuvent donc travailler sur les mêmes branches – disons dev sans avoir d’interaction. Lorsque un développeur a fini sa tâche il récupère le code de la branche principale (dépôt officiel), ainsi son code aura déjà eu la résolution de conflit avant le pull request. Lors du pull request une analyse du code statique est lancé, de même pour les tests. Si tout ce passe bien les core développeur peuvent vérifier le code puis après modification potentielle accepter la pull request. Alors on pourra déployer de manière automatique le code – en effet les serveurs ayant le droit de lecture sur le dépôt peut récupérer le code source.

Bien que cet article peut sembler un peu long, je ne traite pas de la totalité des éléments que l’on pourrait incorporer dans un workflow centré sur git, n’hésitez pas a compléter ou poser vos questions en commentaire.

Fusionner et Réorganiser les Commits Git : Guide Pratique

2016-01-03T19:32:37+00:00

Aujourd’hui nous allons voir comment fusionner plusieurs commit ensemble pour n’en former qu’un seul.

Bien que cette manipulation soit relativement simple elle n’est pas souvent utilisé ce qui mène souvent a voir dans les branches master des commit sans ‘utilité’ fonctionnelle (commit de fix d’une erreur de syntaxe, plusieurs commit pour la même feature etc).

Pourquoi fusionner des commits dans git ?

Voyons tout d’abords les raisons qui peuvent nous amener a fusionner des commit :

Vous avez fait un commit, mais il y’a une modification manquante. (ex. fichier manquant, erreur de syntaxe)
Vous êtes sur un projet open source, vous faites des commits a chaque petites modifications. Il peut être utile de fusionner les commits en un seul pour éviter l’explosion du nombre de commit.

Maintenant que nous avons vu les principales raisons pouvant nous amener a fusionner des commit ensemble nous allons voir la méthode pour les fusionner ensemble.

Comment fusionner des commits dans git ?

J’ai initialisé un dépôt git avec deux commit : l’un pour le création d’un fichier squash.txt et le second après avoir renommé le fichier en git-squash.txt comme nous pouvons le voir dans l’image ci dessous. J’ai fais un troisieme commit afin d’avoir un rebase plus visible pour la seconde partie (il n’est absolument pas nécessaire)

Etant donné que je travaille en local je souhaiterai fusionner ces deux commit. J’utilise donc la commande git rebase.

Pour cela je fais un git rebase -i HEAD~2 (git rebase, en mode interactif a partir des deux commit précédent le HEAD (inclus)).

On voit donc nos commit (id et message) du plus vieux au plus récent dans un éditeur vim. Pour effectuer le rebase il faut modifier le fichier. Ici on veux fusionner le update (7cd2fe3) avec le précédent on remplace donc son pick par squash (l’option qui nous est utile).

Puis l’on enregistre les modification (option wq de vim). On obtient a nouveau l’éditeur vim avec les messages de nos commit a fusionner. On enregistre le nouveau commit avec son message en enregistrant comme lors de l’étape principale. Pour modifier le message il suffit de l’éditer directement (les lignes avec les # sont des commentaires).

A la fin nous obtenons donc les commit suivant :

Voila en espérant que cette astuce vous soit utile.

Introduction à Polymer : simplifiez vos web components

2015-11-22T19:24:02+00:00

Lors d’un précédent article je vous ai fait une présentation des web component lors de laquelle on a pu voir l’utilité de ceux ci mais leurs principal inconvénient : la compatibilité. Nous allons a présent voir que cette difficulté peut être facilement effacé et que l’écriture de web component avec polymer se trouve assez simplifié.

Vaincre les incompatibilités :

Comme vu précédemment chacun des piliers nécessaire au fonctionnement des web composant ne sont pas implémenté au même niveau au sein de chaque navigateur. Pour résoudre ce problème de différence et avoir ainsi des composant disponible sur chaque navigateur une surcouche javascript sera a mettre en amont : polyfills.

Pour obtenir polyfills vous pouvez simplement utiliser bower :

Enfin vous avez juste a inclure le fichier javascript dans vos pages utilisant les web composants :

Utiliser polymer pour vos composants :

Polymer est un projet de l’entreprise Google datant de 2013. Il a pour but de permettre l’utilisation de web composant de maniéré simple grâce à une librairie javascript. Il est impératif de noter qu’il existe de nombreuse différence entre la version 0.7 et 1.0. Nous parlerons uniquement de la version 1.0 car il s’agit de la seule que j’ai eu a manipuler et surtout parce quelle est considéré comme production ready par google.

Pour les plus curieux voici le dépôt github du projet : polymer/polymer

Installer polymer :

Rien de plus simple avec bower :

L’un des principaux avantages de polymer hormis le fait de pouvoir facilement créer ces propres composant est bien entendu la grande variété de composant que l’on peut trouver sur le net et donc directement utilisable.

Composants polymer disponible et utilisable :

Comme je l’ai dit dans l’article précédent l’une des forces de web composant est le fait de pouvoir ré-utiliser nos composant même dans d’autres projets du fait de leurs isolations. Les composant écrit avec polymer n’échappe pas a la règle. On peut donc trouver :

des composants Google ( youtube, google map etc) pour pouvoir utiliser les services facilement
des composants dédié au material design (paper componant)
des composants utilitaires (iron composant)
des composants pour firebase permettant de faire du web temps réel
et bien d’autres ….

Vous pouvez trouver vos composant sur les sites suivants :

Polymer Element (composant plutôt officiel)
Custom Element (banque de composant comme packagist)

Créons un composant :

Nous allons donc créer un composant avec polymer. Le composant que l’on va faire affichera les informations relative a un stream sur twitch. Pour cela nous utiliserons l’api publique du service qui renvoie les informations nécessaire lorsque le stream est actif. Commençons par établir la structure de notre composant et de la page l’utilisant :

On a donc un composant vide et la page pouvant inclure notre composant. La première étape est de récupérer les données depuis l’api. Pour cela nous avons a exécuter une requête ajax.

Dans le fichier index on a rajouté un attribut stream-name qui corresponds a la propriété streamName dans notre composant. Dans le composant on forge l’url associé au stream a l’instanciation via la méthode ready. Notre appel ajax est fait par l’élément iron-ajax qui lors d’une réponse appelle la méthode hresponse. Il nous reste plus qu’a mettre en forme notre élément a partie des données reçues. Nous avons donc le code suivant :

A noter :

L’on utilisera des pour afficher les variables, des la modification de la propriété la variable affiché change. Il faut que ces éléments soit isolé dans une balise ou attribut – les concaténation de fonctionne pas.

L’aspect visuel est sinon géré en html classique ce qui permet d’avoir des composant de tout type.

J’espère que cet article vous as donné envie d’utiliser des web composants, lors du prochain nous verrons un exemple un peu plus poussé avec les notions de boucles etc. N’hésitez pas a laisser un commentaire pour avoir plus d’information sur cette technologie.

Pourquoi utiliser des tests automatisés en développement

2015-11-15T19:52:50+00:00

Bien que souvent considéré comme fastidieux et peu utiles l’écriture de test automatisable pourra vous être d’un grand secourt.

Ils sont en outre les garants de la qualité du code de l’application.

Nous allons donc voir plus en détails quelles sont les diverses utilités des tests et pourquoi vous devez les utiliser.

C’est hélas une partie négligé car pour beaucoup :

ça fait perdre du temps
je code super bien donc pas besoin de tests
…

Bon que l’on soit clair je trouve toutes les raisons ci dessus nulles et a oublier au plus vite. Je vais donc vous dire a présent pourquoi je pense ainsi.

Alors le célèbre ça fait perdre du temps, certes écrire des tests prends du temps mais quand il vas y avoir un bug – et il y’en a toujours – vous allez être content de le trouver rapidement avec ce test et la vous allez gagner du temps. Idem quand vous allez modifier le code plus tard ces tests automatisés vous aiderons bien a vérifier qu’il n’y a pas eu d’introduction de bug.

Je tiens aussi a signaler que le coût d’un bug augmente au fur et a mesure du temps. En effet corriger un bug en phase de développement n’a pas le même cout qu’une fois en production.

Pour la partie du je code super bien … pas la peine de s’étaler sur le fait que personne ne peux être dur de ne jamais introduire de bug, de ne jamais zapper un cas d’utilisation – surtout qu’on a la fâcheuse tendance a toujours vouloir avoir le cas idéal et ne pas prendre en compte des cas totalement illogique.

Comme j’ai pu le dire les tests nous aide à vérifier que notre application fonctionne comme voulu, que l’on ne re-introduit pas de bug mais il faut quand même rester vigilent car il est possible que nos tests de soit pas complet (cas oublié, bug non testés etc) et doivent donc comme votre code vivre et rester à jour sous risque de devenir plus néfaste que leurs absences.

Program testing can be used to show the presence of bugs, but never to show their absence!

Edsger W. Dijkstra

Personnellement les tests sont aussi la comme documentation, en effet en regardant les tests on comprend souvent comment fonctionne l’application ce qui est plus rapide que devoir lire des pages et des pages de doc. Je vous invite à lire les tests autant que possible (en plus leurs absence n’est pas très bon signe sur la qualité du code selon moi).

En résumé les tests :

permette de vérifier que le fonctionnement est celui attendu
Eviter l’introduction de bug lors de modification ultérieure – et donc pouvoir toucher au code de manière sereine
Faire une sorte de documentation
Doivent vivre avec le code pour ne pas être inutiles et dangereux

Je vais bien entendu écrire des articles sur ce sujet (traitant le sujet d’un point de vu pratique) en parallèle de celui sur les web component.

Lectures : Introduction au Big Data et Machine Learning

2015-11-11T00:08:29+00:00

J’inaugure avec ce livre une catégorie sur les livres que j’ai lu ainsi que mon avis sur ceux ci. Il s’agit du dernier livre que j’ai fini.

Lorsque j’ai décidé d’acheter ce livre je n’avais pas de connaissance particulière dans le domaine du Big Data ni du Machine Learning mais j’ai été attiré par celui ci pour connaitre un peu plus ces domaines que l’on peut régulièrement retrouver.

Je trouve ce livre assez bien découpé et donc facilement accessible.

Les principales parties sont :

Big Data ( origine, intérêt, noSql, algorithme et framework)
Machine Learning ( présentation du métier de data scientist, traitement des données, algorithme de machine learning, visualisation)
Outils du Big Data (Hadoop, Pig, Hive, architecture lambda, apache storm)

Bien que majoritairement théorique ce livre est a mon gout intéressant pour tout ceux voulant avoir un aperçut de ces domaines – la dernière partie permet de ce pencher plus sur la pratique. Je le conseille donc a tout ceux voulant un livre d’introduction au Big Data et au Machine Learning.

Auteurs : Pirmin Lemberger, Marc Batty, Médéric Morel, Jean-Luc Raffaëlli

Vous pouvez trouver ce livre sur Amazon

Web Components : présentation et concepts essentiels

2015-11-05T08:00:40+00:00

Pour mon dernier jours au sein de mon ancienne société j’ai eu a présenter ma dernière Reutek. J’ai choisi comme sujet les web component et plus particulièrement l’implémentation a l’aide de Polymer. Etant donnée l’attrait de ceux-ci de la part de ceux présent a cette réunion – moi compris pourtant je ne suis pas très attiré par le développement front – je me suis dit qu’il faudrait que j’y consacre une série d’article.

Dans ces articles je vais expliquer qu’est ce qu’un composant (et plus particulièrement un web composant) pour que vous puissiez simplifier vos pages html.

Qu’est ce qu’un composant ?

Pour résumer un composant est une portion identifiable d’un programme plus large qui a pour but d’apporter un ensemble particulier de fonctionnalités. Bon je l’accorde dit comme ça ce n’est pas très clair et pourtant en tant que développeur ce concept vous est familier j’en suis sur.

Prenons les lego ci-contre, certains sont différents en eux pourtant on peut les assembler ensemble pour effectuer une construction de notre choix. Chaque type de blocs a une fonction définie dans notre constructions et permettent ensemble d’avoir notre construction finale.

Maintenant que vous avez compris la notion de composant je vais passer à la partie qui nous intéresse vraiment les web composant que j’appellerai souvent web component.

Les composants adaptés au monde du web.

Vous vous doutez bien que lorsque l’on peut isoler des blocs, les factoriser pour pouvoir s’en servir dans le futur sur divers projets on ne ce gène pas. Autant ne pas re-inventer la roue a chaque fois. En cela les web component peuvent être utiles.

Toutefois je dois vous prévenir de ne pas les utiliser encore en production.

Les raisons sont simples :

Même si il s’agit d’un projet porté par un working group du W3C, il n’y a pas encore de norme arrêté – et ça risque de prendre un peu de temps avant de l’être
Seuls certains navigateurs sont compatibles.

Les templates

Il s’agit des modèles de base, pour être plus exact il s’agit de la structure à dupliqué. Ce bloc html ne sera pas évalué.

Pour “l’instancier” nous avons besoin d’un peu de javascript. L’idée est de récuperer le contenu de celui ci pour l’injecter dans le DOM en tant qu’élément visible comme ceci par exemple :

Le shadow DOM

Comme en programmation classique lorsque l’on encapsule une portion de code l’on souhaite que celle ci ne soit pas directement injecté dans les sources les polluants. Ceci reste vrai avec les web composant a l’aide du shadow DOM. Pour explique simplement il s’agit d’un nouvel arbre DOM totalement indépendant situé dans un élément. De base il ne sont pas visible (on peut dans les réglages de l’inspecteur de code de chrome les voir en cochant show user agent shadow DOM).

L’une des balises utilisant le shadow DOM la plus connue est la balise HTML5 video – derrière cette simple balise se trouve un ensemble d’élément html définissant les divers boutons etc.)

On entendra parler de Shady DOM par moment la différence est qu’au lieu d’être une fonctionnalité native comme le shadow DOM il s’agit d’élément dans le DOM classique avec une classe style-scope permettant d’émuler le shadow DOM.

Les custom element :

Il s’agit de bloc englobant les Template ayant pour but de gérer le cycle de vie du composant. Ainsi l’on pourra avoir nos balises personnelle avec par exemple notions d”héritage.

Les HTML Imports

On arrive sur une fonctionnalité bien pratique pour pouvoir réutiliser nos composant dans plusieurs projet. La notion d’import en effet il sera donc possible d’écrire notre composant dans un fichier html séparé et de juste l’importer avant l’utilisation. Ainsi on peut importer dans notre page des fichier externe – toutefois les import n’importerons pas le code HTML a proprement parlé juste les éléments et template.

Pour cela rien de plus simple

Les technologies de web composant on l’air vraiment intéressante mais entre la complexité de l’ensemble et les problèmes de compatibilité on peut vite se démoraliser et ne pas les utiliser. Mais n’ayez craintes il existe des librairies permettant d’utiliser les web composant de manière plus uniforme et simple. Notamment POLYMER qui fera l’objet de futur articles.

Installer un serveur TeamSpeak facilement : Guide pratique

2015-06-29T11:49:00+00:00

La communication est essentielle dans de nombreux jeux en ligne. Cependant, des solutions comme Skype montrent vite leurs limites lorsqu’il s’agit de gérer un grand nombre de participants. C’est pourquoi les chefs de guilde et les joueurs se tournent vers des outils comme TeamSpeak ou Mumble. Mais louer un serveur TeamSpeak peut vite devenir coûteux (plus de 5€ par mois pour un petit 32 slots). Saviez-vous qu’il est possible de réduire considérablement ce coût en configurant votre propre serveur grâce à un VPS ? Dans ce guide, nous vous montrons comment faire.

Étape 1 : Location et configuration du VPS

Un VPS est un serveur virtualisé sur lequel vous avez la main, ainsi vous pouvez installer votre teamspeak, mais aussi un bot pour celui ci et même le site de votre guilde. Et ce pour bien moins cher que la location d’un serveur teamspeak.

Comment choisir votre VPS ?

Loin de moi l’idée de faire de la pub mais avec 2,39€/mois vous pouvez avoir un vps chez ovh ( VPS classic 1).

Sur ce serveur libre a vous d’installer tout ce qui est utile – personnellement j’héberge le serveur teamspeak de ma guilde ainsi qu’un petit site web sans problème et j’ai encore de la marge.

Étape 2 : Installation de TeamSpeak

Maintenant que vous avez votre serveur vps, voici un dépot github qui va vous permettre d’installer votre serveur tres facilement TeamSpeak-Installer.

Suivez les consignes présent sur le dépôt (champs intall) et l’installation sera faite en même pas 5 minutes. Par contre pensez a noter les informations d’administration – le login pour être server admin query ainsi que le token pour vous donner les droit de serveur admin sur le teamspeak.

Étape 3 : Sécurisation de votre serveur

Si vous utilisez iptable pour filtrer les connexions a votre serveur (très fortement recommandé – obligatoire selon moi) voici les règles iptables a jouer pour autoriser le fonctionnement de votre serveur ( j’ai utilisé les ports par défaut uniquement)

Voila votre serveur teamspeak est enfin totalement opérationnel et vous pouvez a coter utiliser le serveur pour d’autre services.

Étape 4 : Étendre la capacité de votre serveur

Si la limite des 32 slots est gênante vous pouvez demander une NPL qui est gratuite pour étendre a 512 slots votre serveur toujours gratuitement – hormis les frais de vps.

En cas de problème

En cas de problème sur l’installation du serveur teamspeak sur votre vps ou même pour l’utilisation de votre vps n’hésitez pas a me contacter sur twitter.

Conclusion

En utilisant un VPS pour héberger votre serveur TeamSpeak, vous économisez sur les coûts tout en gardant le contrôle total sur vos services. Ce guide vous permet de créer un serveur performant, sécurisé et adapté à vos besoins. Alors, prêt à commencer ?

Game-Scan : présentation d’un outil pour les api de jeux

2015-06-27T00:01:36+00:00

De nombreux jeux proposent des API pour accéder aux informations sur le jeu lui même mais aussi sur les joueurs. C’est API ne sont pas souvent utilisé car peu connues ou alors parce que de nombreux projet n’ont pas l’envie et le temps de développer tout les éléments afin de pouvoir les utiliser. C’est la qu’intervient le projet game-scan.

Game-Scan est un ensemble de module PHP qui permet d’appeler de manière simple les API des différents jeux. En effet chaque jeux possédera son propre module installable via composer – ainsi nous pouvons donc avoir un module principal gérant toutes les actions communes aux divers modules. Puis pour accéder aux différentes ressources de l’API il suffira après avoir renseigné les clefs api d’instancier la classe associée puis naviguer dans l’objet afin de récupérer les informations voulues.

Au fur et a mesure des modules – correspondant a un nouveau jeu avec ses api d’ouverte- seront implémenté et ceux présent se verront compléter de sorte a couvrir la totalité de l’API. Bien entendu les pré-requis pour ces modules sont minimaux, on évite au maximum les dépendances afin que ces modules puissent être utilisé dans des applications diverses et variées.

L’ensemble du code source de ce projet sera bien entendu testé avec PHPUnit (on utilisera Travis pour lancer les tests) et la qualité du code sera effectué avec Scrutinizer, Insight…

Apres une première analyse nous avons pour but d’implémenter les modules correspondants aux jeux suivant :

WoW
Diablo 3
Starcraft 2
LoL

Vous pouvez retrouver l’ensemble des modules ainsi que les codes sources sur github. De même si certaines personnes souhaite participer au projet cela est totalement possible via le process de pull request etc.

Utiliser php-cs-fixer avec PHPStorm pour un code propre

2015-05-21T18:00:24+00:00

Les normes sont utiles afin que tous le monde puisse facilement lire du code source avec une certaines uniformité. Ainsi l’on repère facilement les différents blocs etc. Bien qu’elles devraient être obligatoire de nombreux développeur ne les utilises pas. Souvent parce que les contraintes de saut de lignes, d’indentations etc. sont trop nombreuses. Heureusement il existe des outils pour le faire de manière automatique. En PHP la norme est le PSR, nous allons donc voir comment utiliser php-cs-fixer pour pouvoir rendre votre code conforme.

Etape 1 : Pre-requis

Pour pouvoir utiliser cet outil vous devez avoir php d’installé sur votre PC, ainsi que php-cs-fixer.

Vous pouvez récupérer php-cs-fixer Ici. Personnellement j’ai récupéré l’archive phar.

Etape 2 : Configuration

Nous allons donc définir un external tools dans PHPStorm, pour cela on se rend dans les options ( ctrl + alt + S) puis dans l’onglet external tools. On en ajoute un nouveau et on rempli comme ci-dessous

Dans program on met le lien vers l’exécutable php, j’ai utilisé la macro php de PHPStorm pour être plus générique, cela utilisé l’exécutable défini dans PHPStorm.

Dans parameters on met le chemin vers le fichier php-cs-fixer (le .phar chez moi) le niveau a utiliser (psr2) l’option verbose le mot clef fix et surtout le chemin vers le fichier courant avec les macros afin de pouvoir s’en servir sur n’importe quel projet php ouvert avec l’ide.

Voici mes paramètres, a adapter selon vos besoin bien entendu (surtout le chemin vers le fichier php-cs-fixer)

Program

$PhpExecutable$

Parameters

D:\Projets\php-cs-fixer.phar  --level=psr2  --verbose fix  $FileDir$/$FileName$

Working directory

$ProjectFileDir$

Etape 3 : Utilisation

Maintenant vous pouvez vous en servir en allant dans Tools > External Tool > PHP cs fixer (ou autre si vous avez changé le nom). Mais aussi lors du click droit sur un fichier/dossier en allant dans le sous menu external tools.

Je vous conseille par contre de mettre un raccourci (keymap -> external tools -> php cs fixer) pour pouvoir l’appliquer directement avec le clavier.

Pour automatiser cette options vous pouvez faire un hook avec git sur le pre-commit ou définir un file watcher dans PHPStrom. L’action sera faite au moment de la sauvegarde. Plus d’information ici

Design pattern stratégie : principe et exemple en PHP

2015-05-14T18:00:51+00:00

Le design pattern stratégie permet d’appliquer un algorithme dynamiquement au sein de votre application. On a donc une famille d’algorithmes au sein d’objets interchangeables a l’aide d’une interface. Il est assez simple, et même probable que vous l’utilisait déjà sans le savoir. Nous allons donc voir un peu plus en détail le design pattern stratégie comme cela à été demandé il y a peu.

Nous avons donc une interface qui contient toutes les méthodes communes a nos algorithmes. Ensuite dans un objet qui implémentera cette interface nous allons mettre le code correspondant a notre algorithme. Ainsi par exemple nous avons une collection d’objet implementant cette interface on peut leurs appliquer les méthodes communes sans avoir la moindre idée de la classe réelle.

Le design pattern peut etre utilisé par exemple pour effectuer des tris. Ensuite dans les classes les implémentant nous pouvons donc utiliser des algorithmes totalement différent puis permettre leurs utilisations au sein d’un objet principal en utilisant l’interface.

Pour expliquer ce design pattern nous allons utiliser des applications différentes pouvant être lancé par une classe principale qui ne sait pas quelle application elle va lancer. On utilise juste l’interface.

Nous avons donc deux applications (A et B) ayant pour interface ApplicationInterface. Une classe principale qui appelle la méthode run d’un objet implémentant l’interface ApplicationInterface. Ainsi notre classe principale peut faire les différents appel sans avoir la connaissance de la classe réelle.

Ceci permet d’avoir bien entendu un code plus souple et maintenable, bien entendu il est fortement conseillé de privilégier l’utilisation des interfaces a celle des classes. En effet cela vous permettra d’avoir dans un premier temps un code plus souple mais surtout cela vous permettra d’écrire plus facilement vos tests.

Retour d’expérience sur l’utilisation d’inbox by Gmail

2015-05-11T23:21:38+00:00

Note : Ce projet n’existe plus chez google, une bonne partie des fonctionnalités sont maintenant ingégré a gmail

J’ai pu avoir accès a la beta d’inbox by gmail il y a un peu plus d’une semaine. Je vais donc vous faire parvenir un petit retour sur ce service.

Personnellement malgré quelques petits défaut j’accroche assez bien et je trouve que je gagne un peu de temps comparé a l’application web gmail.

Il s’agit d’un nouveau service proposé par Google pour lire ses messages etc. Par défaut il est obligatoirement synchronisé avec votre compte gmail. Les actions effectués au sein de chaque service ce répercute sur l’autre.

L’interface a été totalement remanié pour être plus claire et mettre plus en avant vos mails. De même pour l’interface de vos contacts. Tout semble avoir rajeunie.

Pour vous en servir vous pouvez soit envoyer un mail a inbox@google.com soit avoir une invitation de la part de quelqu’un utilisant déjà le service (il me reste quelques invitations si besoin).

Un point important à préciser est que cette messagerie est faite pour avoir peu de message dans la boite de réception en effet il est possible de marquer les messages comme terminés (équivalent de archivé sur gmail) pour qu’il ne soit plus dans votre boite de réception bien que toujours présent et accessible via une recherche etc. De même les messages importants peuvent être épinglé pour pouvoir les retrouver facilement.

Les points positifs

Je vais maintenant vous dire pourquoi ce service m’a séduit.

Les contenus mis en avant :

Certaines informations principales de vos mails sont souvent des pièces jointes, il faut alors accéder au mail pour les trouver. Avec inbox c’est fini avant même d’ouvrir un mail vous avez des informations sur les pièces jointes (nom, type et selon les types elles sont même visible directement).

De même si votre mails contient des informations sur un vol, un restaurant etc les informations sont aussi mise en avant.

Le tri automatique

Oui en fonction du contenu les messages sont trié dans des catégories par défaut ainsi que vos propres catégories a l’aide de filtre. Il sont ainsi regroupé et vous ne pouvez commencer votre tour que par l’essentiels. C’est assez pratique pour pouvoir ne se concentrer que sur l’utile au moment de la lecture. Un autre point assez intéressant qui viens avec le tri automatique est la possibilité de ne recevoir les mails d’une certaine catégorie que une fois par jours ou une fois par semaine si l’on le désire. Par défaut les mails sont disponible dès la réceptions.

Les rappels

Il s’agit la de la fonctionnalité qui m’a le plus séduit, en effet il est possible de placer de nombreux rappel au sein d’inbox. Le premier type de rappel est très simple il s’agit d’une simple todo list. Le message apparaîtra tant que vous ne l’avez pas mis comme terminé. Bien entendu vous pouvez faire en sorte qu’un rappel apparaisse dans la boite au lettre que a partir d’une certaine date ou lorsque l’on se trouve a une certaine position géographique (il faudra alors l’application mobile).

Ainsi je peux le matin me créer un rappel a 8h00 mais ne l’avoir affiché que le soir a partir de 19h00. Le rappel est donc mis en attente pendant ce temps. Il est important de noter que en dessous de la tâche nous avons la durée depuis laquelle elle est mise en attente.

La ou cela deviens merveilleux c’est que l’on peut mettre un mail en attente, il disparaît ainsi de la boite de réception pour ne réapparaître plus tard quand il sera utile ou lorsque il sera possible de le traiter. Ainsi plus de risque d’oublier un mail remis a plus tard mais aussi plus de culpabilité a voir ce mail sans réponse dans votre boite de réception.

Les points négatifs

Comme de partout il y a quelques points négatifs. Premièrement pour faire les tris automatiques etc il est évidents que vos mails sont analysé par des algorithmes appartenant a google – après il faut relativisé si le mail est sur votre adresse gmail avec ou sans inbox google a la possibilité d’y avoir accès.

Mais plus important pour moi c’est une erreur d’ergonomie, en effet actuellement il est impossible de supprimer un mail en un clic. Il faut passer par un menu pour pouvoir enfin le supprimer. Cette action bien que courante va vous faire perdre du temps a chaque suppression.

En conclusion je suis devenu assez fan de ce service qui me fait gagner du temps dans le tri de mes mails mais aussi me sert de todo-list. De plus c’est toujours agréable d’avoir 0 messages ou tâche en boite de réception car tout est terminé ou en attente et pouvoir profiter du beau soleil en fond d’inbox.

Il me reste quelques invitations si jamais certains veulent tester le service eux aussi.

Utiliser Diff et Patch sous Linux : Guide Essentiel

2015-04-30T18:00:56+00:00

Vous avez déjà eu besoin de chercher les différences entre deux fichiers ?
Modifier un fichier et souhaité transmettre uniquement vos modifications ?
Ou bien appliquer des modifications sur un fichier ?

Si vous avez répondu oui à l’une de ces questions, cet article est fait pour vous.

La commande diff sous Linux

Introduction à la commande diff

Pour résumer la commande diff permet de voir les différences entre plusieurs fichiers. Cette comparaison se fait ligne par ligne de manière séquentielle et comprends donc tout le fichier.

Les cibles peuvent être

des fichiers
des dossiers
et même l’entrée standard (via le symbole -).

En fonction du type de cible le comportement varie un petit peu, surtout lors qu’il ne s’agit pas de deux fichier.

Lorsque l’une des cibles est un dossier et l’autre un fichier la comparaison est faites sur les fichiers de même nom.

Pour le cas de deux dossiers les fichiers de même nom sont comparé un a un de manière séquentielle. Par défaut il n’y a pas de récursivité, on ne compare que le premier niveau.

La syntaxe est :

diff [options] cible1 cible 2

Options utiles pour la commande Diff

Comme vous avez pu le voir dans la commande ci-dessous diff peut avoir des options.

Voici les plus pratiques et utilisé :

-b ignore les différences du à des espaces blancs
-B ignore les différences du à des lignes blanches
-i ignore la casse (c’est a dire les différences entre les minuscules et les majuscule)
-q indiquer seulement si les fichiers sont différents et ne pas afficher les différences elles-mêmes
-s indiquer lorsque deux fichiers sont identiques
-r comparaison récursive des fichiers d’un répertoire, sous répertoires…

La commande patch pour appliquer des modifications

Les patch permettent d’appliquer rapidement les modifications effectué entre deux fichiers.

Son utilisation est assez simple entre deux fichiers

patch fichierSource < fichier.patch

Dans le cas des répertoires il y a une option p pour préciser le niveau de profondeur, en effet la hiérarchie des fichiers a pu changer entre le pc ou le patch a été effectué et le pc où l’on applique le patch.

On ajoute le nombre de dossier a sauter dans l’arborescence pour appliquer le patch. Souvent l’option -p1 fonctionne – plus de 90% des cas.

Par exemple on pourrai avoir

patch -p3 < fichier.patch

Annuler un patch

Vous avez appliqué le mauvais patch a votre fichier, pas de panique une option est prévu pour revenir au fichier original avec le fichier modifié et notre fichier de patch grâce a l’option -R

Attention pour les patchs avec les répertoire il faut ici encore spécifier la profondeur avec l’option -p comme lors de l’application du patch.

Par exemple

patch -p3 -R < fichier.patch

Créer un patch avec diff

Pour créer un patch avec diff entre deux fichiers on utilise l’option -u et on redirige la sortie vers notre fichier de patch a l’aide du symbole >.

Par exemple

diff -u fichierInitial.c fichierModifie.c > fichier.patch

Pour une arborescence complète l’option change un peu : on utilise -rupN

diff -rupN dossierInitial/ dossierModifie/ > dossier.patch

Conclusion sur l’utilisation de Diff et Patch sous Linux

Pour résumer avec ces commandes vous pouvez

Voir les différences entre fichiers : commande diff
Créer un patch : commande diff avec l’option -u
Appliquer un patch : commande patch
Revenir a l’état d’avant le patch : commande patch avec l’option -R

Bien entendu des qu’il y a des dossiers d’autre options sont a rajouté pour gérer la récursion, les fichiers manquant, les différences de hiérarchies etc.

NB : la commande diff est disponible aussi sur git.

En espérant que ces deux petites commandes vous fasse gagner un peu de temps.

Activer inbox by Gmail sans smartphone

2015-04-29T00:20:34+00:00

Note : Ce projet n’existe plus chez google, une bonne partie des fonctionnalités sont maintenant ingégré a gmail

Si vous aussi vous avez obtenue une invitation pour le service Inbox by gmail mais que comme moi vous n’avez ni smartphone sous android ni iphone vous avez du etre un peu frustré quand lors de votre connexion sur l’application web vous avez un message demandant un passage par l’application mobile. Et bien entendu aucune application de disponible pour votre support (windows phone pour moi)

Toutefois il est assez simple de s’en passer.

Avec le mail d’invitation se trouve en bas un token (code d’invitation), grâce a celui ci vous pouvez vous passer de l’application mobile.

Collez le a la fin de cette URL

https://mail.google.com/mail/btinvites/mobile?token=

Accéder a la ressource, un fichier est normalement téléchargé en parallèle un mail vous confirmera que l’application sera utilisable en mode web.

Build d’application node-webkit avec grunt

2015-04-23T18:00:23+00:00

Avec node-webkit-builder vous allez pouvoir build votre application node-webkit en ligne de commande assez simplement. Le module se charge de télécharger les exécutables, de créer votre dossier de release et build votre application. Mieux encore, ce processus peut être simplifié avec un plugin grunt. Nous allons donc voir comment utiliser au mieux ce plugin pour avoir votre application disponible sur les diverses plateformes.

Import de node-webkit-builder

Commençons par creer notre fichier package.json, ce fichier servira de base pour nos dépendance nodeJs nécessaire au build, c’est a dire notre plugin grunt.

{ 
	"name": "node-webkit-starter-pack", 
	"description": "Beggins with node-webkit using grunt for packaging", 
	"devDependencies": { 
		"grunt": "latest", 
		"grunt-node-webkit-builder": "latest" 
	}
}

Globalement il s’agit d’un fichier de dépendance classique pour nodeJs, on spécifie que l’on a besoin de grunt et grunt-node-webkit-builder pour pouvoir utiliser nos build automatiques.

Pour installer nos dépendance il suffit d’un simple

npm install

Maintenant nous allons voir comment configurer notre plugin grunt pour répondre a nos attentes.

Configuration de node-webkit-builder

Pour configurer grunt nous allons remplir un fichier Gruntfile.js. Voici ci dessous une configuration possible notre plugins :

module.exports = function(grunt) {

    grunt.initConfig({
        nodewebkit: {
            options: {
                buildDir: './build', // where the build is save
                platforms: ['win', 'osx', 'linux'], // platform to build
                buildType : "versioned",
                macZip: false // app isn't zip on mac but it improve speed app
            },
            src: './app/**/*' // Your node-webkit app
        },
      });
      
      grunt.loadNpmTasks('grunt-node-webkit-builder');
      grunt.registerTask('default', ['nodewebkit']);

};

Nous avons donc défini pour node-webkit que notre application se situe dans le sous dossier app. De même nous avons mis en place certaines configuration.

De ce fait a chaque build nous retrouverons nos résultats dans les sous dossier ./build/appName – Version/platform . Le fait d’avoir mis macZip a false entraînera un fichier plus lourd sur macOs mais le temps de démarrage sera largement amélioré.

Maintenant pour générer nos build il suffit d’entre la commande suivante :

grunt

Je vais éviter de faire une liste des options disponible avec le plugins : pour voir l’ensemble de celle ci vous pouvez vous rendre ici.

Il faut également savoir que l’on peut surcharger le fichier de configuration de node webkit par plateforme grâce a l’option platformOverrides.

J’ai également mis en place un dépôt github avec la structure de base de faire vous permettant de n’avoir qu’a changer les config de base et coder votre application node-webkit. Il est disponible ici.

Je vous invite a jouer avec toutes les options de node webkit, que ce soit dans le package.json contenu au niveau de l’application (dans le dossier app du coup) ou au niveau du fichier Gruntfile.js. Avec cet outil le packaging de vos applications devrait être plus rapide et simple. Pour ma part je vais m’en servir sur mon projet avec node-webkit.

Présentation de NW.js : Créez des apps desktop modernes

2015-04-22T00:17:13+00:00

Node-Webkit, rebaptisé NW.js, est un environnement d’exécution basé sur Chromium et Node.js. Il permet de créer des applications de bureau multiplateformes (Windows, Mac OS X, Linux) en utilisant des technologies web modernes telles que HTML5, CSS3 et JavaScript. Cet outil offre une intégration unique entre le DOM et les modules Node.js, ouvrant la voie à une nouvelle manière de développer des applications natives.

Pourquoi utiliser Node-Webkit/NW.js ?

NW.js se distingue par ses nombreuses fonctionnalités qui facilitent le développement d’applications performantes et faciles à distribuer :

Technologies modernes : Prise en charge complète de HTML5, CSS3, WebGL et des API Node.js.
Performance optimisée : Chromium et Node.js s’exécutent dans le même thread, ce qui simplifie les appels de fonctions et l’accès aux objets.
Flexibilité : Possibilité d’appeler directement les modules Node.js depuis le DOM ou les Web Workers.
Multiplateforme : Compatible avec Linux, Mac OS X et Windows.
Facilité de distribution : Les applications peuvent être facilement empaquetées et distribuées.

Installation et prise en main

Installation

Pour installer NW.js, vous pouvez utiliser npm. Voici les étapes de base :

Installer NW.js localement dans votre projet :
```
npm install nw
```
Ajouter un script dans votre fichier package.json pour lancer l’application :
```
{
  "scripts": {
    "start": "nw"
  }
}
```
Lancer l’application :
```
npm start
```

Création d’une application simple

Créez un fichier index.html :

<!DOCTYPE html>
<html>
  <head>
    <title>Hello World!</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    <p>Nous utilisons Node.js version : <script>document.write(process.version)</script></p>
  </body>
</html>

Créez un fichier package.json :

{
  "name": "nw-demo",
  "version": "1.0.0",
  "main": "index.html"
}

Lancez l’application avec NW.js :
```
nw .
```

Cas d’utilisation

NW.js est idéal pour plusieurs scénarios :

Applications desktop multiplateformes : Créez une seule application qui fonctionne sur Windows, Mac et Linux.
Applications nécessitant des fonctionnalités avancées : Intégrez des modules Node.js pour accéder à des fonctionnalités système ou tierces.
Prototypage rapide : Utilisez vos compétences en développement web pour concevoir rapidement des interfaces utilisateur.

Avantages par rapport à Electron

Bien que NW.js soit souvent comparé à Electron, il présente certaines différences notables :

Caractéristique	NW.js	Electron
Intégration DOM-Node.js	Appels directs entre DOM et Node.js	Processus séparés pour DOM et Node.js
Structure du projet	`package.json` au cœur	Fichiers séparés pour main/renderer
Performances	Fonctionne dans un seul thread	Multi-processus

Conclusion

NW.js est un outil puissant pour les développeurs souhaitant créer des applications de bureau modernes en utilisant leurs compétences en développement web. Grâce à sa flexibilité, ses performances optimisées et sa prise en charge multiplateforme, il constitue une excellente alternative pour transformer vos idées en applications natives.

Si vous cherchez à développer rapidement une application desktop tout en exploitant les avantages des technologies web, NW.js est une solution incontournable !

Emportez et partagez votre éditeur avec C9

2015-04-16T18:00:39+00:00

Vous avez déjà eu a éditer votre code mais sans avoir votre éditeur favori ?

Ou simplement du travailler ensemble sur un même code (par exemple lors de prise de note en cours) ?

Si cela vous ai déjà arrivé vous devez savoir a quel points il est difficile d’être à deux en même temps sur le même bout de code en mode collaboratif (comme par exemple etherpad ou google docs pour la prise de texte).

J’ai découvert il y a peu – hélas – un outil qui va changer tout ça : C9.

Présentation générale

Cloud9 abrégé c9 est un ide en ligne, accessible ainsi avec un simple navigateur.

De plus votre code est exécuté dans l’application : une machine virtuelle est disponible configurable selon les besoins. Ainsi avec un simple navigateur vous pouvez facilement coder, compiler si besoin et tester votre application.

Ce qui vous permettra d’éditer facilement vos scripts et tests varié. Il un système de plugin permettant de rendre cet ide aussi performant qu’un ide standard (auto-complétion, coloration, options de refactoring etc.) est disponible.

Mais vous pouvez aussi partager votre IDE avec d’autre ainsi que le workspace et même l’application qui tourne sur le workspace tout simplement avec un système de droit.

Lors que vous avez partagé votre ide vous pouvez voir tout ce que les autres utilisateur tape en direct.

Cerise sur le gâteau il est en outre possible de revoir les modifications d’un fichier depuis sa création, avec même une sorte de mode vidéo.

Comment se servir de c9 comme éditeur

Pour pouvoir utiliser C9 vous pouvez soit :

L’héberger vous même les sources sont disponible sur github – attention il faudra utiliser les plugins etc pour avoir toutes les fonctionnalités
Utiliser le service en ligne

Pour la suite de l’article je parlerai uniquement du service en ligne, en effet je n’ai pas encore testé d’installer c9 sur ma machine ni sur un serveur.

Vous pouvez vous inscrire gratuitement et profiter de fonctionnalités limitées.

Avec l’offre gratuite vous pouvez avoir :

Une Vm privée
Autant de vm publique que voulu

Les vm sont limitées à:

1GB d’espace disque
512 mo de ram
les vm non utilisé sont mise en hibernation (il faudra un petit délais pour pouvoir y accéder a nouveau).

Voici un petit screen de l’interface de notre ide

Quelques cas d’utilisation possible :

Vous pouvez dans un amphi recopier les exemples de TP tous ensemble.

Mais aussi programmer a plusieurs sur le même fichier en même temps. Voire même écrire votre code et obtenir une vidéo de toutes les modifications – ce qui peut être pratique pour un tutorial.

Bien entendu cette solution étant relié a des services de versionning vous pouvez récupérer vos propre dépôt facilement.

Dans un contexte totalement différent vous pouvez ainsi développer votre application sur un environnement externe et de ce fait économiser les ressources de votre ordinateur.

En effet avec c9 vous avez plus besoin d’ouvrir votre ide favori qui se fait une joie de consommer une quantité de ram importante.

Personnellement même si le concept a l’air assez bien je préfère avoir mon ide en local pour des projets plus important, en effet ils ont quand même souvent plus de fonctionnalités.

Le fait que les sources soient disponible peut nous permettre d’utiliser c9 sur des projets un peu plus privé avec un peu plus de confiance malgré la présence de workspace privée sur le site.

Que pensez vous de cet outil ? Seriez vous prêt a passer totalement dessus ? Pour quels genre de projet ?

Design Pattern Visiteur : principe et exemple d'implémentation

2015-04-09T18:00:11+00:00

Découvrez le Design Pattern Visiteur : une méthode efficace pour séparer algorithmes et structures de données, avec exemples en PHP et Java.

Cette semaine je vais vous présenter un nouveau design pattern que je trouve assez intéressant : le design pattern visiteur.

Le pattern Visiteur (Visitor) permet de séparer de manière claire un algorithme d’une structure de donnée. L’algorithme n’est donc pas implémenté dans la classe mais dans des classes externes.

On limite ainsi tout couplage entre les données et leurs traitements, ce qui permet d’ajouter des traitements à nos structures de données sans avoir à les modifier. De plus, la classe externe est informée du type exact de l’objet qu’elle visite à l’aide du principe du double dispatch (bon, sauf en PHP où la signature des méthodes ne prend pas en compte le type des entrées).

Qu’est-ce que le Design Pattern Visiteur ?

Principe et avantages

Le design pattern Visiteur permet de séparer l’algorithme du modèle de données. Il consiste à appliquer un algorithme sur une structure de données sans modifier cette structure. L’algorithme est encapsulé dans une classe distincte, appelée visiteur, qui peut agir sur divers types d’objets visités, tout en préservant la flexibilité du code.

Le concept de double dispatch

Le double dispatch est essentiel au fonctionnement du pattern. Il permet à un objet de connaître son type exact à runtime et d’exécuter des méthodes adaptées au type de l’objet qu’il visite.

Implémentation du Design Pattern Visiteur

Bien que souvent évoqué comme complexe, ce design pattern est relativement simple. Notre classe visitable (c’est-à-dire notre structure de données) possède une méthode accept qui nous permet d’injecter notre visiteur (on précise une interface correspondant aux visiteurs voulus en type d’entrée).

En même temps, les visiteurs concrets implémentent une interface qui contient une méthode visit par type d’objet visitable. Lors de l’utilisation, le typage dynamique permet d’appeler la bonne méthode — c’est ce qu’on appelle le double dispatch.

Dans notre objet visitable, on appellera donc la méthode visit de notre visiteur en lui passant l’objet lui-même.

Cas d’usage en PHP

Pour cet article, j’ai d’abord implémenté une solution en PHP avant de me rendre compte que le typage faible, ainsi que la façon dont est calculée la signature des méthodes, nous empêche de redéfinir une méthode avec des types différents. Cela signifie qu’en PHP, nous ne pouvons pas pleinement bénéficier des avantages du double dispatch. Toutefois, cet exemple simplifié aide à comprendre le concept.

Grace au design pattern visiteur nous allons mettre en place un système de rendu d’un document. Notre document sera un simple objet contenant un tableau clef-valeur. Le but est d’afficher le contenu de l’objet de plusieurs façon différente : plain text, html et xml. Pour faire cela une solution triviale serait de faire une classe renderer et dedans créer une méthode par type de rendu. Lors d’un ajout/suppression de méthode de rendu on éditerai ce fichier. Les deux principaux inconvénient de cette méthode a mon gout sont que :

on va avoir une classe assez volumineuse : difficulté de maintenance
pour l’ajout d’une méthode on modifie la classe du coup il faut la recompiler : temps de compilation croissant avec la taille de la classe.

Nous allons donc utiliser le design pattern visiteur. Chaque type de renderer sera une classe concrété ayant le rôle de visiteur et notre document (ici ConfigDocument) aura le rôle de classe visitable.

Ainsi pour gérer les différents types de rendu on aura juste a injecter le bon renderer via accept puis récupérer la sortie au niveau de notre renderer. Le fait d’avoir du html, xml ou autre ne dépends que du renderer que nous avons injecter. Si cela vous semble déjà merveilleux, je vous conseille de lire attentivement la suite.

Cas d’usage en Java

En java la principale modification est que chaque visiteur contient plusieurs méthodes accept : une part type d’objet quelle peut visiter. De cette façon on peut exécuter du code différent selon le type d’objet qui est visité et ceci au runtime. Voici un exemple simple pour illustrer ceci :

Conclusion

Le design pattern visiteur permet de séparer les algorithmes des structures de données sur lesquels ils sont appliqué
A l’aide du système de double dispatch les objets visiteurs peuvent avoir des comportements différents en fonction de l’objets qu’ils visitent

C’est tout pour ce design pattern, en espérant le voir plus souvent utilisé même si on y pense pas tout le temps. J’espère que vous comprenez un peu mieux l’intérêt du visiteur et surtout comment le mettre en oeuvre. Si ce n’est pas le cas, je répondrai aux questions dans les commentaires.

Apprenez le Design Pattern Décorateur en 5 Min

2015-04-02T18:36:46+00:00

Vous voulez comprendre rapidement comment ajouter des fonctionnalités dynamiques à vos objets ? Ce guide vous explique tout en 5 minutes chrono !

Pour cela je vais vous présenter un design pattern fondamental en programmation orientée objet : le Décorateur.

Qu’est-ce que le Design Pattern Décorateur ?

Le pattern Décorateur (Decorator) permet d’ajouter dynamiquement de nouvelles fonctionnalités à un objet sans modifier son code d’origine. Il offre une alternative souple à l’héritage, évitant ainsi une complexité inutile (comme l’explosion des classes ou des diagrammes rigides).

En pratique, ce pattern est utile lorsque l’héritage rend le code trop lourd ou difficile à maintenir. Grâce au Décorateur, vous pouvez ajouter des comportements à l’exécution de manière flexible.

Dans certains cas, l’héritage alourdit inutilement la structure du code, rendant sa maintenance plus complexe :

explosion de classes
diagramme rigide
méthodes de la classe de base inappropriées dans certaines classes dérivées

On prefere donc ajouter les nouvelles fonctionnalité a l’exécution.

Mise en place du design pattern :

Introduction

Le concept est simple : un décorateur est une classe qui hérite de l’objet qu’elle décore et contient une instance de cet objet. Cela permet une décoration récursive.

Prenons un exemple concret. Imaginez un vaisseau spatial (comme dans l’image en haut de l’article). Le vaisseau de base est l’objet à décorer, et un propulseur supplémentaire agit comme un décorateur, lui ajoutant de nouvelles fonctionnalités (par exemple, augmenter sa vitesse).

Voici un schéma pour mieux visualiser :

Et voici une version UML plus formelle pour clarifier :

On voit bien que notre décorateur hérite du composant a décorer, contient une instance sur un composant.

Implémentation

Voici un extrait de code qui illustre comment implémenter ce pattern :

Dans cet exemple :

Ship est une classe abstraite qui définit un vaisseau spatial.
JediShip représente un vaisseau Jedi.
Accelerator est un décorateur qui ajoute une fonctionnalité : l’accélération.

Les deux dernières classes héritent de Ship, permettant ainsi un chaînage récursif des décorateurs.

Dans le fichier Warehouse, vous pouvez observer une utilisation concrète de ce design pattern.

Points forts

Le Décorateur repose sur l’héritage et la composition, ce qui en fait un pattern puissant pour construire des applications modulaires et évolutives. Cependant, l’instanciation fréquente d’objets peut nécessiter l’utilisation d’une Factory pour optimiser le processus.

Conclusion

En résumé :

Le Décorateur ajoute dynamiquement des comportements à un objet.
Il permet de chaîner plusieurs décorateurs pour des fonctionnalités combinées.
Le Décorateur et l’objet décoré partagent une classe ou une interface commune.

Ce pattern est un excellent outil pour gérer des besoins évolutifs tout en maintenant un code propre et maintenable.

C’est tout pour ce design pattern ! J’espère que cet article vous a été utile.

Quels autres patterns aimeriez-vous voir abordés dans un prochain article ? Faites-le-moi savoir dans les commentaires!

FAQ (Foire Aux Questions)

Qu’est-ce qu’un Design Pattern en programmation ?

Un Design Pattern est une solution réutilisable à un problème courant rencontré dans le développement logiciel. Ces patrons de conception permettent d’améliorer la structure, la lisibilité et la maintenance du code.

Quand utiliser le Design Pattern Décorateur ?

Le pattern Décorateur est particulièrement utile lorsque :

Vous souhaitez ajouter dynamiquement des fonctionnalités à un objet sans modifier son code source.
L’héritage devient trop complexe ou rigide, avec une explosion de classes.
Vous avez besoin d’une solution flexible pour enrichir un comportement à l’exécution.

Quelle est la différence entre héritage et composition ?

Héritage : Permet de définir une hiérarchie rigide où les classes dérivées héritent des propriétés et méthodes d’une classe parent.
Composition : Permet d’assembler dynamiquement des objets pour ajouter des fonctionnalités, offrant ainsi plus de flexibilité qu’un système basé uniquement sur l’héritage.

Quels sont les avantages du Design Pattern Décorateur ?

Ajout dynamique de fonctionnalités sans modifier le code existant.
Réduction de la complexité liée à l’héritage.
Meilleure réutilisabilité et modularité du code.
Possibilité d’empiler plusieurs décorateurs pour enrichir un objet.

Windows Host File Manager : outil de gestion simplifiée

2015-03-28T22:43:30+00:00

En tant que développeur web, vous avez souvent à éditer le fichier host pour ajouter des associations de nom hôtes avec des ip au sein de votre machine. Ce fichier a hélas la fâcheuse tendance de grossir de manière assez rapide ce qui rends la gestion assez capricieuse. Pire encore quelques fois vous aimeriez bien pouvoir a un nom de domaine associé une ip puis peut de temps apres une autre avant de revenir sur celle du début….

Introduction

C’est en partant de ce constat que j’ai eu l’idée de me lancer dans ce projet. Mettre en place une interface simple pour gérer ce fichier. Niveau technologie, bien que en premier lieux j’étais tenté de le faire en JAVA j’ai décidé de me lancer dans l’utilisation de NodeJS avec nodeWebkit pour permettre l’aspect logiciel natif. Cela dans le but d’apprendre a utiliser plus en détails ces deux technologies.

Actuellement j’ai mis en place une version fonctionnant sur windows qui permet de lister les hôtes dans le fichier host, les modifier supprimer et commenter. L’ajout de ligne est bien entendu possible également.

Fonctionnement :

Le fonctionnement de ce projet est assez simple, nous ouvrons donc le fichier host pour pouvoir l’analyser et afficher les diverses informations. Les actions au sein de l’ihm entraîne la modification du fichier par une nouvelle écriture.

Restant à faire :

Amélioration de l’existant
Import / export
Système de profil
Portabilité
Système de recherche

Vous pouvez suivre plus en détail ce projet sur github