Pourquoi Open Suse Leap 16.1 va faire beaucoup de bien au DevSecOps, et à Kubernetes ?

Le 1er novembre, Open Suse officialisait une mise à jour "mineure" de Leap (16.1). Cette nouvelle version arrive avec la possibilité d'installer un serveur en mode immuable. C'est à dire, avec un système en lecture seule. Ceci n'est pas très nouveau dans le monde Linux. Avec Kubic, et MicroOS, Open Suse a fait partie des premières distributions à adopter ce mode de déploiement.

Ce qui est vraiment nouveau aujourd'hui, c'est qu'Open Suse unifie la manière de livrer Leap. Pour ceux qui ne sont pas familiers avec Open Suse :

  • Leap 16.1 s'appuie sur Suse Linux Enterprise Server (SLES).
  • Il faut voir Leap comme étant leur distribution la plus stable, et la plus moderne.
  • Un concurrent direct à Rocky Linux, et donc par extension Red Hat.
  • C'est la distribution qui se rapproche le plus de ce que cherchent les entreprises.

Dans un serveur Leap immuable, on va retrouver par défaut :

  • rpm
  • selinux
  • systemd
  • firewalld
  • transactional-update (une CLI pour gérer les mises à jour automatiques, reboot, snapshot, rollback, ...)
  • …

Tout ce que l'on peut déjà trouver dans MicroOS, mais avec une adoption un peu plus "raisonnable" (LTS oblige). On peut donc monter un serveur K8S sans avoir de breacking change lors des mises à jour. Ce qui n'était pas le cas avec MicroOS. Et contrairement à un Talos Linux, on a un OS qui ne fait pas que du K8S, et qui servir à installer les autres applications de sa stack d'entreprise. Je cois qu'il y a des admins qui vont craquer.

Je pense que l'on a là un OS très solide pour monter sa stack DevSecOps.,

Jérémy Jeanson

Quelle stratégie choisir pour conteneuriser une application .net 11 ?

.net 11 arrive à grands pas. Il est donc venu le temps de se poser moult questions sur ce qui change avec cette nouvelle version. Il est aussi temps de confirmer, ou contredire quelques rumeurs.

Avant d'aller plus loin, faisons un petit rappel des approches disponibles avec .net 11, et 10. Pour conteneuriser une application, nous avons deux solutions :

  • dockerfile : l'approche historique, commune à toutes les technologies.
  • dotnet publish : l'approche moderne disponible depuis .net 7.

Fidèle à mes mauvaises habitudes, je commencerai par la fin, en vous livrant l'approche que je recommande pour .net 10, et 11 : dotnet publish, sans aucune hésitation.

Maintenant, abordons la raison de ce choix, et commençons par tordre le cou à quelques idées reçues.

Il ne peut en rester qu'un !

Non, .net ne va pas soudainement abandonner dockerfile. Ceci est impossible. On ne peut pas vous interdire de conteneuriser une application .net, ou autre avec un dockerfile.

L'un sait tout faire, l'autre ne sait gérer que les cas simples ?

Dockerfile serait la seule véritable solution pour créer des images complexes. Dotnet publish ne serait en mesure que de publier le dossier bin d'une application .net. Voici les deux affirmations qui le dérangent le plus. Oui on peut tout faire avec dockerfile. Il en est de même avec dotnet pulish, car celui-ci s'appuie sur msbuild. On peut donc utiliser le XML d'un projet pour effectuer toutes sortes d'opérations. Tout comme on le fait avec msbuild depuis plus de 20 ans.

Seul dockerfiel offre de bonnes performances

Voilà une affirmation qui me décoiffe. Oui, c'est compliqué vu ce qui me reste sur le caillou, mais une expression reste une expression. Ce n'est pas moi qui fais les règles. Dockerfile, et dotnet publish peuvent fournir des performances similaires. Si votre image est le produit d'une opération de type multistage, dotnet publish devraient vous offrir les meilleures performances. Ceci est lié au fait que msbuild profite davantage des précédentes compilations que dockerfile.

Rapport complexité / optimisations

L'optimisation de dokerfile est un peu plus complexe. Il faut bien comprendre ce que l'on fait si l'on veut optimiser un multistage. Pour accélérer les builds sur les PC de développement, il est souvent plus facile de créer plusieurs images. On se retrouve donc à avoir à maintenir, et publier davantage d'images.

Comme évoqué un peu plus tôt, dotnet publish profile de msbuild. Il offre donc de bonnes performances sans trop de connaissances, et sans compliquer la maintenance. Si en plus, vous maitrisez bien vos builds .net, vous trouverez rapidement vos marques, et des solutions pour accélérer la build.

CI / CD et Pipelines

Côté DevOps, il n'y a pas de comparaison possible :

  • dockerfile : dépendance à dotnet, et docker.
  • dotnet publish : dépendance à dotnet.

Sur ce point on me dit souvent que docker est une dépendance facile à gérer. Je ne peux pas être d'accord. En fonction de votre plateforme DevOps, vous allez préférer éviter docker pour des raisons de performances ou compatibilité. Ce peut être le cas de certain mixes de cluster k8s, OS, cloud providers (le docker in docker que certain aiment tant détester, et que toutes les solutions ne supportent pas).

De plus, je rappelle un sujet qui parfois dérangent les personnes fans du multistage dockerfile : on ne créé jamais une image sans avoir exécuté des tests unitaires. Ajourd'hui, les solutions de workflow / pipelines, CI / CD s'appuient presque toutes sur des images. On complexifie alors le nombre d'images à gérer, et donc le nombre de versions à suivre, en plus des images référencées dans les dockerfile. Alors qu'avec dotnet publish, l'image de base donet/sdk suffit pour la build, les test, et dotnet publish (+l'image dotnet référencé dans votre projet .net).

Conclusion

J'espère vous avoir convaincu des avantages de donet publish pour .net11. Si vous n'êtes pas d'accord, faites le savoir ;)

Jérémy Jeanson

Pourquoi je préfère gérer un projet SQL Server, qu'un projet PostgreSQL ?

Je vous propose aujourd'hui de partager avec vous un retour d'expérience concernant les SGBDs. Après des années à jouer avec de multiples solutions, il y a un point qui me fait presque toujours préférer SQL Server à d'autres solutions. Il s'agit de la problématique des montées de version.

Oui, c'est beau d'avoir un super projet, avec une base de données que l'on maitrise sur le bout des doits.

Mais que se passe-t-il après quelques années ? Votre SGBD, et la méthode utilisée pour l'héberger vous permettent-ils de ne pas avoir de coupure de service ? Mon équipe a les compétences pour ce travail ?

Vous ne savez pas... ou du moins vous pensez que "ça va bien se passer, car tout le monde utilise cet outil".

La problématique

Aujourd'hui, il y a trois solutions majeures pour disposer d'une base de données :

  • Service Cloud.
  • Kubernetes on-premise, ou Cloud (AKS, GKS,...).
  • On-premise.

Chacun va avoir son processus pour la mise à jour, et nécessite que votre équipe le maitrise. Pour la suite de cet article je vai comparé SQL Server à PosgreSQL, car ce sont les SGBD. Mes motivations sont simples :

  • J'ai l'expérience de ces deux SGBD dans l'intégralité des cas présentés aujourd'hui.
  • Ce sont les seuls qui trouvent grâce à mes yeux ;)

Oui, même si je préfère m'appuyer sur SQL Server, j'apprécie beaucoup PosgreSQL.

On-premise

Commençons par l'approche historique, le "on premise" :

  • SQL Server : coupure du service, on lance le setup, et on se laisse guider.
  • PostgreSQL : coupure du service, on lance un script, et on se laisse guider.

Sur SQL Server, si vous avez un super DBA vous pouvez monter une architecture "zero downtime". Mais ce n'est pas donné, et il faut avoir les compétences.

Sur PostgreSQL, les solutions de sync / cutover sont possibles, là encore, il faut un bon DBA, car il y a des subtilités concernant les LOBS, et les séquences.

Kubernetes

C'est certainement sur Kubernetes qu'il y a le plus de différences. Par défaut, si l'on prend les images de bases et que l'on suit la documentation :

  • SQL Server : zéro coupure.
  • PostgreSQL : coupure du service, exécution d'un script.

Mais si on utilisé CloudNativePG pour sont déploiement de PostgreSQL, on peut effectuer des montés de versions sans coupure de service. Si vous utilisez déjà PostgreSQL sans CloudNativePG, il est possible de procédé à une migration du style sync /cutover (comme on-premise, il faut avoir un bon DBA sous la main).

Si vous ne connaissez pas CloudNativePG, prenez 5 minutes pour aller sur ce site. Cela vaut vraiment le détour. Ensuite, vous ne déploierez plus jamais PostgreSQL autrement ;)

Cloud

Sur le Cloud, là où le SAAS est roi, tous les SGBD ne sont pas logés à la même enseigne :

  • SQL Server : Sur Azure, on utilise toujours la dernière version. Il n'y a donc pas d'upgrade à gérer.
  • PostgreSQL : Azure, AWS, et GCP permettent de faire des montés der version. Mais il y a toujours une période d'indisponibilités des bases de données.

La seule solution pour approcher d'un upgrade sans coupure est donc de disposer d'un très bon DBA. Celuic- aura la charge de vous monter un plan de sync / cutover entre deux instances. Il faut donc des compétences, et consommer un peu plus de services cloud le temps de l'upgrade.

Conclusion

Seul SQL Serveur fourni des expériences d'upgrade sans coupure de service, sans rien avoir à configurer (Cloud, et K8S). Le nombre de compétences utiles est alors réduit.

Voilà pourquoi j’apprécie autant avoir à maintenir des projets qui utilisent SQL Server ;)

Jérémy Jeanson

Comment améliorer la qualité de son code .net, tout de suite, pour 0€, avec Azure DevOps ?

Dès que l'on parle DevOps, et qualité, on s'attends à vir arriver la grosse artillerie. Des solution couteuses, et/ou compliquées.

Fort heureusement avec Azure DevOps, il existe une solution simple et qui fonctionne "out of the box"

Il s'suffit d'activer la couverture de code lors des builds. En plus de rapports très complets, la première page de ceux-ci fourni une indication sur les méthodes qui peuvent poser problèmes (crap code , complexités).

Information 
Line coverage 
Branch coverage 
Method coverage 
Parser: 
MultiReport (14x Cobertura) 
4089 
Assemblies: 
98% 
Covered lines: 
12 
Uncovered lines: 
48 
88% 
Covered branches: 
856 
Classes: 
216 
Feature is only available for sponsors 
Total branches: 
964 
Files: 
224 
Coverable lines: 
4137 
Total lines: 
12242 
Branch coverage: 88.7% 
Upgrade to PRO version 
Tag: 
Line coverage: 
98.8% 
Risk Hotspots 
Cyclomatic 
Assembly 
Class 
Method 
Crap Score 
complexity 
52 
52 
22 
22 
20 
20 
18 
18 
16 
16

Simple à mettre en place, et rapide à prendre en main.

Bien évidemment, vous n'avez pas tous les raffinements d'un NDepend, ou d'un Sonar mais c'est un début, et cela ne coute rien.

Jérémy Jeanson

CS9113: le petit warning qui mériterait une plus longue description.

Je profite de cet article pour mettre en avant un petit warning, dont la description est très peu parlante sortie de son contexte :

CS9113: Parameter is unread.

Celui-ci concerne une classe qui utilise un constructeur principal. L'un des arguments du constructeur n'est pas utilisé. Il peut donc être supprimé.

Petite référence vers la documentation : Resolve errors related to constructor declarations and module initializers - C# reference | Microsoft Learn

En soi, rien de bien compliqué. Mais je trouve la description "CS9113: Parameter is unread" un peu courte. Dans mon cas, je venais de modifier le code concerné. J'ai donc vite compris l'origine du problème. Hors contexte, j'aurai préféré une description un peu plus longue comme le "CS0168: The variable 'var' is declared but never used".

Jérémy Jeanson