&Agrave; la d&eacute;couverte du Fediverse


Depuis quelques semaines, un séisme secoue le web après l’arrivée récente d’Elon Musk à la tête de Twitter&nbsp;: démissions, licenciements en cascade, rumeurs de fermeture&#8230; Ces bouleversements font migrer de nombreuses personnalités, utilisatrices et utilisateurs de Twitter vers Mastodon.&nbsp;



<h2>Qu’est-ce que Mastodon ?</h2>



Mastodon est à la fois un réseau social et un logiciel de microblogging auto-hébergé, libre, distribué et décentralisé. Le réseau est constitué d’un ensemble de serveurs qui peuvent communiquer entre eux grâce à <a href="https://fr.wikipedia.org/wiki/ActivityPub" target="_blank" rel="noreferrer noopener">ActivityPub</a>, un protocole ouvert édité par le W3C (le même organisme qui publie les spécifications HTML, CSS ou encore RDF, qui sont au cœur du web). On peut considérer Mastodon comme un réseau analogue de Twitter, mais fédéré.&nbsp;



Non seulement les comptes Mastodon peuvent suivre d&#8217;autres comptes Mastodon &#8211; même si ils sont hébergés sur d&#8217;autres serveurs appelées “instances”, mais ils peuvent aussi suivre des comptes utilisant d&#8217;autres applications communiquant également avec le protocole ActivityPub, comme Pixelfed ou PeerTube. L’ensemble de ces instances fédérées (qui peuvent donc utiliser des logiciels différents mais interopérables) forment ce que l’on appelle <a href="https://fr.wikipedia.org/wiki/Fediverse" target="_blank" rel="noreferrer noopener">le Fediverse</a>. Concrètement, c’est un peu comme si votre compte Twitter vous permettait de suivre et d&#8217;interagir avec les utilisateurs d’Instagram et de TikTok.



<h2>À la découverte du Fediverse</h2>



Le Fediverse, mot-valise formé à partir de &#8220;federation&#8221; et &#8220;universe&#8221;, est un réseau fédéré composé de nombreux serveurs indépendants, qui utilisent divers logiciels très différents mais capables de communiquer ensemble. Ces nombreux serveurs autonomes et indépendants sont ainsi interconnectés et permettent à leurs utilisateurs et utilisatrices d&#8217;interagir les uns et les unes avec les autres de façon totalement transparente. Il n&#8217;y a pas de site central unique : c’est à chaque utilisateur de choisir un serveur pour s’y inscrire.



<center><iframe loading="lazy" title="What is this Federation thing?" src="https://tilvids.com/videos/embed/d62847b6-b803-4985-8b7e-9f905799188c" allowfullscreen="" sandbox="allow-same-origin allow-scripts allow-popups" width="560" height="315" frameborder="0"></iframe></center>



Cette décentralisation garantit que chaque hébergeur d’un serveur est souverain sur ses données. Aucune autorité centrale ne peut censurer ou invisibiliser. De plus, les serveurs du Fediverse (également appelé Fedi) n&#8217;intègrent généralement pas de publicités, ni d&#8217;algorithmes malveillants qui vous fichent et vous surveillent. Comme le web sur lequel il s’appuie, le Fediverse n’appartient pas à une grande firme qui y dicte ses règles : tout le monde peut y brancher son serveur, sans devoir demander l’autorisation à qui que ce soit. 



Pour le moment, le Fediverse est principalement composé de petites communautés, mais n’importe quel site ou réseau social existant peut facilement rejoindre le Fediverse. Pour cela il lui suffit d’implémenter ActivityPub (ou l’un des autres protocoles supporté par le réseau). <a href="https://techreport.com/software/3485711/tumblr-signals-support-for-activitypub-the-mastodon-protocol/" target="_blank" rel="noreferrer noopener">Tumblr, la plateforme de microblogging qui fut un temps la coqueluche du web, vient par exemple d’annoncer son intention de rejoindre le Fediverse</a>.



<h2>Le protocole ActivityPub</h2>



Les communications entre tous ces serveurs se font généralement via un protocole appelé ActivityPub. Il est supporté par Mastodon, mais aussi par d&#8217;autres logiciels tels que PeerTube (alternative à YouTube) et Mobilizon (alternative à Meetup et aux évènements Facebook), tous deux développés par l’association française Framasoft, ou encore Pixelfed (alternative à Instagram) et WriteFreely (logiciel de blog). Il existe par ailleurs un plugin permettant de rendre n’importe quel site utilisant WordPress (y compris le nôtre) accessible sur le Fediverse. Tous ces logiciels peuvent donc interagir ensemble !



ActivityPub a été publié en 2018. C’est le successeur du standard OStatus. ActivityPub s’est très vite imposé du fait de sa simplicité d’implémentation. Les rédactrices et rédacteurs du standard ont d’ailleurs mis un point d’honneur à rendre la lecture de <a href="https://www.w3.org/TR/activitypub/" target="_blank" rel="noreferrer noopener">la spécification</a> aussi aisée que possible, ce que les habitués de ce type de littérature savent assez rare.



Le framework web que nous développons, API Platform, <a href="https://github.com/api-platform/activity-pub" target="_blank" rel="noreferrer noopener">propose également un module permettant à n’importe quel site qui l’utilise d’implémenter ActivityPub</a>. Il est aussi compatible avec l’ensemble des sites créés avec le populaire framework Symfony, auquel nous sommes fiers de contribuer et que nous sponsorisons. Ce module peut même être utilisé comme une bibliothèque PHP autonome.



ActivityPub fonctionne grâce à deux points d’entrée mises à disposition sur une API REST qui se comportent comme deux boîtes aux lettres : l’une permet de recevoir du contenu, l’autre permet d’en envoyer. Pour communiquer avec une autre instance, un serveur n’a donc qu’à consulter le contenu public de la&nbsp; “boîte d’envoi” de cette instance, et déposer du contenu qui lui est spécifique dans sa “boîte de réception”.



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="476" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13-1024x476.png" alt="" class="wp-image-6069" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13-1024x476.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13-600x279.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13-300x140.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13-768x357.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/12/Capture-decran-2022-12-06-a-17.50.13.png 1380w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Le seul prérequis est de connaître l’existence du serveur en question. Dans le cas d’un serveur exécutant Mastodon, la découverte des autres serveurs se fait au fur et à mesure que les membres du Fediverse se connectent entre eux.



Notez que la spécification d’ActivityPub précise qu’il est tout à fait possible de n’implémenter qu’une seule des deux boîtes.



<h2>Les-Tilleuls.coop et le Fediverse</h2>



Chez Les-Tilleuls.coop, cela fait plusieurs années désormais que <a href="https://les-tilleuls.coop/blog/api-platform-schema-generator-v3" target="_blank" rel="noreferrer noopener">nous alertons sur la manière dont le web est utilisé</a>. Nous sommes intervenu·e·s à plusieurs reprises sur les manières de&nbsp; bâtir un nouveau web décentralisé : 



<center><iframe loading="lazy" src="https://www.youtube.com/embed/x4rvTtfP4k8" title="YouTube video player" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" width="560" height="315" frameborder="0"></iframe></center>



Comme nous l’avons vu, nous avons également créé il y a quelques années <a href="https://github.com/api-platform/activity-pub" target="_blank" rel="noreferrer noopener">une bibliothèque PHP implémentant le protocole ActivityPub</a> et nous sommes logiquement présents sur <a href="https://mastodon.online/@cooptilleuls" target="_blank" rel="noreferrer noopener">Mastodon</a> et Peertube depuis plusieurs années.



Si vous souhaitez aussi rejoindre le Fediverse, <a href="https://les-tilleuls.coop/blog/rencontre-equipe-sre" target="_blank" rel="noreferrer noopener">notre pôle SRE</a> peut héberger vos instances Mastodon, PeerTube, Mobilizon, PixelFed, etc. Nos développeuses et développeurs <a href="https://les-tilleuls.coop/cloud-et-devops" target="_blank" rel="noreferrer noopener">peuvent également adapter vos sites, apps et réseaux sociaux pour les rendre compatibles</a> ! Contactez-nous pour plus de détails.







Crédit photo : <a href="https://commons.wikimedia.org/wiki/User:Eukombos">Eukombos</a>, <a href="https://en.wikipedia.org/wiki/en:Creative_Commons">Creative Commons</a> <a href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Attribution-Share Alike 4.0 International</a>

Mastodon, le Fediverse, ActivityPub : comprendre et maîtriser les nouvelles étoiles du web

Comprenez le fonctionnement du Fediverse, du protocole ActivityPub et du réseau social Mastodon grâce à cet article.

Mastodon, le Fediverse, ActivityPub : comprendre et maîtriser les nouvelles étoiles du web | Les-Tilleuls.coop

Accueil

Les-Tilleuls.coop

https://secure.gravatar.com/avatar/54fb8ea2a1a36c3b9ef44f25bf976b48?s=96&d=mm&r=g

Cécile Hamerel

Formater et documenter vos &eacute;num&eacute;rations expos&eacute;es


&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Validator\Constraints\Length;

#[ApiResource(types: ['http://schema.org/Blogpost'], description: "A blog article")]
class BlogPost
{
    public function __construct(
        #[ApiProperty(types: ['http://schema.org/identifier'])]
        public Uuid $id,
        #[ApiProperty(types: ['http://schema.org/name'])]
        #[Length(min: 3)]
        public string $title,
        public Status $status
    )
    {
    }
}

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;

#[
    ApiResource(
        types: ['https://schema.org/Enumeration'],
        normalizationContext: ['groups' => ['read']],
        description: "Status used for a blog article"
    ),
    GetCollection(provider: Status::class.'::getCases'),
    Get(provider: Status::class.'::getCase')
]
enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;

    use EnumApiResourceTrait;
}

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\Operation;
use Symfony\Component\Serializer\Annotation\Groups;

trait EnumApiResourceTrait
{
    #[ApiProperty(types: ['https://schema.org/identifier'])]
    public function getId()
    {
        return $this->name;
    }

    #[Groups('read')]
    #[ApiProperty(types: ['https://schema.org/name'])]
    public function getValue()
    {
        return $this->value;
    }

    public static function getCases()
    {
        return self::cases();
    }

    public static function getCase(Operation $operation, array $uriVariables)
    {
        $name = $uriVariables['id'] ?? null;
        return self::tryFrom($name) ?? constant(self::class . "::$name");
    }
}

    "components": {
        "schemas": {
            "BlogPost.jsonld": {
                "type": "object",
                "description": "A blog article",
                "deprecated": false,
                "externalDocs": {
                    "url": "http://schema.org/Blogpost"
                },
                "properties": {
                    "id": {
                        "externalDocs": {
                            "url": "http://schema.org/identifier"
                        },
                        "type": "string",
                        "format": "uuid"
                    },
                    "title": {
                        "minLength": 3,
                        "externalDocs": {
                            "url": "http://schema.org/name"
                        },
                        "type": "string"
                    },
                    "status": {
                        "type": "string",
                        "format": "iri-reference"
                    }
                }
            },
            "Status.jsonld-read": {
                "type": "object",
                "description": "Status used for a blog article",
                "deprecated": false,
                "externalDocs": {
                    "url": "https://schema.org/Enumeration"
                },
                "properties": {
                    "@context": {
                        "readOnly": true,
                        "oneOf": [
                            {
                                "type": "string"
                            },
                            {
                                "type": "object",
                                "properties": {
                                    "@vocab": {
                                        "type": "string"
                                    },
                                    "hydra": {
                                        "type": "string",
                                        "enum": [
                                            "http://www.w3.org/ns/hydra/core#"
                                        ]
                                    }
                                },
                                "required": [
                                    "@vocab",
                                    "hydra"
                                ],
                                "additionalProperties": true
                            }
                        ]
                    },
                    "@id": {
                        "readOnly": true,
                        "type": "string"
                    },
                    "@type": {
                        "readOnly": true,
                        "type": "string"
                    },
                    "value": {
                        "readOnly": true,
                        "externalDocs": {
                            "url": "https://schema.org/name"
                        },
                        "type": "string"
                    }
                }
            }

    "hydra:supportedClass": [
        {
            "@id": "http://schema.org/Blogpost",
            "@type": "hydra:Class",
            "rdfs:label": "BlogPost",
            "hydra:title": "BlogPost",
            "hydra:supportedProperty": [
                {
                    "@type": "hydra:SupportedProperty",
                    "hydra:property": {
                        "@id": "#BlogPost/id",
                        "@type": "rdf:Property",
                        "rdfs:label": "id",
                        "domain": "http://schema.org/Blogpost"
                    },
                    "hydra:title": "id",
                    "hydra:required": false,
                    "hydra:readable": true,
                    "hydra:writeable": true
                },
                {
                    "@type": "hydra:SupportedProperty",
                    "hydra:property": {
                        "@id": "#BlogPost/title",
                        "@type": "rdf:Property",
                        "rdfs:label": "title",
                        "domain": "http://schema.org/Blogpost",
                        "range": "xmls:string"
                    },
                    "hydra:title": "title",
                    "hydra:required": false,
                    "hydra:readable": true,
                    "hydra:writeable": true
                },
                {
                    "@type": "hydra:SupportedProperty",
                    "hydra:property": {
                        "@id": "#BlogPost/status",
                        "@type": "hydra:Link",
                        "rdfs:label": "status",
                        "domain": "http://schema.org/Blogpost",
                        "owl:maxCardinality": 1,
                        "range": "https://schema.org/Enumeration"
                    },
                    "hydra:title": "status",
                    "hydra:required": false,
                    "hydra:readable": true,
                    "hydra:writeable": true
                }
            ],
            "hydra:description": "Blog article"
        },
        {
            "@id": "https://schema.org/Enumeration",
            "@type": "hydra:Class",
            "rdfs:label": "Status",
            "hydra:title": "Status",
            "hydra:supportedProperty": [
                {
                    "@type": "hydra:SupportedProperty",
                    "hydra:property": {
                        "@id": "#Status/value",
                        "@type": "rdf:Property",
                        "rdfs:label": "value",
                        "domain": "https://schema.org/Enumeration",
                        "range": "xmls:integer"
                    },
                    "hydra:title": "value",
                    "hydra:required": false,
                    "hydra:readable": true,
                    "hydra:writeable": false
                }
            ],
            "hydra:supportedOperation": [
                {
                    "@type": [
                        "hydra:Operation",
                        "schema:FindAction"
                    ],
                    "hydra:method": "GET",
                    "hydra:title": "Retrieves a Status resource.",
                    "rdfs:label": "Retrieves a Status resource.",
                    "returns": "https://schema.org/Enumeration"
                }
            ],
            "hydra:description": "Status used for a blog article"
        },


&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use Symfony\Component\Uid\Uuid;

#[ApiResource, GetCollection, Get, Post]
class BlogPost
{
    public function __construct(
        public Uuid $id,
        public string $title,
        public Status $status
    )
    {
    }
}

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;
}

curl -k -X 'POST' \
  'https://localhost/blog_posts' \
  -H 'Accept: application/ld+json' \
  -H 'Content-Type: application/ld+json' \
  -d '{
  "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "title": "string",
  "status": 0
}'

string

Donner la possibilit&eacute; de conna&icirc;tre la liste des valeurs possible


&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;

#[
    ApiResource,
    GetCollection, 
    Get,
]
enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;
}

&lt;?php

enum Suit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

function doStuff(Suit $s)
{
    // ...
}

doStuff(Suit::Spades);
doStuff('Spades'); // ceci échouera

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Operation;

#[
    ApiResource,
    GetCollection(provider: Status::class.'::getCases'), 
    Get(provider: Status::class.'::getCase'),
]
enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;

    public function getId()
    {
        return $this->name;
    }

    public static function getCases()
    {
        return self::cases();
    }

    public static function getCase(Operation $operation, array $uriVariables)
    {
        $name = $uriVariables['id'] ?? null;

        return constant(self::class . "::$name");
    }
}

curl -k --request GET 'https://localhost/statuses' --header 'Content-Type: application/ld+json'

curl -k --request GET 'https://localhost/statuses/DRAFT' --header 'Content-Type: application/ld+json'

    // ...

    public function getId()
    {
        return $this->value;
    }

    public static function getCases()
    {
        return array_map(static fn (UnitEnum $enumCase) => $enumCase->value, self::cases());
    }

    public static function getCase(Operation $operation, array $uriVariables)
    {
        return self::tryFrom($uriVariables['id'] ?? null);
    }

    // ...

S&eacute;rialiser les valeurs &eacute;num&eacute;r&eacute;es


&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Operation;
use Symfony\Component\Serializer\Annotation\Groups;

#[
  ApiResource(normalizationContext: ['groups' => ['read']]),
  GetCollection(provider: Status::class.'::getCases'),
  Get(provider: Status::class.'::getCase')
]
enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;

    public function getId()
    {
        return $this->name;
    }

    #[Groups('read')]
    public function getValue()
    {
        return $this->value;
    }

    public static function getCases()
    {
        return self::cases();
    }

    public static function getCase(Operation $operation, array $uriVariables)
    {
        return self::tryFrom($uriVariables['id']);
    }
}

curl -k -X 'GET' 'https://localhost/statuses' -H 'accept: application/ld+json'

curl -k -X 'GET' 'https://localhost:8000/statuses/DRAFT' -H 'accept: application/ld+json'

&lt;?php

enum Suit: string
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';
}

curl -k -X 'POST' \
  'https://localhost/blog_posts' \
  -H 'Accept: application/ld+json' \
  -H 'Content-Type: application/ld+json' \
  -d '{
  "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "title": "string",
  "status": "/statuses/DRAFT"
}'

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;

#[ApiResource(normalizationContext: ['groups' => ['read']]),
    GetCollection(provider: Status::class.'::getCases'),
    Get(provider: Status::class.'::getCase')
]
enum Status: int
{
    case DRAFT = 0;
    case PUBLISHED = 1;
    case ARCHIVED = 2;

    use EnumApiResourceTrait;
}

&lt;?php

declare(strict_types=1);

namespace App\ApiResource;

use ApiPlatform\Metadata\Operation;
use Symfony\Component\Serializer\Annotation\Groups;

trait EnumApiResourceTrait
{
    public function getId()
    {
        return $this->name;
    }

    #[Groups('read')]
    public function getValue()
    {
        return $this->value;
    }

    public static function getCases()
    {
        return self::cases();
    }

    public static function getCase(Operation $operation, array $uriVariables)
    {
        $name = $uriVariables['id'] ?? null;
        return self::tryFrom($name);
    }
}

Note d&#8217;avant lecture : si des termes vous sont inconnus, mettez votre lecture en pause et allez vérifier leur signification avant de reprendre !



Ils sont là depuis près d&#8217;un an, et ils ont longtemps été attendus ! Ce ne sont pas les derniers titres de Vianney mais les énumérations. Si vous les découvrez avec cet article, les <meta charset="utf-8">énumérations sont un moyen de définir un ensemble restreint de valeurs possibles pour un type. Cela peut être particulièrement utile lors de la définition d&#8217;un modèle de domaine puisqu&#8217;ils ne nécessitent pas de surcouche de code. 





 Il est également possible d&#8217;associer leurs constantes à des valeurs. 





Je vous invite à lire <a href="https://www.php.net/manual/fr/language.enumerations.php" target="_blank" rel="noreferrer noopener">la documentation</a> afin de prendre connaissance des autres mécanismes que proposent les <meta charset="utf-8">énumérations, leurs méthodes, leurs constantes&#8230; Lisez bien les douze sections en prenant le temps de les comprendre, quitte à tester vous-même chaque situation présentée ! Utiliser les <meta charset="utf-8">énumérations avec API Platform devient très vite attrayant, découvrez plus en détails pourquoi :



<h2>Les Enums avec API Platform</h2>



Voyons un cas classique d&#8217;un BlogPost possédant un statut : 







 Si nous effectuons une requête <code>POST</code> pour créer un BlogPost : 





Nous obtenons bien un BlogPost valide.





C&#8217;est déjà une très bonne chose, mais nous aimerions donner la possibilité de connaître les statuts disponibles, et de les exposer à l&#8217;aide de notre API.



<h2>Donner la possibilité de connaître la liste des valeurs possible</h2>



Nous allons transformer notre classe Status en ressource. 





<div class="wp-block-image"><figure class="aligncenter size-large"><img decoding="async" loading="lazy" width="1024" height="269" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-1024x269.png" alt="Aperçu de SwaggerUI avec les nouveaux EndPoint pour les status." class="wp-image-5882" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-1024x269.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-600x157.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-300x79.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-768x201.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-1536x403.png 1536w, https://api.les-tilleuls.coop/wp-content/uploads/2022/11/Capture-décran-2022-11-08-à-07.52.33-2048x537.png 2048w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure></div>



Pour servir de <code>provider</code>, nous allons utiliser l&#8217;<meta charset="utf-8">énumération Status lui-même. 





<blockquote class="wp-block-quote">La méthode statique <code>cases</code> n&#8217;appartient pas au <code>userland</code>. Il est sous-entendu ici qu&#8217;elle est définie par le langage, et n&#8217;est pas tout à fait régie par les mêmes règles. Nous devons la redéfinir nous-même afin qu&#8217;elle puisse être utilisée comme méthode de provider, sinon une incompatibilité des arguments attendus sera soulevée par PHP.</blockquote>



Nous pouvons à présent lister les statuts avec la requête HTTP suivante :







Et en obtenir une valeur spécifique à l&#8217;aide des constantes :







Vous pourriez aussi vouloir les récupérer avec leur valeur. 





<h2>Sérialiser les valeurs énumérées</h2>



Les <meta charset="utf-8">énumérations fonctionnent d&#8217;une manière assez particulière. Chaque <code>case</code>, lorsqu&#8217;il est obtenu est techniquement une instance de l&#8217;<meta charset="utf-8">énumérations. En passant par le Serializer, nous aurions alors une boucle infinie (si elle n&#8217;était pas limitée à trois sous-niveaux par défaut) où chaque <code>case</code> expose à son tour les autres <code>cases</code> disponibles. 



Nous devons restreindre cette récursion à l&#8217;aide des groupes de sérialisation (voir <a href="https://www.youtube.com/watch?v=mYwL8snWvTs" target="_blank" rel="noreferrer noopener">la conférence de notre coopérateur Mathias Arlaud</a> sur le sujet). 





Vous pouvez à présent obtenir la liste des statuts : 







Et récupérer un status seul : 







<h2>Résultat</h2>



Pour effectuer notre requête <code>POST</code> initiale, nous pouvons désormais faire référence à sa ressource à l&#8217;aide de son IRI ! 





Avec pour résultat : 





<h2>Factoriser le code</h2>



Les trois méthodes de notre <meta charset="utf-8">énumération sont très génériques alors nous pouvons utiliser les traits pour éviter de nous répéter au sein de nos autres <meta charset="utf-8">énumérations. 





Et 





C&#8217;est un bon moyen d&#8217;exposer vos listes !





<h2>Formater et documenter vos énumérations exposées</h2>



Depuis le début de cet article, je me suis appliqué à utiliser l&#8217;entête HTTP <code>Accept</code> pour la récupération de mes énumérations. En particulier avec le <a href="https://www.iana.org/assignments/media-types/media-types.xhtml" target="_blank" rel="noreferrer noopener">Media-Type</a> <code>application/ld+json</code> pour l&#8217;usage de <a href="https://json-ld.org/" target="_blank" rel="noreferrer noopener">Json Linked Data</a>. Cet entête permet la négociation de contenu. C&#8217;est important parce que REST propose une solution de restitution de la ressource demandée de sorte à ce qu&#8217;elle corresponde à ses capacités, sa nature, ainsi qu&#8217;au désir du client. Pour respecter ceci, nous voulons : 



<ul><li>Pouvoir représenter / rendre les données où elles se trouvent</li><li>Pouvoir encapsuler les données avec un moteur de rendu et envoyer les deux (la donnée brute et la donnée rendue)</li><li>Pouvoir envoyer les données brutes avec des métadonnées afin de laisser le choix du moteur de rendu au client</li></ul>



Ici nous nous proposons sur le dernier point.



<meta charset="utf-8">Le format <code>application/ld+json</code> est un format <a href="https://book.validatingrdf.com/" target="_blank" rel="noreferrer noopener">RDF</a>.



RDF est un élément clé des données liées (<a href="https://www.w3.org/standards/semanticweb/data" target="_blank" rel="noreferrer noopener">Linked-Data</a>). Les données liées ont été proposées comme un ensemble de bonnes pratiques pour publier des données sur le Web. Elles ont été introduites par <a href="https://fr.wikipedia.org/wiki/Tim_Berners-Lee" target="_blank" rel="noreferrer noopener">Tim Berners-Lee</a> et reposent sur quatre grands principes. RDF est mentionné dans le troisième principe comme l&#8217;une des normes qui fournit des informations utiles.



L&#8217;objectif est que l&#8217;information soit utile non seulement pour les humains qui utilisent des navigateurs (pour lesquels le HTML serait suffisant) mais aussi pour d&#8217;autres agents susceptibles de traiter automatiquement ces données (des clients avec des API HTTP).



<meta charset="utf-8">Nous ne savons pas encore, en tant que consommateur de l&#8217;API, ce que signifie ou représente le champs valeur de notre ressource <code>Status</code>. Mais puisque nous avons une API REST, offrant un format RDF, en particulier JSON-LD, nous souhaitons la nourrir pour qu&#8217;un outil partageant les mêmes standards puisse découvrir de façon automatisée comment exploiter nos données.



Pour faire ceci, et respecter RDF, il faut choisir un format respectant les règles établies ainsi qu&#8217;un &#8220;<a href="https://fr.wikipedia.org/wiki/Web_Ontology_Language" target="_blank" rel="noreferrer noopener">vocabulaire</a>&#8221; / une &#8220;<a href="https://www.w3.org/standards/semanticweb/ontology" target="_blank" rel="noreferrer noopener">ontologie</a>&#8220;, afin de s&#8217;assurer que la donnée offerte puisse être exploitée comme prévu. Les vocabulaires RDF sont couramment utilisés pour définir des concepts et des relations à l&#8217;échelle du web (<a href="https://schema.org/" target="_blank" rel="noreferrer noopener">Schema.org</a>), d’une branche d’industrie (la&nbsp;<a href="https://data.nasa.gov/ontologies/atmonto" target="_blank" rel="noreferrer noopener">NASA</a>,&nbsp;<a href="http://www.automotive-ontology.org/" target="_blank" rel="noreferrer noopener">The Automotive Ontology</a>,<a href="https://addictovocab.org/" target="_blank" rel="noreferrer noopener">&nbsp;AddictO Vocab</a>&#8230;) ou d’une organisation&nbsp; (<a href="https://op.europa.eu/en/web/eu-vocabularies/corevocs" target="_blank" rel="noreferrer noopener">l’Union Européenne,</a>&nbsp;<a href="https://www.w3.org/2001/sw/sweo/public/UseCases/Volkswagen/" target="_blank" rel="noreferrer noopener">Volkswagen</a>).





Au sein du vocabulaire Schema.org, il existe une définition des énumérations. <a href="https://schema.org/Enumeration" target="_blank" rel="noreferrer noopener">https://schema.org/Enumeration</a>. Afin de rendre nos ressources expressives, nous allons ajouter l&#8217;usage du vocabulaire dans nos métadonnées. Profitons-en pour ajouter une description à notre classe <code>BlogPost</code>.





Ensuite notre énumération <code>Status</code>





Sans oublier le trait :





Ce qui permet à API Platform de documenter notre ressource.



Voici ce qui sera ajouté à notre documentation OpenAPI (j&#8217;ai collé un extrait pour n&#8217;afficher ici que l&#8217;essentiel) :





API Platform pourra également fournir la documentation <a href="https://www.hydra-cg.com/" target="_blank" rel="noreferrer noopener">HYDRA</a> <meta charset="utf-8">(j&#8217;ai collé un extrait pour n&#8217;afficher ici que l&#8217;essentiel).





<h2>Synthétisons</h2>



Avec tout ce que nous avons fait, lorsque nous récupérons un statut en particulier, nous obtenons ce JSON-LD :





Nous ne savons pas encore, en tant que consommateur de l&#8217;API ce que signifie ou représente le champ valeur. Mais puisque nous avons une API REST, offrant un format RDF, en particulier JSON-LD, nous savons que nous pouvons en apprendre plus à l&#8217;aide de la clé <a href="https://www.w3.org/TR/json-ld/#the-context" target="_blank" rel="noreferrer noopener">context</a>. En effectuant une requête GET sur cet URL, nous allons donc obtenir des informations sur cette propriété et cette ressource.





Nous obtenons l&#8217;information que toutes les valeurs sont décrites par le vocabulaire défini à l&#8217;URL <code><meta charset="utf-8">https://localhost:8000/docs.jsonld#</code>. Cet URL, c&#8217;est la documentation Hydra vue précédemment.



Autrement dit, cela nous a permis d&#8217;obtenir une API Hypermédia.




Si API Platform est compatible, la documentation pourrait être un peu plus automatisée, et ce travail est en cours grâce à <a href="https://github.com/alanpoulain" target="_blank" rel="noreferrer noopener">Alan Poulain</a>, ici : <a href="https://github.com/api-platform/core/pull/5120" target="_blank" rel="noreferrer noopener">https://github.com/api-platform/core/pull/5120</a> et là <a href="https://github.com/api-platform/core/issues/2254" target="_blank" rel="noreferrer noopener">https://github.com/api-platform/core/issues/2254</a>. N&#8217;hésitez pas à aller tester et montrer votre enthousiasme sur son travail !




<h2>Aller plus loin </h2>



Si vous avez besoin d&#8217;intégrer encore plus loin vos <meta charset="utf-8">énumérations (readable, Doctrine, translate, bitwise operation, forms et Faker), je vous recommande également l&#8217;excellente bibliothèque PhpEnums <a href="https://github.com/Elao/PhpEnums" target="_blank" rel="noreferrer noopener">https://github.com/Elao/PhpEnums</a> réalisée par l&#8217;équipe d&#8217;Elao. 



Bon code à vous !

Exposez vos Enums avec API Platform

Découvrez dans cet article comment les Enums permettent de définir un ensemble restreint de valeurs possibles pour un type.

Exposez vos Enums avec API-Platform. Ils sont un moyen de définir un ensemble restreint de valeurs possibles pour un type.

Exposez vos Enums avec API-Platform

Exposez vos Enums avec API Platform | Les-Tilleuls.coop

https://secure.gravatar.com/avatar/b473bd9d058c922e08d57f39a4a861db?s=96&d=mm&r=g

Grégoire Hébert

&lt;?php

class LivingThing{}

class Animal extends LivingThing {}

class Cat extends Animal 
{
    public function __construct(
        public string $name,
        public bool $needToBeBrushed = true,
        public bool $needClawsCutting = true,
        public bool $needToBeFed = true
    ){}
}

interface AnimalShelter
{
    public function adopt(string $name): Animal;
}

class CatShelter implements AnimalShelter
{
    public function adopt(string $name): Cat
    {
        return new Cat($name);
    }
}

class BetterCatShelter implements AnimalShelter
{
    // On donne l'instance décorée
    public function __construct(private AnimalShelter $decorated)
    {}
     
    public function adopt(string $name): Cat
    {
        // On utilise le comportement initial de l'instance décorée
        $cat = $this->decorated->adopt($name);
        
        // Ainsi qu'un comportement supplémentaire
        $this->groom($cat);
        
        return $cat;
    }
     
    private function groom(Cat $cat)
    {
        $cat->needToBeBrushed = false;
        $cat->needClawsCutting = false;
        $cat->needToBeFed = false;
    }
}

class Me
{
    private Cat $cat;
     
    // Puis que le décorateur possède la même interface,
    // je n'ai rien à changer dans cette classe pour utiliser l'un ou l'autre
    public function getACatFromShelter(AnimalShelter $shelter, string $catName)
    {
        $this->cat = $shelter->adopt($catName);
    }
     
    public function checkCatStatus(): string
    {
        if (!$this->cat->needToBeBrushed &amp;&amp; !$this->cat->needClawsCutting &amp;&amp; !$this->cat->needToBeFed) {
            return "Tout va bien pour {$this->cat->name}.";
        }
        
        return "Oula... {$this->cat->name} a besoin d'attention !";
    }
}

$me = new Me;
$catShelter = new CatShelter;

$me->getACatFromShelter($catShelter, 'Cripper');
echo $me->checkCatStatus(). PHP_EOL;

$betterCatShelter = new BetterCatShelter($catShelter);
$me->getACatFromShelter($betterCatShelter, 'Jinjer');

echo $me->checkCatStatus(). PHP_EOL;


Application du pattern avec les services de Symfony


&lt;?php

// src/Mailer/LoggingMailer.php
namespace App\Mailer;

// ...
use Symfony\Component\DependencyInjection\Attribute\AsDecorator;

#[AsDecorator(decorates: Mailer::class)]
class LoggingMailer<meta charset="utf-8"> implements MailerInterface
{
	// ...
}

&lt;?php

// ...

#[AsDecorator(
	decorates: Mailer::class,
	priority: 10,
	onInvalid: ContainerInterface::IGNORE_ON_INVALID_REFERENCE,
)]
class LoggingMailer implements MailerInterface
{
	// ...
}

&lt;?php
 
// ...
use Symfony\Component\DependencyInjection\Attribute\AsDecorator;
use Symfony\Component\DependencyInjection\Attribute\MapDecorated;

#[AsDecorator(decorates: Mailer::class)]
class LoggingMailer implements MailerInterface
{
	public function __construct(#[MapDecorated] <meta charset="utf-8">MailerInterface $originalMailer)
	{
 	// ...
	}

	// ...
}

Inconv&eacute;nients de l'h&eacute;ritage


&lt;?php

class BoiteDeTucs 
{
    private array $authorizedFlavours = ['bacon', 'fromage', 'crème oignon', 'ail et fines herbes'];
    protected array $tucs = [];
    
    public function obtenirUnTuc()
    {
        if (empty($this->tucs)) {
            throw new RuntimeException('boite vide !');
        }
        
        return array_shift($this->tucs);
    }
    
    public function insererDesTucs(array $tucs) 
    {
        if (!empty($this->tucs)) {
            throw new RuntimeException('On fini la boite avant !');
        }
        
        $this->tucs = array_filter($tucs, fn ($tuc) => in_array($tuc, $this->authorizedFlavours));
    }
}


$boiteDeTucs = new BoiteDeTucs;
$boiteDeTucs->insererDesTucs(['bacon', 'barbecue', 'fromage', 'crème oignon']);

echo $boiteDeTucs->obtenirUnTuc().PHP_EOL; // bacon
echo $boiteDeTucs->obtenirUnTuc().PHP_EOL; // fromage, ouf pas de barbecue.


&lt;?php

class BoiteDeTucs 
{
    protected array $authorizedFlavours = ['bacon', 'fromage', 'crème oignon', 'ail et fines herbes'];
    protected array $tucs = [];
    
    public function obtenirUnTuc()
    {
        if (empty($this->tucs)) {
            throw new RuntimeException('boite vide !');
        }
        
        return array_shift($this->tucs);
    }
    
    public function insererdesTucs(array $tucs) 
    {
        if (!empty($this->tucs)) {
            throw new RuntimeException('On fini la boite avant !');
        }
        
        $this->tucs = array_filter($tucs, fn ($tuc) => in_array($tuc, $this->authorizedFlavours));
    }
}

class BoiteDeTucsTriFromage extends BoiteDeTucs
{
    public function obtenirUnTuc()
    {
        while ('fromage' === $tuc = parent::obtenirUnTuc()){
            $this->tucs[] = $tuc;
        }
        
        return $tuc;
    }
}


$boiteDeTucs = new BoiteDeTucsTriFromage;
$boiteDeTucs->insererdesTucs(['fromage', 'bacon', 'barbecue', 'crème oignon']);

echo $boiteDeTucs->obtenirUnTuc().PHP_EOL; // bacon
echo $boiteDeTucs->obtenirUnTuc().PHP_EOL; // crème oignon… Ouf, ni fromage ni barbecue


Pourquoi pr&eacute;f&eacute;rer la composition &agrave; l'h&eacute;ritage


Description du Liskov Substitution Principle


&lt;?php

interface LivingThingInterface {}
interface AnimalInterface extends LivingThingInterface {}

interface DogInterface extends AnimalInterface {}
interface PlantInterface extends LivingThingInterface {}


class Dog implements DogInterface {}

class Plant implements PlantInterface {}

class Pet
{
	public function __construct(AnimalInterface $animal) {}
}

class PetDog extends Pet
{
 	// Fonctionne
	public function __construct(DogInterface $dog)
	{
 		parent::__construct($dog);
	}
}

class PlantPet extends Pet
{
 	// Ne fonctionne pas
	public function __construct(PlantInterface $plant)
	{
 		parent::__construct($plant);
	}
}

&lt;?php

class LivingThing{}

class Plant extends LivingThing {}
class Animal extends LivingThing {}

class Cat extends Animal {}

interface AnimalShelter
{
	public function adopt(string $name): Animal;
}

class CatShelter implements AnimalShelter
{
 	// Fonctionne
	public function adopt(string $name): Cat
	{
 		return new Cat($name);
	}
}

class PlantShelter implements AnimalShelter
{
 	// Ne fonctionne pas
	public function adopt(string $name): Plant
	{
 		return new Plant($name);
	}
}


Note d&#8217;avant lecture : si des termes vous sont inconnus, mettez votre lecture en pause et allez vérifier leur signification avant de reprendre !



Dans <a href="https://api-platform.com/" target="_blank" rel="noreferrer noopener">API Platform</a>, mais aussi dans <a href="https://les-tilleuls.coop/technologies/symfony" target="_blank" rel="noreferrer noopener">Symfony</a> — et dans énormément de logiciels —, il est souvent recommandé de &#8220;décorer&#8221; pour étendre du code tiers. Dans API Platform, on nous propose de décorer les providers, les processors, les listeners, les resolvers, les factories… Pour un·e dev expérimenté·e, c&#8217;est trivial. Mais si vous découvrez le terme, ce n&#8217;est pas si évident.



Avant d&#8217;aborder le pattern, il faut comprendre la raison de son existence. Pour cela, il faut définir la différence (en POO) entre la composition et l&#8217;héritage.



<h2>Héritage</h2>



L&#8217;héritage est l&#8217;un des quatre concepts majeurs associés à la programmation orientée objet. Cela comprend l&#8217;abstraction, l&#8217;encapsulation, l&#8217;héritage et le polymorphisme. L&#8217;héritage nous permet d&#8217;acquérir des propriétés et des méthodes de la classe de base dans la classe dérivée (ou enfant). Les classes dérivées ont généralement une relation (logique) avec la classe de base.



<h3>Avantages de l&#8217;héritage&nbsp;</h3>



<ul><li>L&#8217;héritage permet la réutilisation du code, d&#8217;hériter facilement des fonctionnalités de la classe mère sans copier le code. </li><li>Elle fournit une structure hiérarchique claire qui nous permet de décomposer un modèle en une structure simple et facile à digérer.</li></ul>



<h3>Inconvénients de l&#8217;héritage</h3>



<ul><li>Les fonctions héritées sont plus lentes que les fonctions normales (sans parler de langage de programmation spécifiquement). </li><li>Toutes les variables ainsi que les méthodes de la classe de base sont héritées même si elles ne sont pas utilisées, cela provoque un surplus inutile. </li><li>De petits changements peuvent affecter toutes les classes dérivées de manière inattendue en raison du couplage étroit. </li><li>L&#8217;héritage a une structure définie au moment de la compilation : nous ne pouvons pas modifier quoi que ce soit dans les classes supérieures au moment de la &#8220;distribution&#8221; des méthodes et propriétés publiques ou protégées aux classes dérivées. Les détails de la classe mère sont exposés à la classe fille et cela brise le concept fondamental d&#8217;encapsulation (à savoir &#8220;cacher&#8221;, &#8220;garder privées&#8221; des propriétés et méthodes, pour maîtriser leurs contenus et leurs actions).</li></ul>



<meta charset="utf-8">Pour faire une analogie, si je pose des Tucs sur la table pour chacun·e avec 1 Tuc par personne. Sans surveillance, après le passage de 2 ou 3 gourmand·e·s, il n&#8217;y en a plus pour les autres. Alors je dépose les Tucs dans un distributeur (ce serait une classe) qui se charge de vérifier qu&#8217;un seul soit distribué à chacun. Personne ne peut en prendre directement. J&#8217;ajoute un accesseur `<code>obtenirUnTuc</code>`. Une fois vide cependant, je ne peux plus renouveler le stock. Alors je rajoute aussi un mutateur `<code><meta charset="utf-8">insererDesTucs</code>`.



Est-ce suffisant ? Non ! Je viens de laisser la possibilité d&#8217;ajouter des Tucs barbecue ! Tragédie, ils ne sont pas bons ! Alors mon mutateur sera aussi responsable de contrôler la qualité des Tucs insérés.





Nous avons correctement protégé l&#8217;accès et l&#8217;ajout des Tucs ! 



Si une implémentation d&#8217;une classe est parfaite d&#8217;un point de vue encapsulation, et si des changements sont appliqués sur cette classe, aucun changement ne sera nécessaire dans les classes qui en héritent. Seulement dans les faits, dès lors que je vais étendre la boite de Tucs, ma nouvelle classe aura connaissance de toutes les propriétés et méthodes publiques comme protégées.



Disons que je n&#8217;ai pas envie des Tucs au fromage aujourd&#8217;hui et que je souhaite faire le tri :





Imaginons que la marque distributrice de ces biscuits décide de remplacer la gamme fromage par 3 variations : beaufort, comté et chèvre. Lorsque je vais mettre à jour ma `<code>BoiteDeTucs</code>`, je vais être obligé de modifier ma `<meta charset="utf-8"><code>BoiteDeTucsTriFromage</code>` : l&#8217;héritage a rompu le contrat d&#8217;encapsulation.



<h2>Composition</h2>



Dans la composition, l&#8217;une des classes possède une ou plusieurs instances d&#8217;autres classes souvent obtenues en les passant au constructeur.



<h3>Avantages de la composition</h3>



<ul><li>Les dépendances sont moindres par rapport à l&#8217;héritage, l&#8217;idée étant de surtout s&#8217;appuyer sur des arguments typés à l&#8217;aides d&#8217;interfaces pour être le plus versatile et résilient possible dans le futur. </li><li>Les objets sont définis au moment de l&#8217;exécution, ils n&#8217;ont pas la possibilité d&#8217;accéder aux données protégées d&#8217;un autre objet : cela permet de maintenir l&#8217;encapsulation.</li></ul>



<h3>Inconvénients de la composition</h3>



<ul><li>Elle nécessite plus de temps et produit un code plus verbeux.</li><li>Le système est dépendant de l&#8217;interrelation entre les objets.</li><li>Un bon découpage pour conserver en souplesse tout en assurant l&#8217;évolutivité du code sans avoir à faire de profonde restructuration est difficile : il faut passer un peu de temps en amont à étudier les possibilités de structures, de design pattern, pour faire le choix optimal.</li></ul>



<h2>Pourquoi préférer la composition à l&#8217;héritage</h2>



La composition est un concept de programmation orientée objet qui stipule que les classes doivent avoir un comportement <a href="https://fr.wikipedia.org/wiki/Polymorphisme_(informatique)" target="_blank" rel="noreferrer noopener">polymorphe</a> (on parle surtout ici de surcharge de méthode, ce qui n&#8217;est pas possible en PHP par exemple). Cela rend le tout plus flexible, plus facile à maintenir malgré un code plus important au départ. C&#8217;est à cela que l&#8217;on doit le dicton “<a href="https://en.wikipedia.org/wiki/Composition_over_inheritance" target="_blank" rel="noreferrer noopener">Favoriser la composition d&#8217;objets plutôt que l&#8217;héritage de classes</a>”.



L&#8217;héritage est un outil puissant. S&#8217;il est bien utilisé, il peut rendre votre code compact, facile à lire et rapide à développer mais il existe de nombreux pièges dans lesquels une personne peut facilement tomber. Des changements minimes peuvent avoir des conséquences désastreuses comme vu plus haut. C&#8217;est pour cela qu&#8217;en règle générale, on opte plutôt pour la composition.



<h2>Quand hériter ou non ?</h2>



Voyons ensemble quelques règles de typage en POO et les limites qu&#8217;elles imposent. Avec celles-ci en tête, vous serez capable de déceler les situations dans lesquelles hériter n&#8217;est pas une bonne solution.



Connaissez-vous Barbara Liskov ? Elle a produit une publication nommée “A behavioral notion of subtyping” où elle formalise le Liskov Substitution Principle, un des principes <a href="https://fr.wikipedia.org/wiki/SOLID_(informatique)" target="_blank" rel="noreferrer noopener">SOLID</a>. Je vous encourage à étudier ces principes (ainsi que <a href="https://fr.wikipedia.org/wiki/Loi_de_D%C3%A9m%C3%A9ter" target="_blank" rel="noreferrer noopener">la loi de Déméter</a>).



<h3>Description du Liskov Substitution Principle</h3>



Si S est un sous-type de T, alors les objets de type T dans un programme peuvent être remplacés par des objets de type S sans altérer aucune des propriétés de ce programme.



Le principe de substitution de Liskov impose certaines exigences sur les signatures de méthodes dans les langages de POO. Parmi elles, deux notions que nous allons détailler :



<ul><li>Le respect de la contravariance des types de paramètres de méthode dans le sous-type.</li><li>Le respect de la covariance des types de retour des méthodes dans le sous-type.</li></ul>



<h3>Covariance et Contravariance</h3>



De nombreux langages de programmation prennent en charge le sous-typage. Par exemple, si le type Chat est un sous-type de Animal, un élément de type Chat devrait être accepté partout où un élément de type Animal est utilisé.



La variance fait référence à la manière dont le sous-typage entre des types plus complexes est lié au sous-typage entre leurs composants. Par exemple, comment une liste de chats doit-elle s&#8217;identifier comme une liste d&#8217;animaux ? Ou comment une fonction qui renvoie un chat doit-elle s&#8217;identifier à une fonction qui renvoie un animal ? Ces phrases sont complexes, et rien ne vaut un exemple par la pratique pour s&#8217;approprier la règle.



<h4>Exemple de contravariance en PHP</h4>





<code>DogInterface</code> hérite de <code>AnimalInterface</code>, l&#8217;héritage tolère ce changement de type, c&#8217;est la contravariance. S sous type de T -&gt; S étant DogInterface et T étant AnimalInterface.



<code>PlantInterface</code> hérite de <code>LivingThingInterface</code>, tout comme <code>Animal</code>. Cependant <code>PlantInterface</code> n&#8217;est pas un sous type de <code>AnimalInterface</code>, c&#8217;est un sous type de <code>LivingThingInterface</code>.



Considérons-le comme un cousin. L&#8217;héritage refusera ce changement de type.



<h3>Un exemple de covariance en PHP</h3>





<code>Cat</code> hérite de <code>Animal</code>, l&#8217;héritage tolère ce changement de type, c&#8217;est la contravariance. S sous type de T -&gt; S étant Cat et T étant Animal.



<code>Plant</code> hérite de <code>LivingThingInterface</code>, tout comme <code>Animal</code>. Cependant <code>Plant</code> n&#8217;est pas un sous type de <code>Animal</code>. C&#8217;est un sous type de <code>LivingThing</code>.



Considérons-le comme un cousin. L&#8217;héritage refusera ce changement de type. On remarquera que par l&#8217;évidence des noms utilisés, il semble étrange d&#8217;avoir classé <code>Plant</code> sous <code>Animal</code>, mais ce n&#8217;est pas toujours aussi flagrant. Une meilleure structure aurait été de tout faire découler de LivingThing.



Aussi, de nouvelles exceptions ne devraient pas être lancées par les méthodes du sous-type, sauf si elles sont des sous-types d&#8217;exceptions lancées par les méthodes du super-type. Vous commencez à voir les limites de l&#8217;héritage !



Il y a un moment où dans nos structures, ces relations entrent en conflit avec ce que l&#8217;on souhaite accomplir. Alors, plutôt que d&#8217;hériter pour ajouter des comportements, cela devient plus clair en créant des classes qui font juste ce qui est désiré et de les injecter aux classes qui ont besoin de ce comportement. En prime, ces classes pourront plus facilement être utilisées.



La composition prend beaucoup plus de sens, d&#8217;accord. Et la décoration dans tout ça ?



<h2>Le pattern</h2>



Admettons que nous ayons utilisé de la composition dans notre code. Parmi les principes SOLID se trouve aussi le O pour Open/Closed Principle. Ce principe dit ceci : les entités logicielles (classes, modules, fonctions, etc.) devraient être ouvertes à l&#8217;extension, mais fermées à la modification. C&#8217;est-à-dire qu&#8217;une telle entité peut permettre d&#8217;étendre son comportement sans modifier son code source.



Comment ajouter un comportement à une classe, mais sans toucher à son interface et ses signatures, sans lui ajouter de nouvelles méthodes ? C&#8217;est envisageable d&#8217;hériter et de surcharger, mais nous ne voulons pas retomber dans les limites que nous avons vues plus haut. Alors on compose. On compose en décorant !



Un décorateur est une classe. C&#8217;est une classe qui expose la ou les mêmes interfaces que la classe qu&#8217;il décore, qu&#8217;il veut étendre. Ce n&#8217;est pas suffisant bien entendu, pour compléter la décoration, il va falloir passer une instance de la classe décorée à la classe qui la décore, souvent via son constructeur. L&#8217;image la plus répandue pour visualiser l&#8217;opération est celle des poupées russes s&#8217;imbriquant les unes dans les autres. On parle aussi d&#8217;onion architecture.



<h3>Un exemple avec PHP</h3>





N&#8217;hésitez pas à jouer avec cet exemple, à le triturer pour bien appréhender la mécanique. Par exemple, amusez-vous à ajouter un <code>CollarOptionCatShelter</code> qui met un collier à son nom au chat lorsque vous payez plus cher.



Et tentez de décorer <code>CatShelter</code>, et/ou <code>BetterCatShelter</code>.



<h3>Application du pattern avec les services de Symfony</h3>



Dans Symfony toutes les classes enregistrées comme service sont décorables. Dans la version 6.1 du framework voici comment s&#8217;y prendre (traduit de la documentation : <a href="https://symfony.com/blog/new-in-symfony-6-1-service-decoration-attributes" target="_blank" rel="noreferrer noopener">https://symfony.com/blog/new-in-symfony-6-1-service-decoration-attributes</a>). Vous pouvez aussi vous référer au talk de notre coopérateur Robin : <a href="https://slides.com/chalasr/symfonybc-promise-demystifed/" target="_blank" rel="noreferrer noopener">https://slides.com/chalasr/symfonybc-promise-demystifed/</a>. 



Considérons le cas courant où vous voulez décorer un service (par exemple <code>Mailer</code>) avec un nouveau service qui lui ajoute des capacités de log (par exemple <code>LoggingMailer</code>). Voici comment vous pouvez configurer la décoration avec des attributs PHP :



Les deux classes devront implémenter une interface commune. Ici <code>MailerInterface.</code>





L&#8217;attribut `<code>#[AsDecorator]</code>` prend en charge toutes les options supplémentaires dont vous pourriez avoir besoin :





Si vous devez accéder au service décoré à l&#8217;intérieur du service décorateur, ajoutez l&#8217;attribut `<code>#[MapDecorated]</code>` à l&#8217;un des arguments du constructeur du service :





<blockquote class="wp-block-quote">Attention à ne pas décorer un service servant d&#8217;Alias dans Symfony, pour éviter de chercher pourquoi le code ne fonctionne pas. L&#8217;injection de dépendance de Symfony ne supporte pas encore la décoration d&#8217;Alias.<cite>De la part de Baptiste, Antoine, Vincent, Robin, Moi-même&#8230; (et tout ceux qui s&#8217;y sont frotté)</cite></blockquote>



J&#8217;espère que ce concept est un peu plus clair pour vous maintenant. Pour votre veille personnelle, n&#8217;hésitez pas également à consulter <a href="https://symfony.com/doc/current/service_container/service_decoration.html" target="_blank" rel="noreferrer noopener">ce billet de Symfony</a> sur les différentes façons de décorer un service. Bon code à vous !

Maîtrisez votre app avec le pattern decorator

Apprenez le pattern decorator, gagnez en maîtrise dans votre application développée avec API Platform.

Apprenez le pattern decorator et gagnez en maitrise dans votre application Symfony.

Maîtrisez votre app avec le pattern decorator | Les-Tilleuls.coop

En 2022, le Forum PHP nous emm&egrave;ne dans un autre univers


Nous sommes ravi·e·s de retrouver l&#8217;AFUP et la communauté PHP francophone la semaine prochaine au <a href="https://event.afup.org/" target="_blank" rel="noreferrer noopener">Forum PHP 2022</a> en tant que sponsor Or de l&#8217;événement. Deux jours de conférences inédites sont attendus <a href="https://www.disneylandparis.com/fr-fr/hotels/disneys-hotel-new-york/" target="_blank" rel="noreferrer noopener nofollow">l&#8217;Hôtel New York The Art of Marvel à Disneyland Paris</a>, les 13 et 14 octobre. 



<center><blockquote class="twitter-tweet">Toujours fidèles à la communauté PHP, à l&#8217;AFUP et à ses événements, <a href="https://twitter.com/coopTilleuls?ref_src=twsrc%5Etfw">@coopTilleuls</a> nous feront encore une fois le plaisir de nous suivre, lors du Forum PHP 2022 : on a hâte de vous retrouver. ?<a href="https://t.co/NkVnEwjYNd">https://t.co/NkVnEwjYNd</a>, sponsor Or du Forum PHP 2022 &#8211; 13&amp;14/10, Disneyland Paris <a href="https://t.co/bqb6AtYFF8">pic.twitter.com/bqb6AtYFF8</a>— AFUP (@afup) <a href="https://twitter.com/afup/status/1536241961501270016?ref_src=twsrc%5Etfw">June 13, 2022</a></blockquote> <script async="" src="https://platform.twitter.com/widgets.js" charset="utf-8"></script><center></center></center>



<h2>Un programme haut en couleurs</h2>



PHP sera encore une fois un langage bien représenté. De multiples intervenantes et intervenants se succèderont pour partager leurs connaissances et accompagner la montée en compétences de 800 auditrices et auditeurs. Cerise sur le gâteau, nous avons 3 coopérateurs parmi les speakers !



<center> <blockquote class="twitter-tweet">J’aurai encore une fois l’honneur de parler au <a href="https://twitter.com/hashtag/ForumPHP?src=hash&amp;ref_src=twsrc%5Etfw">#ForumPHP</a> ! Le programme est top ?. Merci à toute l’équipe de l’<a href="https://twitter.com/afup?ref_src=twsrc%5Etfw">@afup</a> pour le boulot, on se voit chez Mickey ! <a href="https://t.co/a4QGsaZHZ5">https://t.co/a4QGsaZHZ5</a> <a href="https://t.co/A55NZSy033">pic.twitter.com/A55NZSy033</a>— Kévin Dunglas (@dunglas) <a href="https://twitter.com/dunglas/status/1544383257734746113?ref_src=twsrc%5Etfw">July 5, 2022</a></blockquote> <script async="" src="https://platform.twitter.com/widgets.js" charset="utf-8"></script><center></center></center>



<a href="https://twitter.com/matarld" target="_blank" rel="noreferrer noopener">Mathias Arlaud </a>nous accompagnera dans la découverte du sens d&#8217;un texte avec ElasticSearch avec sa conférence : &#8220;De l&#8217;humain à l&#8217;ordinateur, ou découvrir le sens d&#8217;un texte avec ElasticSearch.&#8221; Il a profité de sa sélection pour répondre aux questions de l&#8217;AFUP lors d&#8217;une récente interview, découvrez-là : <a href="https://event.afup.org/forumphp2022-interview-mathias-arlaud/" target="_blank" rel="noreferrer noopener">https://event.afup.org/forumphp2022-interview-mathias-arlaud/</a>. De son côté, <a href="https://twitter.com/dunglas" target="_blank" rel="noreferrer noopener">Kévin Dunglas</a> présentera le talk &#8220;FrankenPHP, dans les entrailles de l&#8217;interpréteur PHP, de machines virtuelles et des threads.&#8221; Son interview est disponible à cette adresse : <a href="https://event.afup.org/forumphp2022-interview-kevin-dunglas/" target="_blank" rel="noreferrer noopener">https://event.afup.org/forumphp2022-interview-kevin-dunglas/</a>. Enfin, Robin Chalas rejoint le pool de speakers avec le talk &#8220;<a href="https://event.afup.org/forum-php-2022/programme/#4037" target="_blank" rel="noreferrer noopener nofollow">Sortir du cadre</a>&#8220;. 



<center><blockquote class="twitter-tweet">Nous avons le plaisir d&#8217;annoncer la venue de <a href="https://twitter.com/chalas_r?ref_src=twsrc%5Etfw">@chalas_r</a> au Forum PHP 2022, pour un talk intitulé &#8220;Sortir du cadre&#8221; ! Il interviendra sur le créneau de 11h40 le vendredi, en lieu et place de la conférence de Tomas Votruba, qui ne peut pas nous rejoindre. ▶️ <a href="https://t.co/QEz9GlHfwd">https://t.co/QEz9GlHfwd</a> <a href="https://t.co/kg163VW2dc">pic.twitter.com/kg163VW2dc</a>— AFUP (@afup) <a href="https://twitter.com/afup/status/1576829408085770240?ref_src=twsrc%5Etfw">October 3, 2022</a></blockquote> <script async="" src="https://platform.twitter.com/widgets.js" charset="utf-8"></script></center>



<h2>En 2022, le Forum PHP nous emmène dans un autre univers</h2>



Nous étions déjà habitué·e·s à assister à des événements très qualitatifs avec l&#8217;AFUP (n&#8217;oublions pas que l&#8217;association, en complément d&#8217;une salariée, est gérée par des bénévoles sur leur temps libre), en rejoignant le parc de Disneyland l&#8217;association montre à quel point elle est capable de créer des conventions de grande envergure. Nous avons, pour notre part, hâte d&#8217;y être. Prenez au plus tôt <a href="https://afup.org/event/afupday2022lille/tickets" rel="noreferrer noopener nofollow" target="_blank">votre billet</a>, la billetterie ferme dans quelques jours !

Les-Tilleuls.coop sponsor et speaker du Forum PHP 2022

Nous rejoignons à nouveau l'AFUP dans le cadre du Forum PHP 2022, prévu les 13 et 14 octobre à Disneyland Paris.

Les-Tilleuls.coop sponsor et speaker du Forum PHP 2022 | Les-Tilleuls.coop

https://secure.gravatar.com/avatar/5f74ccf442f27a3c41d1ab21d11e8900?s=96&d=mm&r=g

Une transformation e-commerce acc&eacute;l&eacute;r&eacute;e par le Cloud et le DevOps, Maxime Drouet &amp; Quentin Tshaimanga


Vous voulez sauver la plan&egrave;te? Utilisez DailyClean une application open source r&eacute;alis&eacute;e avec Quarkus, Guillaume Thomas


Les op&eacute;rateurs Kubernetes &agrave; la port&eacute;e de n'importe quel d&eacute;veloppeur, St&eacute;phane Philippart


Le GitOps par la pratique, une introduction &agrave; FluxV2, Cl&eacute;ment Loiselet &amp; Isma&euml;l Hommani


Votre base de donn&eacute;es comme vous ne l'avez jamais vue, Lo&iuml;c Knuchel


Retrouvez la première partie de <a href="https://les-tilleuls.coop/blog/retour-sur-cloud-nord-2022-premiere-partie" target="_blank" rel="noreferrer noopener">notre compte-rendu ici</a>. 



<h2>Vous voulez sauver la planète? Utilisez DailyClean une application open source réalisée avec Quarkus, Guillaume Thomas</h2>



<a href="https://github.com/AxaGuilDEv/dailyclean" target="_blank" rel="noreferrer noopener">DailyClean</a> est une app permettant d’éteindre ponctuellement ou de manière planifiée des environnements Kubernetes. Une API tourne dans chaque namespace et il peut également y avoir un front. Ce front met en page l’ensemble des déploiements présents dans chaque namespace, avec le statut, le nombre de réplica et une estimation des coûts.&nbsp;On peut également y planifier des jours et des heures d’extinctions et d’allumage. Cette planification va créer un cronjob qui va communiquer avec l’API Kube afin d’éteindre les déploiements.&nbsp;



Une future fonctionnalité sera de pouvoir ajouter des labels sur les déploiements qui ne doivent pas être affectés par DailyClean. C’est également un outil qui est intéressant de coupler avec flux afin de garder la persistance des configurations des déploiements.&nbsp;



<h2>Votre base de données comme vous ne l&#8217;avez jamais vue, Loïc Knuchel</h2>



Talk intéressant de Loïc Knuchel qui nous a présenté <a href="https://azimutt.app/" target="_blank" rel="noreferrer noopener nofollow">Azimutt.app</a>. Azimutt est un outil qui permet d’explorer et d’organiser visuellement les tables des base de données SQL sous la forme de <a href="https://fr.wikipedia.org/wiki/Mod%C3%A8le_entit%C3%A9-association" target="_blank" rel="noreferrer noopener nofollow">diagrammes entité-association</a> (ERD).



Il s’avère particulièrement utile pour découvrir les grosses bases de données et les bases de données “legacy”. Azimut a d’abord été développé pour les besoins de Doctolib et est maintenant disponible pour tous sous licence libre (MIT).



<figure class="wp-block-image size-medium is-style-rounded"><img decoding="async" loading="lazy" width="600" height="555" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38-600x555.png" alt="" class="wp-image-5634" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38-600x555.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38-1024x948.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38-300x278.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38-768x711.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/09/Capture-décran-2022-09-30-à-14.47.38.png 1422w" sizes="(max-width: 600px) 100vw, 600px" /></figure>



Loïc nous a présenté les (nombreuses !) fonctionnalités de l’outil et ses avantages par rapport aux solutions pré-existantes. Cerise sur le gâteau, Azimut est développé avec Elixir et Elm.



<h2>Une transformation e-commerce accélérée par le Cloud et le DevOps, Maxime Drouet &amp; Quentin Tshaimanga</h2>



Maxime et Quentin sont revenus sur la migration menée par La Redoute d’un hébergement classique on premise vers <a href="https://cloud.google.com/?hl=fr" target="_blank" rel="noreferrer noopener">Google Cloud Platform</a>.



Cette conférence très intéressante expliquait les succès (plus grande stabilité, passage à l’échelle amélioré, pas d&#8217;incidences lors de pics de traffic), mais aussi les limites et petits désagréments liés à une telle externalisation.



<h2>Les opérateurs Kubernetes à la portée de n&#8217;importe quel développeur, Stéphane Philippart</h2>



Stéphane nous a présenté ce qu’est un opérateur, qui se compose à la fois d’une CustomResourceDefinition (CRD), de l’API associée, de CustomResources (CR), et d’un controller. Il y a généralement un contrôleur par CRD, bien qu’il soit possible de contrôler plusieurs CRD depuis le même contrôleur, mais cela complique la logique et la maintenabilité. Les opérateurs peuvent intervenir sur plusieurs périmètres. Les plus courants sont l’installation, la désinstallation et la mise à jour d’une application. Pour des usages plus avancés, les opérateurs interviennent également dans la sauvegarde et la restauration, l&#8217;auto-configuration, l&#8217;observabilité et la scalabilité.



Il existe de nombreux frameworks pour créer son opérateur. Ceux-ci nous permettent de nous concentrer sur notre métier en implémentant nativement, entre autres, la boucle de réconciliation. Le plus connu d’entre eux est <a href="https://sdk.operatorframework.io/" target="_blank" rel="noreferrer noopener">Operator SDK</a>, qui permet de développer un opérateur avec 3 langages différents : HELM, Ansible ou Go. L’opérateur HELM n’apporte pas grand chose par rapport à l’utilisation directe de HELM, mais permet de facilement migrer ses charts sous forme d’opérateurs pour homogénéiser le déploiement de ces applications par rapport aux autres opérateurs qu’on pourrait avoir. Cela simplifie aussi l’expérience utilisateur : on ne modifie plus que les values du chart via le CustomResource, en masquant tout le reste des manifests YAML. Stéphane nous a ensuite montré quelques exemples, en Go ou en Java.



Une attention particulière a été portée sur la gestion des finalizers : ils permettent de réveiller l’opérateur en cas de suppression d’un objet. L’opérateur va pouvoir effectuer des actions pour correctement terminer l’application, puis enlever le finalizer, ce qui va permettre à Kubernetes d’effectivement supprimer l’objet. Il est donc important de créer ou supprimer les finalizers au bon moment, pour éviter de se retrouver bloqué.



<h2>Le GitOps par la pratique, une introduction à FluxV2, Clément Loiselet &amp; Ismaël Hommani</h2>



Clément et Ismaël nous ont proposé une initiation à <a href="https://github.com/fluxcd/flux2" target="_blank" rel="noreferrer noopener">FluxV2</a>, un outil intéressant pour mettre en place une démarche GitOps dans son organisation. Ils sont revenus sur les principes mêmes qui sous-tendent que cette démarche généralement mal comprise, y compris parfois dans le métier. Le GitOps est en effet trop souvent assimilé à une simple CI/CD alors que le paradigme est assez différent. Il s’agit en fait de découpler complètement la CI et la CD.



Le GitOps fonctionne sur un mode déclaratif qu’on retrouve aussi chez Kubernetes, ce qui leur fait d’ailleurs dire que cet orchestrateur est le seul du genre à pouvoir entrer dans la catégorie des outils GitOps. En effet, il ne s’agit pas de décrire de façon impérative les ressources nécessaires pour un cluster, mais à énoncer une volonté que FluxV2 aura alors à sa charge de mettre en œuvre sur un cluster à l’aide d’une boucle de réconciliation. Le dépôt git devient alors la source unique de vérité quand il s’agit de décrire un cluster et ses ressources.



Ils voient dans ce type d’outil GitOps de nombreux intérêts :



<ul><li>Une agilité dans la gestion des cibles de déploiements : il n’est plus nécessaire de donner d’accès à la CI sur les clusters,</li><li>Une exposition de l’état des clusters à des profils non techniques</li><li>La possibilité d’agir dès la CI sur la qualité et la conformité des ressources</li><li>Faciliter le multi-cluster en mutualisant des configurations déployées automatiquement sur de nombreux clusters</li><li>Une meilleure collaboration des devs et des ops, les devs pouvant ouvrir des PR reviewées par les ops</li></ul>



L’effort pédagogique des deux intervenants était très appréciable, il y avait une vraie volonté de transmission du savoir. Le workshop était assez dense mais on peut retrouver toutes les instructions sur le <a href="https://github.com/kalioz/fluxv2-demo" target="_blank" rel="noreferrer noopener">dépôt Github</a> qui est de fait une excellente ressource pour quiconque veut s’initier à la démarche GitOps. FluxV2 est un outil utilisé au quotidien chez Les-Tilleuls.coop et ce workshop nous a confortés techniquement et stratégiquement dans ce choix. 







Nous avons passé une excellente journée à Euratechnologies, que nous retrouvions deux semaines après avoir organisé <a href="https://les-tilleuls.coop/blog/api-platform-con-2022-resume-partie-1" target="_blank" rel="noreferrer noopener">la API Platform Con 2022</a>. Cet événement était l&#8217;occasion pour nous de présenter <a href="https://les-tilleuls.coop/blog/rencontre-equipe-sre" target="_blank" rel="noreferrer noopener">notre équipe SRE</a> (qui s&#8217;est agrandie récemment avec l&#8217;arrivée de Hugo Moubèche), et de présenter à la communauté notre toute <a href="https://les-tilleuls.coop/cloud-et-devops" target="_blank" rel="noreferrer noopener">nouvelle offre Cloud</a>. En effet, en addition à nos expertises et contributions reconnues, nous proposons désormais un accompagnement dans la gestion, le maintien et la sécurisation des infrastructures. N&#8217;hésitez pas à <a href="mailto:contact@les-tilleuls.coop" target="_blank" rel="noreferrer noopener">nous contacter</a> pour en savoir plus ! Bravo à l&#8217;équipe d&#8217;organisation de Cloud Nord pour cette journée qui s&#8217;est terminée par un atelier houblonné au sein de l&#8217;Atrium. Comptez sur notre présence l&#8217;année prochaine !

Retour sur Cloud Nord 2022 (deuxième partie)

Voici la seconde partie de notre compte-rendu du Cloud Nord 2022, un événement organisé le 29 septembre dernier à Euratechnologies.

Retour sur Cloud Nord 2022 (deuxième partie) | Les-Tilleuls.coop

C&rsquo;est quoi la Cloud Platform Engineering chez Decathlon, Christophe Furmaniak 


Parce qu'il est souvent question de taille... pour les microservices, Jean-R&eacute;my Revy 


Cr&eacute;er et distribuer un plugin pour Kubernetes en quelques minutes ? Easy ! Aur&eacute;lie Vache et Ga&euml;lle Acas


Le 29 septembre dernier, une partie de notre équipe a assisté à <a href="https://www.cloudnord.fr">Cloud Nord</a>, le rendez-vous lillois des experts du Cloud et technologies Ops. Cet événement où nous étions exposants nous a permis de rencontrer la communauté locale et de lui présenter <a href="https://les-tilleuls.coop/cloud-et-devops" target="_blank" rel="noreferrer noopener">notre toute nouvelle offre de services</a> dédiés à l’infra. Entre moments conviviaux et conférences innovantes, passons en revue les temps forts de cette journée.



<h2>Keynote d&#8217;ouverture, Quentin Adam</h2>



<a href="https://twitter.com/waxzce" target="_blank" rel="noreferrer noopener">Quentin Adam</a>, le boss du PAAS français Clever Cloud, revient sur un sujet qui nous tient à cœur chez Les-Tilleuls.coop : <a href="https://www.youtube.com/watch?v=k6DNqGnXFgY" target="_blank" rel="noreferrer noopener">la centralisation d’Internet et son contrôle par quelques mastodontes de la tech</a>, quasiment tous californiens.



La tech &#8211; et en particulier le logiciel &#8211; est devenue le moteur de l’économie mondiale : toute l’économie réelle en dépend maintenant très fortement. C’est LA branche d’industrie qui génère le plus de profits.



<div class="wp-block-image is-style-rounded"><figure class="aligncenter size-full"><img decoding="async" loading="lazy" width="600" height="314" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/10/Capture-decran-2022-09-30-a-11.23.01-600x314-1.png" alt="" class="wp-image-5674" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/10/Capture-decran-2022-09-30-a-11.23.01-600x314-1.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/10/Capture-decran-2022-09-30-a-11.23.01-600x314-1-300x157.png 300w" sizes="(max-width: 600px) 100vw, 600px" /></figure></div>



Problème : la tech est aussi devenue le nouveau symbole de l’impérialisme états-unien. Les infrastructures numériques modernes sont contrôlées par quelques quelques ultra-riches californiens qui s’enrichissent grâce au capitalisme de surveillance, aux fake news, à des pratiques monopolistiques et surtout en captant l’essentiel de la valeur produite par les travailleuses et travailleurs du monde entier. Leurs pratiques sont tellement néfastes qu’elles mettent en danger les fondements mêmes de nos sociétés et font peser un risque de basculement totalitaire. Quentin résume bien la situation : «Ce sont des fumiers et ils font ce qu’ils veulent.»



Les Big Tech sont devenues tellement riches et puissantes que même les amendes qu’elles sont (trop rarement) condamnées à payer (<a href="https://www.lemonde.fr/pixels/article/2022/09/14/concurrence-google-echoue-a-faire-annuler-une-amende-record-devant-la-justice-europeenne_6141575_4408996.html" target="_blank" rel="noreferrer noopener">Google</a>, <a href="https://www.lebigdata.fr/zoom-amende-donnees-utilisateurs" target="_blank" rel="noreferrer noopener">Zoom</a>, <a href="https://www.cnil.fr/fr/cookies-sanction-de-60-millions-deuros-lencontre-de-facebook-ireland-limited" target="_blank" rel="noreferrer noopener">Facebook</a>, …) n’ont aucun impact sur elles : ils provisionnent de quoi les payer, et profite ensuite du marché qu’ils ont capté illégalement pour s’assurer un domination pérenne.



Quentin présente un début de solution : son association l’<a href="https://www.openinternetproject.eu/" target="_blank" rel="noreferrer noopener">Open Internet Project</a> fait du lobbying auprès de l’Union Européenne et des gouvernements européens pour mettre en place des lois plus agressives visant particulièrement les GAFAM.



Plus précisément, Quentin propose la mise en place de mesures conservatoires qui devront permettre de bloquer les pratiques délétères de ces sociétés sans attendre les procès qui arrivent toujours trop tard, quand ces multinationales se sont déjà accaparé tout le marché et que leurs concurrents sont déjà morts.



Quentin conclut en rappelant que les Big Tech de la vallée ont été créés par des ingénieurs, pas par des commerciaux ni par des spécialistes du marketing. Il dit qu’il est temps qu’en France et en Europe aussi ce soient les ingénieurs qui prennent le pouvoir.



Pourquoi pas, mais faisons-le <a href="https://onestla.tech" target="_blank" rel="noreferrer noopener">sur des bases plus saines</a> !



<h2>C’est quoi la Cloud Platform Engineering chez Decathlon, Christophe Furmaniak </h2>



La (Cloud) Platform Engineering, c’est concevoir et construire des outils et des processus qui facilitent la mise à disposition d&#8217;infrastructures en mode libre service. Son grand principe : traiter une plateforme comme un produit en se focalisant sur une problématique commune. Dans les grandes entreprises, nombreux sont les projets gérés par différentes équipes. Autrefois, les infrastructures utilisées pour déployer ces projets étaient différentes car faites par des ops d’équipes différentes, chacun implémentant différemment en fonction de leurs connaissances et de leurs façons de faire. L’idée est donc d’harmoniser les différentes pratiques afin d’avoir une mise en commun des process pour la mise en place d’infrastructures, quel que soit le type de projet. Cela permet de mettre en place rapidement des nouveaux projets. L’outil interne de chez Decathlon permet en 15/20min de déployer un projet sur un cluster k8s, ayant des normes de sécurité communes, mettant tout en place des repository, à la CI, au déploiement, en passant par un fichier de configuration yaml. Ce projet permet un certain niveau de granularité :



<ul><li>Bas niveau : fourniture d’enveloppe Cloud</li><li>Entre deux : on sélectionne les services et on les configure</li><li>Haut niveau : les services sont sélectionnés, tout est configuré</li></ul>



On y trouve une promesse utilisateur (aussi bien pour un Ops ou un dev) : l’outil ne nécessite pas d’écriture de code Terraform ou Python mais une infrastructure en mode déclaratif (YAML). Tout est ensuite déployé sur GCP.&nbsp;



<h2>Parce qu&#8217;il est souvent question de taille&#8230; pour les microservices, Jean-Rémy Revy </h2>



Jean-Rémy démarre sa conférence en nous demandant de répondre à un questionnaire afin de connaître nos connaissances sur les microservices.&nbsp;



À la question “C’est quoi la bonne taille d’un microservice ?” plusieurs réponses apparaissent dont “1 microservice pour 1 base de données&#8221;. Cette éventuelle réponse est fausse : une base de 3000 tables ne peut pas représenter un microservice.&nbsp;



Il demande aussi s’il faut une équipe projet de 5 à 8 personnes pour un microservice. Non plus. 1 microservice pour 1 contexte borné ? On s’en rapproche, mais cette réponse reste floue. On se penche alors sur l’article de psychologie de <a href="https://fr.wikipedia.org/wiki/George_Armitage_Miller" target="_blank" rel="noreferrer noopener">George Armitage Miller</a> qui précise que la mémoire à court terme, permet de retenir 7 choses +/- 2. Un microservice pourrait être architecturé de la même manière en considérant qu’un microservice est un ensemble de 5 +/- 2 agrégats par tables. Cela permettrait d’avoir un temps ROI rapide et une maintenabilité accrue.&nbsp;



En résumé de cette conférence, un microservice est donc un service se centrant sur un sujet.&nbsp;



Lors de la séance de questions-réponses, Jean-Rémy rappelle que l’architecture microservice introduit de la complexité et n’est pas toujours la panacée. Découper trop fin est commun, et choisir la bonne granularité n’a rien d’évident : cela demande compétence, expérience et connaissance fine du métier (les méthodologies type <a href="https://fr.wikipedia.org/wiki/Conception_pilot%C3%A9e_par_le_domaine" target="_blank" rel="noreferrer noopener">DDD</a> sont d’un grand secours concernant ce dernier point). Les microservices ne sont pas une solution miracle, ils répondent à certains besoins, mais les <a href="https://m.signalvnoise.com/the-majestic-monolith/" target="_blank" rel="noreferrer noopener">monolithes majestueux</a> bien architecturés peuvent aussi être une bonne solution, souvent moins complexe. Ils peuvent aussi suivre des approches type Clean Architecture, architecture hexagonale etc… sans rajouter la complexité induite par la bordure réseau séparant les microservices.



Jean-Rémy rappelle que souvent, pour un applicatif orienté données, une application <a href="https://fr.wikipedia.org/wiki/CRUD" target="_blank" rel="noreferrer noopener">CRUD</a> sera plus adaptée qu’un système complexe basé sur les microservices.







<h2>Créer et distribuer un plugin pour Kubernetes en quelques minutes ? Easy ! Aurélie Vache et Gaëlle Acas</h2>



<a href="https://twitter.com/aurelievache" target="_blank" rel="noreferrer noopener">A</a><a href="https://twitter.com/aurelievache" target="_blank" rel="noreferrer noopener">urélie</a> et <a href="https://twitter.com/Gaelleacas" target="_blank" rel="noreferrer noopener">Gaëlle</a> nous parlent de Kubectl, une interface de ligne de commande (CLI) qui interagit avec l’API serveur de Kubernetes. C’est un CLI assez intuitif avec des commandes assez logiques. Les plugins kubectl sont là pour améliorer la productivité et raccourcir les commandes qui peuvent parfois être très longues. Ces plugins peuvent être écrits dans beaucoup de langages même si, comme souvent dans l’écosystème Kubernetes, il est recommandé d’utiliser Go (un langage qu’on affectionne beaucoup chez Les-Tilleuls.coop). Aurélie et Gaëlle nous présentent aussi leur propre plugin qui permet d’afficher des émojis liés aux saisons en amont de tous les outputs des commandes kubectl. De quoi mettre de la joie dans votre terminal !



Il est possible de partager son plugin à l’aide de <a href="https://krew.sigs.k8s.io/" target="_blank" rel="noreferrer noopener">Krew</a>, un dépôt libre qui liste des plugins disponibles (voir le <a href="https://krew.sigs.k8s.io/plugins/" target="_blank" rel="noreferrer noopener">catalogue</a>). Cette plateforme fonctionne comme un gestionnaire de paquets avec les commandes usuelles telles que update, install, etc. Il est également possible d’utiliser des dépôts alternatifs autres que celui par défaut de Krew.&nbsp;



Gaëlle et Aurélie nous décrivent aussi le processus d’acceptation d’un nouveau plugin dans le dépôt officiel. Le leur a été refusé à deux reprises, faute d’être considéré comme étant susceptible d’améliorer la productivité ! Elles nous ont ensuite proposé des plugins qui leur semblent pertinents au quotidien, notamment Neat qui permet de nettoyer les champs inutiles.



Enfin, Aurélie Vache a présenté son livre, Understanding Kubernetes in a visual way, qui présente de façon très didactique l’orchestrateur roi de l’industrie. Nous apportons nos félicitations à Aurélie pour son travail conséquent, aussi bien dans la réalisation des dessins que dans la démarche pédagogique pour rendre facilement compréhensible des concepts assez durs à appréhender.&nbsp;



Il est disponible en version papier <a href="https://www.amazon.fr/Understanding-Kubernetes-visual-way-sketchnotes/dp/B0BB619188" target="_blank" rel="noreferrer noopener">imprimée par Amazon</a> ou en version électronique <a href="https://aurelievache.gumroad.com/l/understanding-kubernetes-visual-way" target="_blank" rel="noreferrer noopener">à prix libre</a>. Chez Les-Tilleuls.coop, on a même acheté plusieurs exemplaires sur place !&nbsp;







Découvrez <a href="https://les-tilleuls.coop/blog/retour-sur-cloud-nord-2022-deuxieme-partie" target="_blank" rel="noreferrer noopener">notre seconde partie de compte-rendu ici.</a>

Retour sur Cloud Nord 2022 (première partie)

Découvrez notre compte-rendu du Cloud Nord 2022, le rendez-vous lillois des experts Cloud et DevOps où nous étions exposants.

Retour sur Cloud Nord 2022 (première partie) | Les-Tilleuls.coop

D&eacute;connexion automatique &agrave; l'expiration du JWT


Customisation du nom du cookie d&rsquo;autorisation


Possibilit&eacute; de passer le JWT en utilisant un param&egrave;tre de requ&ecirc;te


Guide de mise &agrave; niveau et compatibilit&eacute;&nbsp;


Versions manag&eacute;e et haute disponibilit&eacute;


Rencontrez la communaut&eacute; &agrave; la API Platform Con !


Am&eacute;lioration des performances et de l&rsquo;utilisation de la m&eacute;moire


<a href="https://dunglas.fr/2022/09/mercure-0-14/" target="_blank" rel="noreferrer noopener">Read the original version of this post</a>



Nous l’évoquions déjà dans <a href="https://twitter.com/coopTilleuls/status/1565001804680683529?s=20&amp;t=0EawZAtHW5JXyrdE6t76Jg" target="_blank" rel="noreferrer noopener">notre Twitter Space de vendredi dernier</a>, nous sommes ravis de vous annoncer la <a href="https://github.com/dunglas/mercure/releases/" target="_blank" rel="noreferrer noopener">disponibilité immédiate</a> de la version 0.14 du hub <a href="https://mercure.rocks/" target="_blank" rel="noreferrer noopener">Mercure.rocks</a> !&nbsp;



Mercure est une solution libre et open-source pour créer des applications temps réel. Avec Mercure, vous poussez en toute sécurité des données vers tous vos utilisateurs connectés grâce à une simple requête POST. Aucune bibliothèque tierce ou SDK n&#8217;est nécessaire : le navigateur (ou tout autre type de client) reçoit les données par le biais d&#8217;un composant serveur que nous appelons hub, et émet un événement JavaScript auquel votre code peut s&#8217;abonner.



<h2>Amélioration des performances et de l’utilisation de la mémoire</h2>



Mercure est une technologie de plus en plus populaire. Il vient d&#8217;atteindre <a href="https://github.com/dunglas/mercure/stargazers" target="_blank" rel="noreferrer noopener">3 000 étoiles sur GitHub</a> et est désormais utilisé pour des projets de haut vol par des organisations telles que l&#8217;ONU, l&#8217;UEFA, Lush, Intermountain Healthcare ou encore le groupe M6.



Le protocole est également utilisé par des projets publics à fort trafic tels que <a href="https://mail.tm/" target="_blank" rel="noreferrer noopener">Mail.tm</a>, un service de messagerie électronique qui aide les utilisateurs à se protéger contre les spams, les bots, le phishing ou d’autres abus en ligne sans exposer leur véritable adresse électronique. Mail.tm envoie environ 8 millions de notifications par jour en utilisant un seul hub Mercure sur un serveur à 6,90 €/mois (<a href="https://les-tilleuls.coop/en/blog/mail-tm-mercure-rocks-and-api-platform" target="_blank" rel="noreferrer noopener">voir l&#8217;étude de cas complète postée sur notre blog</a>). Ce type de déploiement est une vraie mine d&#8217;or pour optimiser au maximum le hub ! Et grâce à l&#8217;équipe derrière Mail.tm et à la communauté, c&#8217;est ce qui a été fait pendant le développement de cette version !



Tout d&#8217;abord, nous avons amélioré <a href="https://github.com/dunglas/mercure/issues/463" target="_blank" rel="noreferrer noopener">l&#8217;utilisation de la mémoire</a> et corrigé <a href="https://github.com/dunglas/mercure/issues/507" target="_blank" rel="noreferrer noopener">certaines fuites</a>, notamment au niveau du logger et de l&#8217;intégration Prometheus. Après ces premières améliorations, nous avons détecté que <a href="https://github.com/dunglas/mercure/issues/558" target="_blank" rel="noreferrer noopener">l&#8217;utilisation du CPU</a> s’envolait lorsqu&#8217;un grand nombre d&#8217;abonnés étaient connectés. <a href="http://kevburnsjr.com/" target="_blank" rel="noreferrer noopener">Kevin Burns</a> a proposé <a href="https://github.com/dunglas/mercure/issues/558#issuecomment-917599547" target="_blank" rel="noreferrer noopener">un patch qui améliore considérablement l&#8217;utilisation du CPU</a>, notamment en cas de charges très élevées. Sous le capot, le correctif de Kevin utilise une nouvelle bibliothèque Go qu&#8217;il a créée pour l’occasion, <a href="https://github.com/kevburnsjr/skipfilter" target="_blank" rel="noreferrer noopener">skipfilter</a>, qui combine des <a href="https://en.wikipedia.org/wiki/Skip_list" target="_blank" rel="noreferrer noopener">skip lists</a> avec des <a href="https://www.roaringbitmap.org/" target="_blank" rel="noreferrer noopener">roaring bitmaps</a>. Selon les benchmarks écrits par Kevin, le nouvel algorithme est 20 à 50% plus efficace que le précédent. Ce patch a réduit l&#8217;utilisation du CPU sur la machine exécutant le hub Mercure de Mail.tm de 100% à ~10% !



<h2>Déconnexion automatique à l&#8217;expiration du JWT</h2>



Mercure prend en charge l&#8217;envoi de mises à jour uniquement aux clients autorisés. Pour ce faire, le client doit fournir un JSON Web Token (JWT) au hub. Ce JWT doit contenir une liste de topics (ou un sélecteur de topics) auxquels le client peut s&#8217;abonner et recevoir des mises à jour privées.



Si <a href="https://www.rfc-editor.org/rfc/rfc7519#section-4.1.4" target="_blank" rel="noreferrer noopener">le champ (claim) expiration `exp` standard du JWT</a> est défini, le token ne peut plus être accepté une fois qu’il a expiré.



À partir de Mercure 0.14, les clients Mercure sont automatiquement déconnectés lorsque le JWT expire. Grâce au système de réconciliation natif fourni par Mercure (via les Server-Sent events), après la déconnexion, le client se reconnectera automatiquement et récupérera les événements manqués lors de la déconnexion, à condition qu&#8217;un nouveau JWT non expiré ait été généré.



<h2>Customisation du nom du cookie d’autorisation</h2>



Lors de l&#8217;utilisation de l&#8217;autorisation, le JWT peut être transmis au hub Mercure par le biais d&#8217;un cookie nommé <code>mercureAuthorization</code> ou de l&#8217;en-tête HTTP <code>Authorization</code>.



Parfois, il peut être pratique d&#8217;avoir plusieurs hubs Mercure sur le même domaine. Malheureusement, cela crée un conflit de nom à cause du nom fixe du cookie. Avec Mercure 0.14, le nom du cookie peut maintenant être configuré, pour permettre l&#8217;utilisation de plusieurs hubs sur le même domaine.



<h2>Possibilité de passer le JWT en utilisant un paramètre de requête</h2>



Depuis le départ, Mercure supporte la transmission du JWT au hub en utilisant un cookie ou un l’en-tête HTTP Authorization. Il est maintenant également possible d&#8217;utiliser un paramètre de requête nommé <code>authorization</code>. Cette nouvelle méthode est <a href="https://mercure.rocks/spec#security-considerations" target="_blank" rel="noreferrer noopener">difficile à sécuriser</a> et son utilisation est déconseillée. L&#8217;utilisation d&#8217;un cookie ou de l&#8217;en-tête <code>Authorization</code> devrait toujours être préférée, mais elle peut être pratique pour des scénarios complexes inter-domaines.



Pour utiliser cette méthode en toute sécurité, la connexion doit être chiffrée (ce qui est requis par la spécification Mercure), et il faut veiller à ne pas loguer le JWT. Le hub Mercure.rocks expurge par défaut le paramètre de requête <code>authorization</code>&nbsp; (ainsi que les cookies et l&#8217;en-tête <code>Authorization</code>). Pour ce faire, <a href="https://dunglas.fr/2022/04/caddy-logging-security-improvements/" target="_blank" rel="noreferrer noopener">nous avons ajouté de nouveaux filtres de logs à Caddy</a>, le serveur web que nous utilisons.



<h2>Caddy 2.5</h2>



En parlant de Caddy, Mercure 0.14 est maintenant construit sur la base de Caddy 2.5. Consultez <a href="https://caddy.community/t/caddy-2-5-released/15749" target="_blank" rel="noreferrer noopener">le changelog de Caddy</a> pour découvrir toutes les nouvelles fonctionnalités apportées ! Vous pouvez toutes les utiliser avec Mercure en personnalisant le fichier Caddy fourni.



Rappel : le hub Mercure est également disponible sous forme de middleware HTTP pour Go, qui peut être intégré dans n&#8217;importe quelle application (typiquement des serveurs web) écrite en Go.



<h2>Guide de mise à niveau et compatibilité&nbsp;</h2>



Quelques changements introduits dans la version 0.14 peuvent nécessiter une mise à jour de vos clients. N&#8217;oubliez pas de lire le <a href="https://mercure.rocks/docs/UPGRADE" target="_blank" rel="noreferrer noopener">guide de mise à jour</a> !



Même si les modifications sont mineures et ne devraient pas affecter la plupart des utilisateurs, nous prenons la rétrocompatibilité très au sérieux, et il est possible d&#8217;activer la compatibilité avec les anciennes versions du protocole public en définissant la nouvelle directive <code>protocol_version_compatibility</code> introduite dans la version 0.14.



<h2>Versions managée et haute disponibilité</h2>



La <a href="https://mercure.rocks/pricing" target="_blank" rel="noreferrer noopener">version managée</a> de Mercure.rocks ainsi que la version <a href="https://mercure.rocks/docs/hub/cluster#purchasing" target="_blank" rel="noreferrer noopener">haute disponibilité</a> sont déjà construites sur la base de la v0.14 et supportent toutes les fonctionnalités listées dans cet article.



Si vous utilisez la version managée, vous pouvez passer à la dernière version directement à partir de la page des paramètres. Les nouveaux projets sont directement créés en l&#8217;utilisant. Les utilisateurs de la version haute disponibilité peuvent télécharger les binaires et les images Docker via les canaux de mise à jour habituels.



<h2>Rencontrez la communauté à la API Platform Con !</h2>



De nombreuses et nombreux spécialistes des APIs asynchrones, de Mercure ou des applications en temps réel comme <a href="https://api-platform.com/con/2022/conferences/building-schema-first-event-driven-architectures-with-async-api/" target="_blank" rel="noreferrer noopener">Fran Mendez</a> (le créateur d&#8217;AsyncAPI), <a href="https://api-platform.com/con/2022/conferences/php-websockets-or-how-to-communicate-with-clients-in-real-time/" target="_blank" rel="noreferrer noopener">Pauline Vos</a> (experte en Websockets), <a href="https://api-platform.com/con/2022/conferences/what-s-new-in-caddy-the-webserver-of-api-platform/" target="_blank" rel="noreferrer noopener">Francis Lavoie</a> (Core Team de Caddy), <a href="https://api-platform.com/con/2022/conferences/real-time-and-beyond-with-mercure/" target="_blank" rel="noreferrer noopener">Brian Mc Cluskey</a> (expert Mercure) et <a href="https://api-platform.com/con/2022/conferences/opening-keynote-introduction-to-API-platform-3/" target="_blank" rel="noreferrer noopener">Kévin Dunglas</a> interviendront la semaine prochaine à la <a href="https://api-platform.com/con/2022/" target="_blank" rel="noreferrer noopener">API Platform Conference</a> 2022.&nbsp;



Il est encore temps d&#8217;acheter vos billets, <a href="https://api-platform.com/con/2022/#pricing" target="_blank" rel="noreferrer noopener">rejoignez-nous</a> à Lille ou en ligne !



<h2>Support ou signalement de bugs</h2>



Comme d&#8217;habitude, <a href="https://github.com/dunglas/mercure/issues" target="_blank" rel="noreferrer noopener">n&#8217;hésitez pas à signaler tout dysfonctionnement sur GitHub</a> et si vous souhaitez <a href="https://les-tilleuls.coop/masterclass/formations/decouvrir-le-protocole-mercure" target="_blank" rel="noreferrer noopener">découvrir Mercure</a> ou être aidé·e dans la création de votre application en temps réel, <a href="mailto:contact@les-tilleuls.coop">contactez-nous</a> !&nbsp;

Sortie de Mercure 0.14 : nouvelles fonctionnalités et amélioration des performances

Détails des nouvelles fonctionnalités et amélioration des performances de la version 0.14 du hub Mercure.

Sortie de Mercure 0.14 : nouvelles fonctionnalités et amélioration des performances | Les-Tilleuls.coop

https://secure.gravatar.com/avatar/362ea08993d784535d1758b2d2f4adb1?s=96&d=mm&r=g

Kevin Dunglas

La seconde édition de la <a href="https://api-platform.com/con/2022/">conférence internationale consacrée à API Platform</a> se déroulera dans moins de deux mois ! Ne manquez pas&nbsp; cet évènement qui sera riche en apprentissages et en surprises ! La conférence aura lieu le jeudi 15 et vendredi 16 septembre à Lille, au sein du campus d&#8217;<a href="https://www.euratechnologies.com/">Euratechnologies</a>. Deux scènes sont au programme : une francophone et une anglophone qui accueillera des experts du monde entier (Europe, Amérique, Afrique). L’intégralité de la conférence sera également retransmise en direct sur le web.



La conférence sera précédée de deux jours de formation animés par les créateurs de API Platform et suivie d’un hack day au cours duquel vous pourrez apprendre à contribuer au logiciel libre aux côtés de développeurs renommés.&nbsp;



Le <a href="https://api-platform.com/con/2022/#schedule">programme complet</a> est publié, voyons ce que vous ne devez pas rater! Plus de 25 conférencières et conférenciers se partageront les deux scènes à travers des conférences de 40 minutes en moyenne. Nous aurons notamment le plaisir d&#8217;écouter :



<ul><li><a href="https://api-platform.com/con/2022/conferences/dilemmas-and-decisions-what-we-ve-learned-designing-the-new-sylius-api/">Lukasz Chrusciel</a>, core team Sylius &#8211; Dilemmas and decisions. What we’ve learned designing the new sylius API.</li><li><a href="https://api-platform.com/con/2022/conferences/domain-driven-design-with-api-platform-3/">Robin Chalas et Mathias Arlaud</a>, expert et core team Symfony &#8211; du DDD avec API Platform 3 !</li><li><a href="https://api-platform.com/con/2022/conferences/gerer-les-operations-sequentielles-avec-REST/">Grégoire Hébert</a>, expert PHP et Formateur Les Tilleuls Coop &#8211; Comment Gérer les opérations séquentielles avec REST. </li><li><a href="https://api-platform.com/con/2022/conferences/comment-alices-garden-gere-t-elle-son-code-metier-via-les-evenements/">Nicolas Lemahieu</a>, symfony expert Alice’s Garden &#8211; Comment Alice&#8217;s Garden gère-t-elle son code méier via les événements ?</li><li><a href="https://api-platform.com/con/2022/conferences/building-schema-first-event-driven-architectures-with-async-api/">Fran Mendez</a>, founder Asyncapi &#8211; Building schema-first event-driven architectures with ASYNCAPI.</li><li><a href="https://api-platform.com/con/2022/conferences/API-platform-au-quotidien-dans-une-entreprise-e-commerce-et-logistique/">Kévin Verschaeve et Clément Sanchez </a>, lead developers Perfect Draft (Saveurs Bières) &#8211; REX : API Platform au quotidien dans une entreprise e-commerce et logistique.</li><li><a href="https://api-platform.com/con/2022/conferences/decentralizaion-query-apis-and-other-myths/">Ruben Verborgh</a>, decentralized web expert Project Solid &#8211; Decentralization, query APIs and other myths.</li><li><a href="https://api-platform.com/con/2022/conferences/reutiliser-et-partager-vos-operations-API-platform-personnalis%C3%A9es/">Hubert Lenoir et Jérémy Jarrié</a>, lead developers Sensiolabs &#8211; Réutiliser et partager vos opérations personnalisées avec API Platform</li><li><a href="https://api-platform.com/con/2022/conferences/4-years-later-the-components-web-app/">Daniel West</a>, Creator Components Web App &#8211; 4 years later: the &#8220;Components web App&#8221; (CWA)</li><li><a href="https://api-platform.com/con/2022/conferences/la-revue-de-code-est-un-art/">Smaïne Millianni</a>, Symfony certified developer &#8211; La revue de code est un art !</li><li><a href="https://api-platform.com/con/2022/conferences/fighting-impostor-syndrome-a-pratical-handbook/">Marine Gandy</a>, Php developer &amp; Drupalista Ekino &#8211; Fighting impostor syndrome, a practical handbook.</li><li><a href="https://api-platform.com/con/2022/conferences/apis-the-next-10-years-beyond-the-interface/">Mehdi Medjaoui</a>, founder Apidays &amp; Oauth.io &#8211; APIS, the next 10 years : beyond the interface?</li><li><a href="https://api-platform.com/con/2022/speakers/helene-maitre-marchois/">Hélène Marchois</a>, agilliste Fairness &#8211; Table ronde à découvrir prochainement!</li><li><a href="https://api-platform.com/con/2022/speakers/antoine-bluchet/">Antoine Bluchet</a> alias <a href="mailto:antoine@les-tilleuls.coop">soyuka</a>, core team API Platform &#8211; Introduction to the new feature of API Platform 3.</li><li><a href="https://api-platform.com/con/2022/conferences/what-s-new-in-caddy-the-webserver-of-api-platform/">Francis Lavoie</a>, team member Caddy Server &#8211; What&#8217;s new in caddy, the webserver of API Platform. </li><li><a href="https://api-platform.com/con/2022/conferences/pourquoi-je-n-utilise-pas-API-platform/">Frédéric Bouchery</a>, PHP Expert CCMBenchmark &#8211; Pourquoi je n’utilise pas API Platform ?</li><li><a href="https://api-platform.com/con/2022/conferences/mon-combat-contre-l-arachnophobie/">Jérôme Tanghe</a>, developer Les Tilleuls.coop &#8211; Mon combat contre l’arachnophobie.</li><li><a href="https://api-platform.com/con/2022/conferences/webauthn-se-debarrasser-des-mots-de-passe-definitivement/">Florent Morselli</a>, PHP developer &amp; symfony lover &#8211; Webauthn: se débarrasser des mots de passe. Définitivement.</li><li><a href="https://api-platform.com/con/2022/conferences/real-time-and-beyond-with-mercure/">Brian McCluskey</a>, Director of engineering Raven controls &#8211; Realtime and beyond with Mercure.</li><li><a href="https://api-platform.com/con/2022/conferences/php-websockets-or-how-to-communicate-with-clients-in-real-time/">Pauline Vos</a>, Lead software engineer &#8211; PHP Websockets: OR how to communicate with clients in real-time?</li><li><a href="https://api-platform.com/con/2022/conferences/tests-avances/">Olivier Doucet</a>, co-founder Oxeva &#8211; Tests avancés</li><li><a href="https://api-platform.com/con/2022/conferences/finding-the-path-to-scaling-API-success/">Darrel Miller</a>, APi Architect Microsoft Graph &amp; OPENAPI initiative &#8211; Finding the Path to scaling API success</li><li><a href="https://api-platform.com/con/2022/conferences/france-televisions-quand-API-Platform-tombe-a-PIC/">Albin Kester et Georges King Njock Bôt</a>, lead developer les Tilleuls Coop &amp; PHP Expert Freelance &#8211; REX: France Télévisions, quand API Platform tombe à pic!</li><li><a href="https://api-platform.com/con/2022/conferences/nicolas-grekas-talk/">Nicolas Grekas</a>, core team Symfony. A découvrir prochainement !</li></ul>



Concernant les formations,&nbsp; cela se passe les mardi 13, mercredi 14 septembre :&nbsp;



<ul><li>Mardi 13/09 : <a href="https://api-platform.com/con/2022/conferences/designing-and-building-an-api-first-project-with-API-Platform-3/">Conception et élaboration d&#8217;un 1er projet API avec API Platform 3</a>, avec <a href="https://twitter.com/dunglas">Kévin Dunglas</a> et <a href="https://twitter.com/s0yuka">Antoine Bluchet</a></li><li>Mercredi 14/09 :&nbsp; <a href="https://api-platform.com/con/2022/conferences/workshop-domain-driven-design-with-API-Platform-3/">du Domain Driven Design avec Api Platform 3</a>, avec <a href="https://twitter.com/chalas_r">Robin Chalas</a> et <a href="https://twitter.com/matarld">Mathias Arlaud</a></li></ul>



&nbsp;Le <a href="https://api-platform.com/con/2022/conferences/API-platform-3-hack-day/">Hack Day </a> se déroulera Samedi 17/09 et sera animé par core team API Platform ! Et c’est gratuit.



Nous espérons que ce programme vous plaira autant que nous avons eu à le préparer ! <a href="https://api-platform.com/con/2022/#pricing">Les places au tarif regular sont encore disponibles jusqu&#8217;au 20 août</a> et des places en présentiel sont encore disponibles. D’ailleurs, si vous êtes étudiant ou en recherche d’emploi, nous offrons cette année les places en ligne mais aussi sur place!&nbsp;



<a href="https://api-platform.com/con/2022/">Inscrivez-vous</a> avant que le changement de tarif n&#8217;ait lieu et préparez-vous à une semaine où différentes communautés de devs vont se rejoindre pour partager, échanger et apprendre ensemble.



Enfin, déjà <a href="https://api-platform.com/con/2022/#partners">8 partenaires</a> soutiennent notre événement. Vous souhaitez que votre entreprise y soit associée ?&nbsp;



Contactez-nous pour recevoir le dossier de sponsoring ! <a href="https://api-platform.com/con/2022/transparency">Tous les bénéfices générés par les recettes de l&#8217;événement seront reversés au développement d&#8217;API Platform</a>, et rien d&#8217;autre.



On se voit en Septembre ?

API Platform Conference #2 : venez rencontrer les plus grand•es expert•es des API web !

La seconde édition de la conférence internationale consacrée à API Platform se déroulera dans moins de deux mois ! Ne manquez pas&nbsp; cet évènement qui sera riche en apprentissages et en surprises ! La conférence aura lieu le jeudi 15 et vendredi 16 septembre à Lille, au sein du campus d&#8217;Euratechnologies. Deux scènes sont au [&hellip;]

API Platform Conference #2 : venez rencontrer les plus grand•es expert•es des API web ! | Les-Tilleuls.coop

// This Go program demonstrates the behavior of runtime.LockOSThread() and runtime.UnlockOSThread().
// runtime.LockOSThread() forces the wiring of a Goroutine to a system thread.
// No other goroutine can run in the same thread, unless runtime.UnlockOSThread() is called at some point.
//
// According to the manual of phthread_self, when many threads are created, the system may reassign an ID that was used by a terminated thread to a new thread.
//
// This programs shows that thread IDs are indeed reused (tested on Linux and Mac), but that the thread itself is actually destroyed.
// To prove this, we store used thread IDs in a global variable, and some data in each local thread using pthread_setspecific().
//
// When we hint the Go runtime to reuse the threads by calling runtime.UnlockOSThread(), we can see that the local data is still available when a thread is reused.

package main

/*
#include &lt;stdlib.h>
#include &lt;pthread.h>

int setspecific(pthread_key_t key, int i) {
	int *ptr = calloc(1, sizeof(int)); // memory leak on purpose
	*ptr = i;
	return pthread_setspecific(key, ptr);
}
*/
import "C"
import (
	"bytes"
	"fmt"
	"runtime"
	"strconv"
	"sync"
)

const nbGoroutines = 1000

type goroutine struct {
	num int    // App specific goroutine ID
	id  uint64 // Internal goroutine ID (debug only, do not rely on this in real programs)
}

var seenThreadIDs map[C.pthread_t]goroutine = make(map[C.pthread_t]goroutine, nbGoroutines+1)
var seenThreadIDsMutex sync.RWMutex

// getGID gets the current goroutine ID (copied from https://blog.sgmansfield.com/2015/12/goroutine-ids/)
func getGID() uint64 {
	b := make([]byte, 64)
	b = b[:runtime.Stack(b, false)]
	b = bytes.TrimPrefix(b, []byte("goroutine "))
	b = b[:bytes.IndexByte(b, ' ')]
	n, _ := strconv.ParseUint(string(b), 10, 64)
	return n
}

// isThreadIDReused checks if the passed thread ID has already be used before
func isThreadIDReused(t1 C.pthread_t, currentGoroutine goroutine) bool {
	seenThreadIDsMutex.RLock()
	defer seenThreadIDsMutex.RUnlock()
	for t2, previousGoroutine := range seenThreadIDs {
		if C.pthread_equal(t1, t2) != 0 {
			fmt.Printf("Thread ID reused (previous goroutine: %v, current goroutine: %v)\n", previousGoroutine, currentGoroutine)

			return true
		}
	}

	return false
}

func main() {
	runtime.LockOSThread()
	seenThreadIDsMutex.Lock()
	seenThreadIDs[C.pthread_self()] = goroutine{0, getGID()}
	seenThreadIDsMutex.Unlock()

	// It could be better to use C.calloc() to prevent the GC to destroy the key
	var tlsKey C.pthread_key_t
	if C.pthread_key_create(&amp;tlsKey, nil) != 0 {
		panic("problem creating pthread key")
	}

	for i := 1; i &lt;= nbGoroutines; i++ {
		go func(i int) {
			runtime.LockOSThread()
			// Uncomment the following line to see how the runtime behaves when threads can be reused
			//defer runtime.UnlockOSThread()

			// Check if data has already been associated with this thread
			oldI := C.pthread_getspecific(tlsKey)
			if oldI != nil {
				fmt.Printf("Thread reused, getspecific not empty (%d)\n", *(*C.int)(oldI))
			}

			g := goroutine{i, getGID()}



// Get the current thread ID
			t := C.pthread_self()
			isThreadIDReused(t, g)

			// Associate some data to the local thread
			if C.setspecific(tlsKey, C.int(i)) != 0 {
				panic("problem setting specific")
			}

			// Add the current thread ID in the list of already used IDs
			seenThreadIDsMutex.Lock()
			defer seenThreadIDsMutex.Unlock()
			seenThreadIDs[C.pthread_self()] = g
		}(i)
	}
}

Thread ID reused (previous goroutine: {6 9}, current goroutine: {1 4})
Thread ID reused (previous goroutine: {1 4}, current goroutine: {13 16})
Thread ID reused (previous goroutine: {3 6}, current goroutine: {32 52})

Thread reused, getspecific not empty (35)
Thread ID reused (previous goroutine: {35 53}, current goroutine: {1 19})
Thread reused, getspecific not empty (26)
Thread ID reused (previous goroutine: {26 44}, current goroutine: {19 37})
Thread reused, getspecific not empty (19)
Thread reused, getspecific not empty (84)
Thread ID reused (previous goroutine: {84 102}, current goroutine: {36 54})
Thread reused, getspecific not empty (36)
Thread ID reused (previous goroutine: {36 54}, current goroutine: {37 55})
Thread reused, getspecific not empty (37)
Thread ID reused (previous goroutine: {37 55}, current goroutine: {38 56})
Thread reused, getspecific not empty (38)
Thread ID reused (previous goroutine: {38 56}, current goroutine: {39 57})
Thread reused, getspecific not empty (18)
Thread reused, getspecific not empty (39)
Thread ID reused (previous goroutine: {39 57}, current goroutine: {40 58})
Thread reused, getspecific not empty (40)
Thread ID reused (previous goroutine: {18 36}, current goroutine: {2 20})
Thread reused, getspecific not empty (1)
Thread ID reused (previous goroutine: {40 58}, current goroutine: {41 59})

<a href="https://dunglas.fr/2022/05/goroutines-threads-and-thread-ids/" target="_blank" rel="noreferrer noopener">Découvrez ici l&#8217;article original</a>







Si vous avez assisté à l’AFUP Day 2022 le 20 mai à Lille, vous savez peut-être que je travaille actuellement sur un module PHP pour serveurs web écrit en Go.



En testant ma future bibliothèque, j&#8217;ai rencontré d&#8217;étranges problèmes d&#8217;accès à la mémoire liés aux threads créés par le runtime Go (vous savez, cgo&#8230;).



Par défaut, le planificateur de Go exécute de nombreuses goroutines sur les mêmes threads système. Ce comportement est incompatible avec le code C qui s&#8217;appuie sur le stockage local des threads, comme PHP compilé avec l&#8217;option ZTS.



Heureusement, la bibliothèque standard de Go fournit une fonction utilitaire pour contourner ce problème : runtime.LockOSThread(). Go garantit que la goroutine qui appelle cette fonction s&#8217;exécute toujours dans le même thread système, et qu&#8217;aucune autre goroutine ne peut s&#8217;exécuter dans le même thread jusqu&#8217;à ce que runtime.UnlockOSThread() soit appelée.



En déboguant ma bibliothèque, j&#8217;ai découvert que PHP utilise l&#8217;ID du thread actuel comme clé pour accéder aux données locales du thread. Cela peut-il être un problème ? Sommes-nous sûrs que le système ne réutilise jamais le même ID de thread alors que le même processus est en cours d&#8217;exécution ?&nbsp;



La page de manuel de pthread_self() fournie par Apple sur Mac OS X (de 1996 !) ne donne aucune information à ce sujet, cependant, la page de manuel de Linux indique ceci :



Un identifiant de thread peut être réutilisé après qu&#8217;un thread terminé ait été rejoint, ou qu&#8217;un thread détaché se soit terminé.



Écrivons un programme de test pour comprendre comment runtime.LockOSThread() fonctionne, et si le système réutilise vraiment les IDs des threads :





Voici un exemple de sortie lorsque runtime.UnlockOSThread() est commenté.





Donc oui, les ID des threads sont réutilisés, tandis que les threads eux-mêmes sont correctement détruits. Nous avons peut-être un problème avec la base de code de PHP !



Et voici un exemple lorsque runtime.UnlockOSThread() est décommenté.





Nous pouvons voir que les threads sont réutilisés, comme documentés !



Si vous cherchez des experts Go, C ou PHP, contactez<a href="https://les-tilleuls.coop/" target="_blank" rel="noreferrer noopener"> Les-Tilleuls.coop </a>! Nous sommes là pour échanger avec vous  et voir ensemble comment on peut répondre à vos besoins !

Goroutines, threads, et IDs de threads

Découvrez ici l&#8217;article original Si vous avez assisté à l’AFUP Day 2022 le 20 mai à Lille, vous savez peut-être que je travaille actuellement sur un module PHP pour serveurs web écrit en Go. En testant ma future bibliothèque, j&#8217;ai rencontré d&#8217;étranges problèmes d&#8217;accès à la mémoire liés aux threads créés par le runtime Go [&hellip;]

Goroutines, threads, et IDs de threads | Les-Tilleuls.coop

Nouveau dans Symfony 6.1 : Constructeurs de contexte de s&eacute;rialiseur

Nouveau dans Symfony 6.1 : Profilage du s&eacute;rialiseur

Comme plusieurs de nos collaborateurs, <a href="https://twitter.com/matarld" target="_blank" rel="noreferrer noopener">Mathias Arlaud </a>attribue du temps à l&#8217;open source. Récemment, il a apporté quelques contributions à Symfony. Vous pouvez les découvrir juste ici ! 



<h2>Nouveau dans Symfony 6.1 : Constructeurs de contexte de sérialiseur</h2>



<a href="https://symfony.com/blog/new-in-symfony-6-1-serializer-context-builders" target="_blank" rel="noreferrer noopener">Découvrez ici l&#8217;article original</a>



Chaque fois que vous sérialisez et désérialisez des données, le sérialiseur de Symfony vous permet de lui fournir un certain contexte pour configurer le processus de sérialisation/désérialisation.



Ce contexte peut par exemple être utilisé pour sérialiser des dates dans un format spécial, pour ignorer certaines propriétés, pour utiliser un délimiteur CSV spécifique, [&#8230;].



Le contexte est un simple tableau associatif qui associe une chaîne de caractères quelconque à une valeur :



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="358" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1-1024x358.png" alt="" class="wp-image-5226" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1-1024x358.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1-600x210.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1-300x105.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1-768x269.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1.png 1114w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Pour éviter les erreurs de frappe, vous pouvez utiliser les constantes exposées par chaque normalisateur/encodeur :



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="282" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1-1024x282.png" alt="" class="wp-image-5227" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1-1024x282.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1-600x165.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1-300x83.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1-768x212.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1.png 1416w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



À partir de Symfony 6.1, vous serez en mesure de créer ce contexte de sérialisation en utilisant des constructeurs de contexte.



Ces constructeurs de contexte sont des objets qui abstraient le tableau associatif du contexte et fournissent à la place une interface fluide pour le construire.



Ainsi, en utilisant les context builders, il sera possible de créer un contexte de sérialisation tout en bénéficiant de l&#8217;autocomplétion, de la validation et de la documentation :



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="210" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-1024x210.png" alt="" class="wp-image-5228" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-1024x210.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-600x123.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-300x61.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-768x157.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1-1536x315.png 1536w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1.png 1854w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Les constructeurs de contextes peuvent être initialisés à partir d&#8217;un tableau ordinaire ou même d&#8217;un autre constructeur de contexte. Et ils peuvent bien entendu être transformés en un tableau associatif, requis par les méthodes du sérialiseur.



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="564" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4-1024x564.png" alt="" class="wp-image-5229" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4-1024x564.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4-600x330.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4-300x165.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4-768x423.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-4.png 1366w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Symfony est livré avec un constructeur de contexte par normalisateur/encodeur.



Mais vous pouvez tout aussi bien créer le vôtre en implémentant la ContextBuilderInterface et en utilisant le ContextBuilderTrait !



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="576" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5-1024x576.png" alt="" class="wp-image-5230" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5-1024x576.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5-600x338.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5-300x169.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5-768x432.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-5.png 1400w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



<h2>Nouveau dans Symfony 6.1 : Profilage du sérialiseur</h2>



<a href="https://symfony.com/blog/new-in-symfony-6-1-serializer-profiling" target="_blank" rel="noreferrer noopener">Découvrez ici l&#8217;article original</a>



Lors de la sérialisation, le sérialiseur de Symfony doit trouver un normalisateur et un encodeur appropriés.



Pour ce faire, il passe en revue tous les normalisateurs/encodeurs connus et leur demande s&#8217;ils sont en mesure de normaliser/encoder.



Le premier normalisateur/encodeur qui répond qu&#8217;il est capable de procéder cette normalisation/cet encodage est sélectionné et utilisé.



Ce modèle de conception est super, mais il rend difficile le fait de savoir quel normalisateur ou encodeur est utilisé pendant tout le processus de (dé)sérialisation. C&#8217;est pourquoi un nouveau panneau Symfony Profiler a été ajouté !



<img decoding="async" loading="lazy" src="https://lh4.googleusercontent.com/jmZhHFQpiwpfGCxfCguDB7byo6utoVfcqxBT3_TAhTQS0G38fM1Y0HK-6yImlosEUFRwclvOltrlhoBbMYpVBp-sC3XC3I7dLdKmWurApEaTkK4_UfHow5NNOLL2F8MhfK3Y7uHR2Ja4_aX5CA" width="602" height="181">



Le service de sérialisation est donc décoré pour tracer l&#8217;activité des appels aux méthodes serialize(), deserialize(), normalize(), denormalize(), encode() et decode().



Chaque normalisateur et encodeur individuel est également décoré, de sorte que le panneau de debug puisse fournir de nombreux détails sur le processus de sérialisation, tels que la durée, le contexte, l&#8217;entrée, &#8230;



Rien n&#8217;est nécessaire pour bénéficier de cette fonctionnalité, il suffit de mettre à jour votre framework et d&#8217;en profiter !















Notre collaborateur<a href="https://twitter.com/matarld"> Mathias </a>est basé dans nos bureaux de Lyon, n&#8217;hésitez pas à <a href="https://les-tilleuls.coop/blog/category/symfony/p/2" target="_blank" rel="noreferrer noopener">nous contacter</a> selon vos besoins ! Notre équipe se fera un plaisir d’y répondre 🙂



Retrouvez aussi Mathias avec<a href="https://twitter.com/chalas_r" target="_blank" rel="noreferrer noopener"> Robin</a>, lors de notre conférence <a href="https://api-platform.com/con/2022/" target="_blank" rel="noreferrer noopener">API platform Con en septembre 2022</a>, ils animeront tous les 2 un talk qui promet d’être passionnant !

Nouveautés dans Symfony 6.1 : Notre coopérateur Mathias vous en dit plus !

Comme plusieurs de nos collaborateurs, Mathias Arlaud attribue du temps à l&#8217;open source. Récemment, il a apporté quelques contributions à Symfony. Vous pouvez les découvrir juste ici ! Nouveau dans Symfony 6.1 : Constructeurs de contexte de sérialiseur Découvrez ici l&#8217;article original Chaque fois que vous sérialisez et désérialisez des données, le sérialiseur de Symfony [&hellip;]

Nouveautés dans Symfony 6.1 : Notre coopérateur Mathias vous en dit plus ! | Les-Tilleuls.coop

https://secure.gravatar.com/avatar/40dfc350a09c1b2f7391856a676253c3?s=96&d=mm&r=g

tilleuls

Caviarder des en-t&ecirc;tes HTTP sensibles

Des filtres suppl&eacute;mentaires !

<a href="https://dunglas.fr/2022/04/caddy-logging-security-improvements/" target="_blank" rel="noreferrer noopener">Découvrez ici l&#8217;article original</a>



<figure class="wp-block-image size-full"><img decoding="async" loading="lazy" width="693" height="343" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/caddy-logging-sercurity-1.png" alt="" class="wp-image-5152" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/caddy-logging-sercurity-1.png 693w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/caddy-logging-sercurity-1-600x297.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/caddy-logging-sercurity-1-300x148.png 300w" sizes="(max-width: 693px) 100vw, 693px" /></figure>



Caddy est l&#8217;étoile montante des serveurs web : rapide, facile à configurer, complet (génération et renouvellement automatique des certificats TLS, HTTP/3, cloud-native, rechargement à chaud de la configuration&#8230;) et sécurisé (écrit en Go et pas en C).



Grâce à son extensibilité inégalée, Caddy est une plateforme applicative de premier ordre, disposant d&#8217;un écosystème florissant !



Pour mieux saisir sa puissance, jetez un coup d&#8217;œil aux modules Mercure (capacités push) et Vulcain (API hypermédia pilotées par le client) auxquels j&#8217;ai contribué ! Caddy est également le serveur web utilisé dans la distribution API Platform et dans Symfony Docker.



Il y a quelques jours, après un an de travail, Matt Holt a publié Caddy 2.5 ! Cette nouvelle version contient quelques nouvelles fonctionnalités que j&#8217;ai contribué ou aidé à concevoir, améliorant la sécurité du système de logs.







<h2>Caviarder des en-têtes HTTP sensibles</h2>



Contrairement à la plupart des autres serveurs web, Caddy émet des logs structurés verbeux. Bien qu&#8217;il soit pratique de pouvoir inspecter et analyser chaque détail des messages HTTP, cela peut également être dangereux. Jusqu&#8217;à la version 2.5, tous les en-têtes HTTP étaient enregistrés lorsque la journalisation est activée, y compris les en-têtes sensibles.



Cela peut entraîner de graves problèmes de sécurité si le système qui traite et stocke les logs (ELK, Datadog&#8230;) n&#8217;est pas configuré correctement. Et ils ne le sont pas par défaut ! Même des entreprises telles que Facebook, Twitter et GitHub ont stocké des millions de mots de passe d&#8217;utilisateurs en clair en raison de mauvaises configurations similaires.



Dans la version 2.5, les en-têtes HTTP standard susceptibles de contenir des informations d&#8217;identification, tels que définis dans la spécification de fetch(), sont automatiquement expurgés. Ces en-têtes sont Cookie, Set-Cookie, Authorization et Proxy-Authorization. Si vous avez malgré tout besoin d&#8217;enregistrer ces en-têtes, par exemple pendant une session de débogage, Francis Lavoie a ajouté une nouvelle option permettant de réactiver l&#8217;ancien comportement : log_credentials.



<h2>Des filtres supplémentaires !</h2>



Mais cette modification ne suffit pas à couvrir tous les cas où des données sensibles doivent être supprimées des logs. Bien que cela soit considéré comme une mauvaise pratique de sécurité, il est courant que les paramètres de requête contiennent des informations sensibles.&nbsp;



Quelques exemples :



<ul><li>les jetons d&#8217;accès OAuth</li><li>les &#8220;liens magiques&#8221; et autres URL temporaires</li><li>les IDs de session PHP</li><li>les JWT Mercure (la raison pour laquelle j&#8217;ai commencé à travailler sur ce sujet en premier lieu)</li></ul>



Dans de nombreux cas, vous pouvez souhaiter logguer certains paramètres de requête, mais supprimer ou remplacer certains autres qui contiennent des données sensibles. Par exemple : le paramètre de requête access token défini dans les spécifications OAuth 2.



De même, au lieu de supprimer entièrement l&#8217;en-tête Cookie, ce qui signifie supprimer tous les cookies, vous pouvez vouloir supprimer certains cookies spécifiques mais en conserver d&#8217;autres. Pour couvrir ces cas d&#8217;utilisation plus avancés mais assez courants, j&#8217;ai ajouté un certain nombre de nouveaux filtres.



Le premier nouveau filtre permet de supprimer, remplacer ou hacher des paramètres de requête spécifiques :



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="458" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1024x458.png" alt="" class="wp-image-5161" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-1024x458.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-600x268.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-300x134.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1-768x343.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-1.png 1432w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



J&#8217;ai également contribué à un filtre similaire pour manipuler les cookies :



<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="461" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1024x461.png" alt="" class="wp-image-5162" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-1024x461.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-600x270.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-300x135.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2-768x345.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-2.png 1436w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Enfin, j&#8217;ai ajouté la possibilité de hacher ou d&#8217;appliquer une expression régulière à la valeur de n&#8217;importe quel champ enregistré :







<figure class="wp-block-image size-large"><img decoding="async" loading="lazy" width="1024" height="349" src="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1024x349.png" alt="" class="wp-image-5164" srcset="https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-1024x349.png 1024w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-600x204.png 600w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-300x102.png 300w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3-768x262.png 768w, https://api.les-tilleuls.coop/wp-content/uploads/2022/05/image-3.png 1424w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



Le filtre de hachage est particulièrement utile pour éviter que différentes requêtes ne soient pas distinguables dans les journaux, ou lorsque vous voulez pouvoir regrouper des requêtes qui ont les mêmes valeurs caviardées, mais qui sont caviardées.



Si vous avez besoin d&#8217;aide pour mettre en place ou même pour mettre à jour Caddy, si vous voulez faire appel à une équipe de développeurs Go expérimentés, ou si vous avez besoin d&#8217;experts pour sécuriser votre application : <a href="https://les-tilleuls.coop/" target="_blank" rel="noreferrer noopener">contactez-nous </a>!



<a href="https://les-tilleuls.coop/" target="_blank" rel="noreferrer noopener"> Les-Tilleuls.coop </a>peut vous aider !

Nouveauté de Caddy 2.5 : Expurger les données sensibles de vos logs

Découvrez ici l&#8217;article original Caddy est l&#8217;étoile montante des serveurs web : rapide, facile à configurer, complet (génération et renouvellement automatique des certificats TLS, HTTP/3, cloud-native, rechargement à chaud de la configuration&#8230;) et sécurisé (écrit en Go et pas en C). Grâce à son extensibilité inégalée, Caddy est une plateforme applicative de premier ordre, disposant [&hellip;]

Nouveauté de Caddy 2.5 : Expurger les données sensibles de vos logs | Les-Tilleuls.coop

Le Web2day en chiffres :

Nous sommes heureux de vous annoncer que nous sommes <a href="https://web2day.co/partenaires/" target="_blank" rel="noreferrer noopener">partenaires Gold du Web2day 2022</a>. Les 1er, 2 et 3 juin, aura lieu le plus grand festival francophone des professionnels du numérique, à Nantes !



Un événement incontournable autour de la tech digne ! Il réunit chaque année plus de 10 000 participants. En onze éditions, <a href="https://web2day.co/" target="_blank" rel="noreferrer noopener">le Web2day </a>s’est imposé comme un événement incontournable pour l’écosystème d’innovation Français, en réinventant les formats de conférences traditionnels.



Nous vous donnons rendez-vous <a href="https://web2day.co/comment-venir-au-web2day/" target="_blank" rel="noreferrer noopener">sous les nefs des Machines de l’île de Nantes</a>. N’hésitez pas à venir nous voir sur notre stand, vous aurez droit à quelques surprises !&nbsp;



<center><blockquote class="twitter-tweet">3️⃣0️⃣ petits jours avant de se retrouver&#8230; ? En attendant, faites un tour du côté de la programmation pour découvrir les speakers de cette nouvelle édition ➡️ <a href="https://t.co/lyJqqQeohH">https://t.co/lyJqqQeohH</a> <a href="https://t.co/vZ9zfE7jdg">pic.twitter.com/vZ9zfE7jdg</a>— Web2day (@web2day) <a href="https://twitter.com/web2day/status/1521044094843244544?ref_src=twsrc%5Etfw">May 2, 2022</a></blockquote> <script async="" src="https://platform.twitter.com/widgets.js" charset="utf-8"></script><center></center></center>



<h2>Le Web2day en chiffres :</h2>



<ul><li>3 journées intenses</li><li>10 000 participants</li><li>225 speakers du monde entier</li><li>160 conférences</li><li>Une vingtaine de coopérateurs présents !&nbsp;</li></ul>



Conférences, workshops, showroom, soirées… <a href="https://web2day.co/le-festival/" target="_blank" rel="noreferrer noopener">Le Web2day est une manifestation qui s’adresse  à l’ensemble des acteurs du numérique </a>( PME, entreprises innovantes, développeurs.ses, designers, professionnel.les de la communication…) Plus de 5000 m2 d’espaces sont dédiés aux démos, exposants et autres animations du festival.



Nous serons aussi présents en tant que conférenciers car notre coopérateur <a href="https://twitter.com/s0yuka" target="_blank" rel="noreferrer noopener">Antoine Bluchet</a> , qui fait partie de notre agence de Nantes, présentera API Platform 3. <a href="https://web2day.co/event/un-standard-incontournable-pour-vos-apis-api-platform/" target="_blank" rel="noreferrer noopener">Retrouvez-le le Vendredi 3 juin à partir de 9h40</a> !



Depuis quelques années et notre première implantation à Nantes, on peut dire que notre équipe a déjà bien grandi ! Doucement mais sûrement, <a href="https://les-tilleuls.coop/la-cooperative/equipe" target="_blank" rel="noreferrer noopener">d’autres coopérateurs</a> rejoignent nos équipes de l’ouest de la France 🙂



Nous sommes impatients d’y être après deux années de pause !&nbsp; Et vous, vous y serez ? Dites-le nous <a href="https://twitter.com/coopTilleuls" target="_blank" rel="noreferrer noopener">sur Twitter </a>!

Les-Tilleuls.coop Sponsor Gold  et speaker du Web2day 2022 !

Nous sommes heureux de vous annoncer que nous sommes partenaires Gold du Web2day 2022. Les 1er, 2 et 3 juin, aura lieu le plus grand festival francophone des professionnels du numérique, à Nantes ! Un événement incontournable autour de la tech digne ! Il réunit chaque année plus de 10 000 participants. En onze éditions, [&hellip;]

Quoi de neuf chez Les-Tilleuls.coop ?