Open-source - Winzana https://www.winzana.com Façonnons le numérique à votre image Wed, 15 Oct 2025 08:07:16 +0000 fr-FR hourly 1 https://wordpress.org/?v=6.9.4 https://www.winzana.com/wp-content/uploads/2025/04/logo-winzana.svg Open-source - Winzana https://www.winzana.com 32 32 Installer API Platform sur un projet Symfony 3.4 https://www.winzana.com/installer-api-platform-sur-un-projet-symfony-3-4/ https://www.winzana.com/installer-api-platform-sur-un-projet-symfony-3-4/#respond Tue, 14 Oct 2025 13:29:32 +0000 https://www.winzana.com/?p=241341

L’idée de ce billet sur l’installation d’API Platform sur un projet Symfony 3.4 m’est venue lors de la réalisation d’une conférence avec l’association Ardèch’Drôm Dev sur ce même sujet.

La vidéo est disponible sur le lien suivant : Conférence API Platform

Tout est parti d’une idée simple: comment puis-je mettre en place une API Rest avancée sur une projet Symfony 3.4 déjà réalisé ? Trois solutions sont alors disponibles :

  • La première, à la mano, ce n’est même pas envisageable ! Trop longue, trop source d’erreur, mais surtout trop longue !
  • La seconde: déjà fait. Pas trop mal, assez simple à mettre en place, déjà connue et une très grosse communauté derrière.
  • La dernière solution, j’ai eu l’occasion de la découvrir lors d’un déplacement chez un client à Valence où j’y ai rencontré, par le plus grand des hasards, Kévin DUNGLAS. C’est de cette solution dont on va parler aujourd’hui.

Étant donné que je suis un grand amateur de nouvelles solutions, je me suis laissé séduire et j’ai fini par mettre le nez dans la solution. Premier constat : “READ THE F*CKING MANUAL”. Mais What ?! La doc est magnifique, un vrai régal pour les yeux (https://api-platform.com/docs/). Un moteur de recherche simple pour trouver tout ce dont on a besoin. Une version get started sur Docker, super bien réalisée, avec une compatibilité Kubernetes. Bref le décor parfait… Parfait oui, mais pour Symfony 4. Ou un projet vierge.

 

Impensable pour moi. Mon projet était déjà en place depuis bien longtemps. Une flemmingite aigüe commença à monter en moi. Mais bon, l’envie étant plus forte que tout… Et j’ai pris mon courage à deux mains !

 

Je me suis mis en quête de mettre ça en place sur tous mes projets personnels et, tant qu’à faire, rédiger un guide d’installation d’Api Platform sur ma stack actuel Symfony 3.4. En avant Guingamp…

 

Je plante le décor :

 

Projet e-commerce from scratch maison

  • Bundle en place :
    • FOSUserBundle
    • ApydataGridBundle
    • StofDoctrineExtensionsBundle
    • NelmioSolariumBundle
    • …

 

Bref rien de transcendant, la stack habituel des familles.
Maintenant, comment je vais rajouter API Platform à tout ça ?

 composer require api 

 

AHHHH la bonne blague ! Je n’ai pas Flex sur mon projet… Mais alors comment faire ? Je ne vous cache pas que j’ai cherché quelques heures et fait un Diff entre un projet vierge de Symfony 3.4 et Symfony 4, je suis tombé sur la conclusion suivante :
Pour ce faire il faut :

  • Avoir une version de PHP 7.1 minimum
  • Installer
    • Api-platform/Core
    • Dunglas/Action-Bundle
    • Nelmio/Cors-Bundle

 

Merci Composer !

Ensuite, modification du AppKernel, puis toute la petite configuration qui va bien :

  • Configuration globale

 

Pour expliquer, ce petit bout de configuration sur “sensio_framework_extra” n’est pas lié à API Platform. Cette configuration permet d’injecter mes entités directement à mes controllers sans être obligé d’utiliser l’Annotation @ParamConverter, mais tout est expliqué ici.

  • Ajout route/api

 

Cette configuration a plusieurs intérêts. Le premier c’est de pouvoir diffuser votre API sur l’entrypoint /api mais cela permet également d’exposer, grâce à API Platform, un client WEB Swagger (https://swagger.io/), permettant d’avoir une version documentée de votre API, diffusable ou non 😉.

 

Et maintenant il n’y a plus qu’à !

Voilà ! On ne s’est pas froissé un muscle et tout est prêt pour développer mon API.

 

Qu’est ce qu’il me reste à faire maintenant ? Si vous utilisez les annotations, la manip est très simple : il vous suffit d’ajouter l’annotation @ApiResource à la classe de votre entité.

 

Mais ne soyons pas trop gourmands pour aujourd’hui. Nous verrons dans un prochain article comment implémenter API Platform.

The post Installer API Platform sur un projet Symfony 3.4 first appeared on Winzana.

]]> https://www.winzana.com/installer-api-platform-sur-un-projet-symfony-3-4/feed/ 0 Comment transformer un higher order component en React Hook https://www.winzana.com/comment-transformer-un-higher-order-component-en-react-hook/ https://www.winzana.com/comment-transformer-un-higher-order-component-en-react-hook/#respond Tue, 14 Oct 2025 13:27:51 +0000 https://www.winzana.com/?p=241336

Aujourd’hui, dans cet article, nous allons voir comment remplacer le pattern Higher Order Component par React Hook. Au sein de cet article, vous trouverez les avantages et inconvénients de chacun de ces deux outils.

Higher Order Component

 

Le HOC est un pattern permettant d’encapsuler un composant et d’en modifier le comportement sans toucher au composant encapsulé ou en injectant des propriétés calculées par le HOC. En clair, le HOC est une fonction qui retourne un composant dont le comportement est modifié par celui-ci.

 

Un exemple avec un HOC qui n’affiche le composant que si l’utilisateur a les droits nécessaires :

const withRole = (WrappedComponent, roleRequired) =>{ return class extends React.Component { constructor(props){ super(props); this.state = { granted: false }; } componentDidMount() { isUserGranted(roleRequired).then(granted =>; {
this.setState({ granted });
});
}
render(){
const { granted } = this.state;
return granted ? : null;
}
};
};

 

Pour l’utiliser il suffit de wrapper le composant :

const GrantedView = withRole(AwesomeView, ‘<role_required>’);

 

On identifie tout de suite le problème, si on veut définir plusieurs HOC on obtient :

 withAuthentication(withRole(withUser(WrappedComponent)));

 

Pas de soucis, compose à la rescousse :

const UserComponent = compose(
withAuthentication,
withRole,
withUser,
);

 

Mais en plus d’être verbeux, cela génère une hiérarchie telle que :

<withAuthentication>
<withRole>
<withUser>
<UserComponent/>
</withUser>
</withRole>
</withAuthentication>

 

 

Il y a un donc non seulement une complexité non négligeable pour un simple isGranted et cette complexité au niveau de la hiérarchie a un impact direct sur la performance. A noter qu’un HOC a parfaitement sa place pour un isAuthenticated par exemple dans un router. Mais dans notre cas on va simplifier notre HOC pour le rendre encore plus réutilisable avec des hooks.

React Hook

 

Les règles à respecter pour des hooks fonctionnels :

https://reactjs.org/docs/hooks-rules.html

Si une de ces règles n’est pas respectée, un comportement inattendu peut survenir dans l’application.

Comme pour le Higher Order Component, le principe est de modifier/surcharger le comportement d’un composant, sans tomber dans le piège du high order component hell et du nesting hell, sauf que cette fois c’est le composant lui même qui appelle le hook, et c’est ce hook qui contiendra la logique.

Comme pour le HOC, React Hook possède quelques inconvénients. Premièrement, l’appropriation des connaissances pour concevoir un Hook. Les hooks sont maintenant bien assimilés par la communauté, mais si vous n’en avez encore jamais fait, écrire votre premier custom hook peut vous donner des boutons !
“Passer des classes à … ça ?!”
Le principal inconvénient des hooks, c’est le couplage fort (composition) entre le composant qui l’utilise et le hook. Regardons ça !

 
Transformer un HOC en React Hook
On va donc créer un custom Hook, qui va se charger de faire l’appel API isUserGranted, et nous retourner la réponse. Ce hook impacte directement le cycle de vie du composant qu’il implémente :
 
const withRole = ({ roleRequired }: Props) => {
const [isGranted, setGranted] = useState(false);
useEffect(() => {
isUserGranted(roleRequired).then(granted => {
setGranted(granted)
});
}, []);
return isGranted
};

 

Je peux utiliser le hook directement :
const MyPage = (props) => {
const isGranted = withRole(« role »);
return ….
}

 

 
Ou encore l’utiliser pour faire un composant qui affichera ou pas son enfant en fonction de la résolution de la variable isGranted :
 
export const Granted = ({children, roleRequired}) => { const isGranted = withRole(roleRequired); return isGranted ? children : null; }

 

 
On a utilisé ici un hook react : useEffect, qui est l’équivalent du componentDidMount(). Le component MyPage, sera de nouveau “rendu” lorsque la variable isGranted sera résolue par notre web-service. Le premier avantage, c’est la simplicité. C’est lisible, toute la complexité inutile a disparu. La hiérarchie est plate, pas de composant supérieur à l’horizon. Cependant il y a un inconvénient, que l’on a pas avec les HOC, le couplage fort. La communauté React est bien au courant de ce défaut, maintenant nous utilisons les hooks de manière générale, ces hooks vont surement évoluer à l’avenir.
 
Des bonnes raisons d’utiliser un HOC au lieu d’un Hook :
 
–  Il ne génère pas plus d’une props a passer au composant encapsulé.
 
– Il ne crée pas de dépendances implicites ( un ordre particulier dans les HOC par exemple ).
– Un comportement par défaut doit être partagé sur plusieurs components.
 
C’est ainsi que se termine notre article sur la transformation d’un HOC en React Hook.

The post Comment transformer un higher order component en React Hook first appeared on Winzana.

]]> https://www.winzana.com/comment-transformer-un-higher-order-component-en-react-hook/feed/ 0 Pourquoi et comment implémenter Flow sur un projet React Native https://www.winzana.com/pourquoi-et-comment-implementer-flow-sur-un-projet-react-native/ https://www.winzana.com/pourquoi-et-comment-implementer-flow-sur-un-projet-react-native/#respond Tue, 14 Oct 2025 13:25:38 +0000 https://www.winzana.com/?p=241331

Intro

 

Flow est un outil de développement déclaratif qui permet d’ajouter du typage de manière statique sur du Javascript et JSX. Il permet de réduire les potentiels bugs liés au développement du programme durant le développement et non durant le runtime. Il permet entre autres de fournir une description plus complète lors de l’autocomplétion. C’est entre autres une des recommandations de l’équipe React : https://fr.reactjs.org/docs/static-type-checking.html

Dans cet article nous aborderons quatre points principaux :

  • L’utilité de Flow
  • L’implémentation Flow
  • Exemples concrets d’utilisation
  • Comparaison rapide avec TypeScript

Pourquoi j’utiliserai Flow ?

 

La première fonctionnalité de Flow est le typage des variables. En React Native ou plutôt JavaScript, les variables ne sont pas typées. Ce qui au cours de l’évolution du programme peut devenir un handicap en termes de maintenance, et de fiabilité. Les changements de types au cours du déroulement du programme peuvent être dramatiques s’ils ne sont pas maîtrisés. Or avec Flow, on peut maîtriser ces changements de type, à conditions de bien les typer. Et bien sûr, grâce au typage des variables, on obtient une autocomplétion encore plus intelligente et plus précise.

 

Implémentation et utilisation de Flow

 
Pour commencer à utiliser la bibliothèque Flow, il vous faut tout d’abord l’installer
 
yarn add flow-bin


Ou


npm install --save flow-bin

 

 
Ensuite, on modifie le package.json (si celle-ci n’est pas ajoutée automatiquement lors de l’installation).
{
//…rest,
« flow »: »flow »
}

 

On initialise Flow via la commande ci-dessous :
npm run flow init
Ou
yarn run flow init
Et voilà ! Flow est installé.
 
Étayons un peu plus le sujet avec flow focus-check. C’est une bibliothèque comprise dans Flow qui permet de vérifier les fichiers passés en pre-commit (ce qui est très utile pour déceler de potentielles erreurs qui peuvent être envoyées sur le git). C’est-à-dire que Flow va uniquement vérifier les dépendances des fichiers qui seront poussées au serveur et les fichiers eux-mêmes bien sûr.
 
Utilisation de Flow
Il faut ajouter à chaque début de fichier auquel on veut que Flow reconnaisse les fichiers qu’il doit parser :
// @flow
on peut désormais utiliser la commande :
yarn run flow
ou :
npm run flow
 
Celle-ci permet de demander à Flow de vérifier que notre code Javascript est typé correctement. Flow permet de signaler des erreurs de type de manière statique (au niveau de l’IDE) durant le développement.
 
Exemples concrets
Au sein de cette sous-partie, nous allons voir les points évoqués lors de la présentation de Flow. Vous aurez donc des exemples concrets pour chaque point. Pour l’occasion, nous créons un petit projet qui permet d’incrémenter un compteur. Tout d’abord, la déclaration des props ne se fait plus via les prop-types, mais via Flow :
type Props = {
/**
* Count value to increment
*
* @type {number}
*/
counter: number;
}

 

 
Ensuite on définit la View, et on type les props reçues par le composant :
const CounterView = ({ counter, incrementCounter }: Props) => (
<View style=>
<Text>{counter}</Text>
<Button onPress={incrementCounter} title= »Increment » />
</View>
);
export default CounterView;

 

Dans le container on instancie la View :
 
const CounterContainer = () => {
const [counter, increment] = useState(0);
const incrementCounter = useCallback(() => {
increment(counter+1);
},[counter]);
return (<CounterView />);
}

 

Et on constate que Flow nous indique que le composant CounterView n’est pas implémenté correctement.
 
On implémente correctement notre CounterView.
return (<CounterView counter={counter} incrementCounter={incrementCounter} />);

 

 
On ajoute maintenant un label optionnel à notre CounterView :
type Props = {
….restProps
/**
* Optional Label for our counter
*
* @type {string}
*/
label?: string;
}

 

 
 
Si on retourne sur le fichier de notre CounterContainer, on se rend compte que Flow ne lance aucune erreur puisqu’il n’y en a pas. Label est optionnel, donc mon composant doit être fonctionnel même si je ne déclare pas la propriété label. Maintenant coté View, je veux que mon label soit en majuscules, pour qu’il soit bien visible.

Donc on tente ça :

<Text>{label.}</Text>

 

L’autocomplétion ne fonctionne pas, alors on force, parce que cette méthode on la connait par coeur quoi :

 <Text>{label.toUpperCase()}</Text>

 

Mais là Flow n’est pas d’accord avec nous, et c’est normal ! On peut également caster nos variables, et faire la majorité des choses qu’on peut faire avec un langage comme Java ou Swift en termes de typage.

 

En l’état mon composant n’est pas fonctionnel si label n’est pas défini ! Et Flow me le dit avant même que je lance l’application sans définir de label. Donc je vérifie que label soit bien défini pour afficher le label !

  {label && <Text>{label.toUpperCase()}</Text>}

 

Bingo ! Mon composant est fonctionnel !

 

Bien évidemment avec cet exemple, nous avons seulement vu les bases de Flow, comment on l’utilise, pourquoi l’utiliser. Mais sur un projet de grande envergure, le typage est d’une grande aide, et permet d’assurer une certaine fiabilité sur le long terme. Généralement Flow s’utilise au cours du développement et également dans une chaîne d’intégration continue.

 
Rapide comparatif entre TypeScript et Flow
TypeScript est un langage de programmation Open Source conçu par Microsoft qui est utilisé pour le typage statique donc sensiblement la même utilité que Flow (sauf que Flow vient de Facebook). Vous l’aurez compris TypeScript est un langage de programmation alors que Flow n’est qu’un outil de productivité.
 
Sur ce point là, Flow est d’une utilisation bien plus simple que TypeScript. Comme dit précédemment, TypeScript est un langage de programmation, il faut donc apprendre la syntaxe, ce qui peut prendre du temps. Or Flow n’étant qu’un outil de productivité, on ajoute juste //@flow (comme vu dans la rubrique “Utilisation de Flow”). Flow possède donc un certain avantage sur la rapidité de prise en main.
 
Le choix entre TypeScript ou Flow ne se résume pas seulement à la prise en main mais aussi à l’environnement dans lequel vous travaillez. Bien souvent les développeurs utilisant Angular vont opter pour l’utilisation de TypeScript qui représente le langage prédominant de cette technologie. Or si vous utilisez React, Flow s’intègre beaucoup mieux à une architecture déjà en place.
 
Pour conclure notre comparatif, il n’y a pas de “meilleur” entre Flow et TypeScript. Ils ont des utilisations similaires mais chacun avec des spécificités utiles. L’environnement d’utilisation est souvent un facteur de décision entre TypeScript et Flow. Néanmoins il est important de noter que, actuellement, la communauté React Native/ReactJS a tendance à s’orienter vers TypeScript.

Conclusion :

Et c’est ainsi qu’on termine cet article sur Flow. Tout du long de cet article, vous avez pu lire l’intérêt de Flow, comment installer sa bibliothèque dans un projet React Native et comment l’utiliser avec des exemples concrets, ainsi qu’un comparatif entre TypeScript et Flow qui permet de peser le pour et le contre de chacun de ces outils.

The post Pourquoi et comment implémenter Flow sur un projet React Native first appeared on Winzana.

]]> https://www.winzana.com/pourquoi-et-comment-implementer-flow-sur-un-projet-react-native/feed/ 0 Vincent Journel vous présente comment créer des API de qualité avec API Platform https://www.winzana.com/vincent-journel-vous-presente-comment-creer-des-api-de-qualite-avec-api-platform/ https://www.winzana.com/vincent-journel-vous-presente-comment-creer-des-api-de-qualite-avec-api-platform/#respond Tue, 14 Oct 2025 13:16:25 +0000 https://www.winzana.com/?p=241326

Une API (Application Programming Interface) est une interface de programmation permettant à deux applications de communiquer et d’échanger des données. Aujourd’hui, nous retrouvons des API de partout. Lorsque vous associez votre compte Facebook et votre compte Instagram, vous ne voyez rien mais pourtant les API font tout le boulot pour publier sur vos 2 réseaux en même temps et bien d’autres choses. Alors dans le développement, les API deviennent des éléments incontournables. Mais comment créer une API ? Nous vous invitons à la conférence animée par Vincent Journel, directeur technique de WinzAna. Il vous explique comment créer des APIs avec API Platform mais surtout, comment le faire bien !
Maintenant installez-vous confortablement, prenez de de quoi noter et surtout, enjoy !

The post Vincent Journel vous présente comment créer des API de qualité avec API Platform first appeared on Winzana.

]]> https://www.winzana.com/vincent-journel-vous-presente-comment-creer-des-api-de-qualite-avec-api-platform/feed/ 0 GitHub : Exclude system gesture area https://www.winzana.com/github-exclude-system-gesture-area/ https://www.winzana.com/github-exclude-system-gesture-area/#respond Mon, 13 Oct 2025 11:55:06 +0000 https://www.winzana.com/?p=241291

Nos Winzanautes sont de véritables férues de codes ! 🧑‍💻

En plus de leur mission en interne à Winzana, ils continuent à pianoter sur leur clavier et à développer de nouveaux projets !

Ici, c’est notre pôle mobile qui est à l’honneur qui sont parvenus à développer un solution permettant de gérer les conflits de détection de gestes entre react-naviguation et android 10 ! 📱

Mais le plus dans tout ça, c’est que c’est entièrement disponible en open-source.

En d’autres mots, si vous souhaitez la reproduire, l’améliorer ou tout simplement y jeter un œil, vous pouvez y aller ! 👋

Retrouvez tout les détails directement sur notre GitHub : https://github.com/Winzana/rn-exclude-system-gesture-area

The post GitHub : Exclude system gesture area first appeared on Winzana.

]]> https://www.winzana.com/github-exclude-system-gesture-area/feed/ 0 GitHub : Animated Tab Bottom Bar for react-navigation ! 🌊 https://www.winzana.com/github-animated-tab-bottom-bar-for-react-navigation-%f0%9f%8c%8a/ https://www.winzana.com/github-animated-tab-bottom-bar-for-react-navigation-%f0%9f%8c%8a/#respond Mon, 13 Oct 2025 11:52:54 +0000 https://www.winzana.com/?p=241286

Nos Winzanautes sont de véritables férues de codes ! 🧑‍💻

En plus de leur mission en interne à Winzana, ils continuent à pianoter sur leur clavier et à développer de nouveaux projets !

Ici, c’est notre pôle mobile qui est à l’honneur et plus particulièrement son chef d’orchestre Jérémy qui est parvenu à développer une barre de menu pour mobile avec un effet de vague, disponible en react ! 🌊📱

Tout est détaillé et entièrement disponible en open-source.
En d’autres mots, si vous souhaitez la reproduire, l’améliorer ou tout simplement y jeter un œil, vous pouvez y aller !

Tout est accessible ici, sur GitHub : https://github.com/Jm-Zion/rn-wave-bottom-bar 

La preview de l’animation est ultra smooth, un véritable plaisir pour les yeux 😎

The post GitHub : Animated Tab Bottom Bar for react-navigation ! 🌊 first appeared on Winzana.

]]> https://www.winzana.com/github-animated-tab-bottom-bar-for-react-navigation-%f0%9f%8c%8a/feed/ 0 Serverless avec Kubernetes en utilisant Knative https://www.winzana.com/serverless-avec-kubernetes-en-utilisant-knative/ https://www.winzana.com/serverless-avec-kubernetes-en-utilisant-knative/#respond Tue, 15 Apr 2025 15:02:38 +0000 https://www.winzana.com/?p=240384

L’écosystème du cloud computing connaît une évolution rapide avec l’intégration de solutions serverless avancées. Parmi celles-ci, Knative, utilisé avec Kubernetes, se distingue comme une solution puissante pour les architectures serverless. Cet article se penche sur les aspects techniques de Knative et de son intégration avec Kubernetes, expliquant pourquoi et comment cette combinaison est devenue un choix stratégique pour les entreprises technologiquement avancées.

Knative : Extension Serverless de Kubernetes

Knative est une plateforme open-source innovante conçue spécifiquement pour optimiser et étendre les fonctionnalités de Kubernetes dans le contexte du computing serverless. Voici un aperçu détaillé de ses trois composants clés :

Tekton Pipelines – Remplaçant de Knative Build

Fonctionnalités avancées de CI/CD : Tekton Pipelines apporte une solution de CI/CD native à Kubernetes, remplaçant la fonctionnalité de build de Knative. Il offre une personnalisation plus approfondie et une flexibilité accrue pour l’automatisation du processus de construction et de déploiement des applications.

Intégration dans les Workflows Kubernetes : En s’intégrant directement dans l’écosystème Kubernetes, Tekton permet une gestion plus cohérente et homogène des workflows de construction et de déploiement.

Serving

Modèle de déploiement Scalable : Serving propose un modèle de déploiement d’applications qui prend en charge le scaling automatique. Cela inclut le scaling horizontal en fonction de la demande, ainsi que la capacité de réduire les ressources à zéro lorsqu’une application est inutilisée (scaling à zéro).

Routing Intelligent : Il intègre un système de routing intelligent qui dirige le trafic vers les différentes révisions de l’application, facilitant le déploiement progressif et le testing A/B.

Support des Conteneurs : Serving est conçu pour prendre en charge divers types de conteneurs, offrant ainsi une grande flexibilité dans le choix des technologies et des langages de programmation.

Gestion de l’État : Bien que principalement axé sur les applications stateless, Knative Serving peut également être configuré pour gérer certaines formes d’état, ce qui le rend polyvalent pour une large gamme d’applications.

Eventing

Gestion des Événements : Eventing est le composant de Knative qui gère les événements au sein de l’écosystème Kubernetes. Il facilite la création, la gestion et le routage des événements entre les services.

Sources d’Événements : Il peut se connecter à diverses sources d’événements, internes ou externes, telles que les bases de données, les systèmes de messagerie ou les services cloud.

Déclencheurs et Abonnements : Eventing permet de définir des déclencheurs spécifiques qui activent les microservices en réponse à des événements, permettant ainsi de créer des architectures basées sur les événements.

Flexibilité et Interopérabilité : Ce composant offre une grande flexibilité et interopérabilité, permettant aux développeurs de lier facilement leurs services à un large éventail d’événements et de sources.

Broker layer : Possibilité d’utiliser des outils tel que Kafka ou RabbitMQ

Quel avantage d’utiliser Knative pour vos équipes de développeurs ?

Développement Agile : Knative accélère le développement et le déploiement des applications grâce à sa capacité à gérer automatiquement les aspects de l’infrastructure.

Scalabilité Simplifiée : Knative offre une scalabilité automatique, y compris le scaling à zéro, ce qui est essentiel pour les applications à charge variable.

Intégration CI/CD Facilitée : Knative s’intègre facilement dans les pipelines CI/CD, réduisant le temps et les efforts nécessaires pour la livraison continue.

Gestion des Événements et des Services : Knative simplifie la création d’applications basées sur les événements, permettant aux développeurs de se concentrer sur la logique métier.

Environnement Kubernetes Optimisé : Utiliser Knative sur Kubernetes offre une expérience améliorée, en profitant de la robustesse et de la sécurité de Kubernetes.

Un argument significatif en faveur de Knative pour les équipes de développement est la capacité à délivrer des environnements distincts pour chaque fonctionnalité. Cette approche permet :

Déploiement par fonctionnalité : Les développeurs peuvent tester de nouvelles fonctionnalités dans des environnements isolés avant leur intégration dans la production.

Rapidité et flexibilité : Chaque fonctionnalité peut être développée, testée et déployée indépendamment, accélérant le processus de développement et de mise sur le marché.

Réduction des risques : Les erreurs ou les problèmes liés à une fonctionnalité spécifique peuvent être identifiés et résolus dans un environnement isolé, sans impacter l’ensemble du système.

Comment aborder la mise en place de Knative

Les Défis

Complexité Technique : Kubernetes est un système complexe avec une courbe d’apprentissage élevée.

L’intégration de Knative ajoute une couche supplémentaire de complexité. Même s’il facilite l’usage de Kubernetes, il faut avoir une connaissance des concepts de la kubernetisation (Pod, Deployment, Service, PVC, …)

Expertise Requise : La mise en œuvre efficace nécessite une équipe avec une expertise approfondie en Kubernetes et Knative.

Gestion des Ressources : La gestion optimale des ressources et le scaling automatique requièrent une configuration et un monitoring attentifs.

Solutions

Formation et Certification : Investir dans la formation et la certification de l’équipe , d’abord sur Kubernetes puis sur Knative.

Automatisation et Outils : Utiliser des outils pour automatiser et simplifier la gestion des clusters Kubernetes tels qu’ArgoCD, Kaniko, Tekton.

Partenariats Stratégiques : Collaborer avec des partenaires technologiques ou des consultants spécialisés pour combler les lacunes en matière de compétences.

Évaluation Continue : Évaluer régulièrement l’architecture pour assurer son évolutivité et sa maintenance.

Approche Stratégique

Évaluation des besoins : Comprendre clairement les besoins de l’entreprise et comment Knative peut les adresser.

Pilotage et Phases : Commencer par des projets pilotes avant de déployer à grande échelle.

Feedback et Adaptation : Être réactif au feedback de l’équipe de développement pour améliorer continuellement les processus et les outils.

Ces stratégies peuvent aider à surmonter les défis techniques tout en maximisant les avantages de Knative en termes de flexibilité, de scalabilité et d’efficacité des coûts.

Applications Pratiques de Knative

ETL Dynamique pour le Traitement de Données Volumineuses pour le département du Vaucluse

Scénario : Traitement des données d’import volumineuses d’APIDAE.

Détails Techniques : Utilisation de Knative pour orchestrer des conteneurs éphémères qui s’activent pour traiter les données et s’éteignent une fois le travail accompli, optimisant ainsi les ressources et les coûts.

Environnements de Développement Agile avec Knative

Scénario : Mise en place d’environnements de développement avec scalabilité flexible.

Détails Techniques : Configuration de Knative pour déployer des environnements à la demande avec scalabilité de 0 (inactif) à n (actif), selon les besoins, réduisant ainsi les coûts d’infrastructure.

Architecture Macro-service pour Yamay

Scénario : Gestion de trafic élevé et traitement de données en tâche de fond pour Yamay.

Détails Techniques : Mise en place de services Knative capables de gérer des pics de charge tout en exécutant des opérations de traitement de données parallèles, garantissant ainsi performance et analyse statistique efficace.

Conclusion : Adopter Knative pour une Innovation Agile dans le Cloud

En conclusion, Knative, combiné à Kubernetes, représente une évolution majeure dans le cloud computing, offrant une flexibilité, une scalabilité et une efficacité accrues pour les architectures serverless. Pour les équipes de développement, Knative apporte agilité et innovation, permettant des déploiements par fonctionnalité et une réduction des risques. Néanmoins, les défis techniques, tels que la complexité de Kubernetes et la nécessité d’une expertise approfondie, doivent être abordés par une formation adéquate, l’utilisation d’outils automatisés, et une évaluation continue. L’adoption de Knative est une démarche stratégique, nécessitant une planification soignée et une adaptation constante. En fin de compte, Knative est un outil puissant pour les organisations cherchant à optimiser leur présence dans le cloud et à accélérer leur développement d’applications serverless.

The post Serverless avec Kubernetes en utilisant Knative first appeared on Winzana.

]]> https://www.winzana.com/serverless-avec-kubernetes-en-utilisant-knative/feed/ 0