Un moyen plus simple de garder l’ancien code Python sain et sécurisé

Un moyen plus simple de garder l’ancien code Python sain et sécurisé

Python a ses avantages et ses inconvénients, mais il est néanmoins largement utilisé. Par exemple, Python est fréquemment utilisé dans les tâches de traitement des données, même lorsqu’il existe des langages plus appropriés parmi lesquels choisir.

Pourquoi? Eh bien, Python est relativement facile à apprendre. Quelqu’un avec une formation scientifique peut comprendre Python beaucoup plus rapidement que, disons, C. Cependant, l’accessibilité inhérente à Python crée également quelques problèmes.

Chaque fois que Python est mis à jour, cela signifie une charge de travail de refactorisation importante, qui est souvent mal gérée, voire pas du tout. Cela conduit à de mauvaises performances et à des vulnérabilités de sécurité. Mais peut-être existe-t-il un meilleur moyen : un outil pour assurer le bon déroulement et la sécurité de vos tâches Python jour après jour. Nous allons jeter un coup d’oeil.

C’est lent, mais ça fait le job

Python n’est pas le langage le plus rapide, mais malgré ses inconvénients comparatifs, vous le verrez souvent utilisé pour des opérations intensives de traitement de données. Pensez à l’apprentissage automatique, à la vision par ordinateur ou même aux mathématiques pures dans les systèmes de calcul haute performance (HPC).

Ainsi, malgré sa réputation de performance, les charges de travail très difficiles sont généralement gérées avec du code Python, simplement parce qu’il est si pratique à utiliser. Si vous avez une formation en sciences ou en mathématiques, vous pouvez relativement facilement apprendre Python et produire votre propre code qui fera le travail.

Mais, comme c’est souvent le cas, quelque chose qui est accessible peut aussi créer beaucoup de risques. Les programmeurs inexpérimentés qui écrivent du code Python peuvent avoir du mal avec des tâches que les programmeurs plus expérimentés tiennent pour acquises.

Le refactoring est une corvée… et un risque

Comme tous les langages de programmation, Python subit des mises à jour fréquentes. Le passage de Python 2.7 à Python 3.0, par exemple, a apporté tout un tas de fonctionnalités et d’améliorations. Cela signifie également que tout ce qui est écrit pour Python 2.7 doit être “refactorisé” pour Python 3.0 en raison de changements dans le fonctionnement de Python.

La refactorisation fait référence à la façon dont les programmeurs ajustent une base de code pour répondre aux changements environnementaux, comme un changement de version linguistique, ou simplement pour améliorer le code existant sous une forme ou une autre. Sans refactorisation, un passage de Python 2.7 à Python 3.0 signifie souvent que le code de Python 2.7 ne fonctionne plus aussi bien, voire pas du tout.

Et voici le problème : les utilisateurs qui ont écrit le code Python d’origine n’ont peut-être pas l’expertise nécessaire pour refactoriser. Après tout, ce sont souvent des scientifiques – et non des programmeurs expérimentés. Lorsque des programmeurs inexpérimentés tentent d’ajuster le code, il existe un risque réel que les performances se dégradent et que des bogues s’infiltrent – parfois uniquement visibles lorsqu’un cas limite apparaît. Les petits bogues deviennent une préoccupation majeure lorsque le code Python est utilisé à des fins critiques, 24 heures sur 24, 7 jours sur 7, telles que l’analyse scientifique.

La refactorisation peut également entraîner une dégradation inattendue des performances. Même s’il ne s’agit que d’une baisse des performances de 5 %, une mise à jour de code mal exécutée peut rapidement créer des factures beaucoup plus importantes sur des plates-formes HPC coûteuses et payantes.

Vous vous en tenez à l’ancien Python ? C’est un risque encore plus grand

Si vous pensez au travail acharné et aux risques liés à l’ajustement du code, il n’est pas surprenant que les utilisateurs choisissent souvent de s’en tenir aux anciennes versions de Python. L’exécution de code existant sur une version obsolète de Python évite de nombreux défis car vous n’avez pas besoin de refactoriser : vous conservez votre code tel qu’il était.

Généralement, les éditeurs de logiciels font exactement cela – ne mettent à jour leur logiciel qu’en fonction d’une nouvelle version de Python lorsqu’ils publient une nouvelle version du produit logiciel. Si vous avez acheté une version spécifique – fonctionnant sur, disons, Python 2.7, vous êtes bloqué et vous devez continuer à exécuter Python 2.7 quoi qu’il arrive.

Cela ne semble pas être un gros problème, mais s’appuyer sur des blocs de construction obsolètes et non pris en charge pour votre informatique est un cauchemar DevSecOps. De nouvelles vulnérabilités apparaîtront et les correctifs nécessaires ne viendront tout simplement pas. S’appuyer sur d’anciennes versions de langages de programmation introduit donc d’énormes risques dans votre environnement informatique.

Il y a peu de choix – ou est-ce qu’il y en a ?

La chose responsable à faire est de mettre à jour la version Python en cas de besoin et de modifier le code qui s’y exécute, mais il n’y a tout simplement pas de moyen indolore de le faire. De manière réaliste, en raison d’un manque de ressources, la refactorisation n’est souvent pas effectuée, avec des conséquences potentiellement coûteuses.

Il y a un grand besoin d’une meilleure approche, et voici ce qui est intéressant. La situation que nous venons de décrire autour des versions Python est fréquente dans le monde de l’informatique. Par exemple, il est courant pour les organisations d’exécuter des versions du système d’exploitation Linux qui ne sont plus couvertes par le support officiel des fournisseurs, prenant le risque que les vulnérabilités de sécurité ne soient pas corrigées. juste pour s’assurer que les applications critiques ne se cassent pas.

C’est un problème pour les mises à jour linguistiques ainsi que pour d’autres éléments de l’infrastructure informatique. Mais, ces dernières années, les solutions de correctifs avancées permettent aux entreprises d’étendre le cycle de vie habituel du support pour plusieurs composants, des systèmes d’exploitation entiers aux bibliothèques partagées critiques spécifiques. Chez TuxCare, nous avons développé plusieurs solutions qui prolongent le fonctionnement sûr et sécurisé des anciens logiciels au-delà de la fin de vie du fournisseur.

Exécution d’anciennes applications Python en toute sécurité

Et si la même chose pouvait être faite pour les versions linguistiques ? Eh bien, vous pouvez maintenant vous attendre à exécuter votre ancien code Python, sur une ancienne version de Python, mais sans les risques que cela comporte. Pas de constructions de langage obsolètes – et pas de vulnérabilités non plus.

En d’autres termes, la prise en charge étendue du cycle de vie des versions linguistiques, telles que Python, devient une réalité. Vous pourrez bientôt conserver votre code Python en toute sécurité sans avoir à réécrire une seule ligne de code, simplement en bénéficiant d’une prise en charge étendue du cycle de vie de Python, qui vous offre la même protection de sécurité qu’une mise à niveau de version complète.

Prêt à être déployé à des prix accessibles, le support du cycle de vie étendu Python de TuxCare aidera votre organisation à traiter les questions difficiles concernant les anciennes charges de travail Python. Gardez un œil sur notre annonce – qui arrive bientôt.

.

Leave a Comment