Programmer
AC23.01 — Automatiser l’administration système avec des scripts
Ce que j’ai fait
J’ai réalisé plusieurs scripts sous Linux afin d’automatiser différentes tâches d’administration système et réseau. Ces scripts me permettaient par exemple de vérifier automatiquement certains services, lancer des commandes réseau, analyser des résultats ou simplifier certaines manipulations répétitives utilisées dans les projets réalisés durant la formation. J’ai également utilisé des scripts Bash afin de gagner du temps pendant certaines phases de test et de configuration.
Pourquoi je l’ai fait
Le but était de comprendre l’intérêt de l’automatisation dans une infrastructure informatique. Lorsqu’un administrateur doit répéter constamment les mêmes manipulations, cela devient rapidement une perte de temps et augmente le risque d’erreur humaine. L’automatisation permet donc de rendre certaines tâches plus fiables, plus rapides et plus simples à reproduire.
Comment je l’ai fait
J’ai principalement utilisé Bash sous Linux ainsi que plusieurs commandes système. Avant de développer un script, je réfléchissais d’abord à la logique nécessaire : quelles informations récupérer, quelles commandes exécuter et dans quel ordre. Une fois le script créé, je réalisais plusieurs tests afin de vérifier son bon fonctionnement et corriger les éventuelles erreurs. Cette méthode m’a permis de mieux organiser ma manière de travailler.
Mes difficultés
Au début, certaines erreurs étaient compliquées à identifier, notamment les problèmes de syntaxe Bash ou les erreurs liées aux chemins de fichiers. Une petite faute pouvait empêcher tout le script de fonctionner correctement. J’avais également parfois du mal à garder des scripts lisibles lorsque plusieurs actions devaient être réalisées automatiquement.
Ce que j’en ai appris
Ce travail m’a appris à être plus rigoureux dans ma manière de développer. J’ai également compris qu’un bon script doit être clair, organisé et facilement modifiable. Cette compétence m’a aussi permis de mieux comprendre le fonctionnement des systèmes Linux et l’importance de l’automatisation dans les métiers du réseau et de la cybersécurité.
Ce que je ferais autrement
Aujourd’hui, je préparerais davantage la structure globale du script avant de commencer le développement. Je prendrais aussi plus de temps pour documenter les différentes parties du code afin de rendre les scripts plus simples à relire et à maintenir dans le temps.
AC23.02 — Développer une application à partir d’un cahier des charges donné, pour le Web ou les périphériques mobiles
Ce que j’ai fait
J’ai participé au développement d’une application communicante en Python capable de rechercher des mots dans plusieurs types de fichiers comme des PDF, TXT, HTML ou XLSX. Le projet comportait une partie client, une partie serveur ainsi qu’un système permettant d’afficher les résultats des recherches. J’ai travaillé sur plusieurs parties du projet, notamment l’organisation du code, les échanges réseau, la gestion des fichiers et le traitement des résultats.
Pourquoi je l’ai fait
Le but était de développer une application répondant à un besoin concret tout en respectant un cahier des charges précis. Ce projet m’a permis de comprendre qu’une application ne doit pas uniquement fonctionner techniquement, mais aussi répondre correctement aux attentes de l’utilisateur. Il fallait donc réfléchir autant à l’organisation du projet qu’au fonctionnement final de l’application.
Comment je l’ai fait
J’ai utilisé Python ainsi que différentes bibliothèques permettant de lire plusieurs formats de fichiers. J’ai également travaillé sur la communication entre le client et le serveur afin de permettre l’envoi des requêtes et la récupération des résultats. Le projet demandait aussi une bonne organisation afin de séparer correctement les différentes parties de l’application et faciliter les phases de développement et de test.
Mes difficultés
La principale difficulté était de garder une architecture claire malgré l’évolution du projet. Certaines fonctionnalités ajoutées progressivement rendaient parfois le code plus complexe à maintenir. La gestion de plusieurs formats de fichiers demandait également beaucoup de tests afin de vérifier que les recherches fonctionnaient correctement dans tous les cas.
Ce que j’en ai appris
Ce projet m’a appris à mieux organiser mon développement et à réfléchir davantage à la structure globale d’une application avant de commencer à coder. J’ai aussi compris l’importance des tests, du travail en équipe et de la communication entre les différentes parties d’un projet informatique.
Ce que je ferais autrement
Je préparerais une architecture plus détaillée dès le début du projet avec une séparation encore plus claire des différentes fonctionnalités. Cela permettrait de simplifier la maintenance du code et de rendre le projet plus simple à faire évoluer.
AC23.03 — Utiliser un protocole réseau pour programmer une application client/serveur
Ce que j’ai fait
Dans le projet d’application communicante, j’ai travaillé sur les échanges entre un client et un serveur développés en Python. Le client envoyait une requête au serveur afin de lancer une recherche, puis le serveur analysait les fichiers avant de renvoyer les résultats demandés. Ce projet m’a permis de travailler concrètement sur une architecture client/serveur et de mieux comprendre le fonctionnement des échanges réseau.
Pourquoi je l’ai fait
Le but était de comprendre comment les applications communiquent à travers un réseau et comment les données circulent entre un client et un serveur. Cette compétence est importante car la majorité des applications modernes utilisent ce type d’architecture pour échanger des informations.
Comment je l’ai fait
J’ai utilisé les sockets TCP sous Python afin d’établir la communication entre les deux parties de l’application. J’ai également travaillé sur les requêtes envoyées, les réponses du serveur et la gestion des données échangées. Plusieurs phases de tests étaient nécessaires afin de vérifier la stabilité des connexions et le bon fonctionnement des échanges.
Mes difficultés
Certains problèmes liés aux connexions réseau étaient parfois difficiles à diagnostiquer, notamment lorsque les échanges entre le client et le serveur ne fonctionnaient pas correctement. Il fallait analyser précisément les données envoyées et reçues afin de comprendre l’origine du problème. Les erreurs réseau demandaient souvent beaucoup de logique et de rigueur.
Ce que j’en ai appris
Cette expérience m’a permis de mieux comprendre le fonctionnement d’une architecture client/serveur ainsi que le rôle des protocoles réseau dans les applications modernes. J’ai également appris à être plus méthodique pendant les phases de test, de débogage et d’analyse des échanges réseau.
Ce que je ferais autrement
Je mettrais en place des outils d’analyse réseau plus tôt dans le projet afin de visualiser plus facilement les échanges entre les applications. Cela permettrait de détecter certaines erreurs plus rapidement pendant les phases de développement.
Voici un extrait du code :
Voici l'interface client :
