Et oui, incroyable mais vrai, la simple installation de **yarn** sous windows n'est pas sans manipulation. 

Rien de compliqué en soit mais il se peut que même après avoir installé yarn en global sur votre machine: 

```shell
npm i -g yarn
```

Vous soyez dans l'incapacité de lancer une commande yarn et receviez en retour ce message d'erreur:

```shell
yarn.ps1 cannot be loaded because running scripts is disabled on this system. For more informations, see about_Execution_Policies at https...

+ CategoryInfo: SecurityError (:) [], PSSecurityException
+ FullyQualifiedErrorId : UnauthorizedAccess 
```

Alors qu'est-ce que c'est que ce charabia ? Tout simplement que **yarn** est incapable de se lancer sur votre machine, faute de droits.

Pour y remédier, rien de compliqué, ouvrez **windows** et tapez **powershell** puis faîtes un clic droit > exécuter en tant qu'administrateur.

![powershell_admin.jpg](https://bo.dev-freelance.fr/uploads/powershell_admin_59e7c13b60.jpg)

Une fois **powershell** ouvert, entrez ceci :

```shell
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
```

On vous demandera de confirmer avec **O**, faîtes-le. 

Voilà, désormais vous êtes en mesure d'utiliser vos commandes **yarn** sur Windows 11 sans problèmes.


large_yarn.jpg

medium_yarn.jpg

small_yarn.jpg

thumbnail_yarn.jpg

yarn.jpg

C'est de plus en plus dur de coder quelque chose sous Windows. De manière générale, je trouve que c'est plus fastidieux qu'ailleurs de faire quoique ce soit dans le dev sous Windows. Chercher des paquets à la main etc, avant l'introduction de nuget du moins. Aujourd'hui nous allons voir comment utiliser yarn (le paquet node) sous Windows.

Comment utiliser Yarn sous Windows 11

Commençons par installer le paquet qui permet d'exécuter les tests en python, j'ai nommé **pytest**

```shell
pip install pytest
```

Une fois que **pytest** est installé, vous pouvez vous lancer sans plus attendre dans l'écriture de vos tests. Je suis un fervent défenseur du TDD car coder sans anticiper l'utilisation m'a déjà causé beaucoup de soucis par le passé. Alors j'aime bien avoir une spécification des entrées et sorties écrites quelque part. Cela permet d'acter comment vous allez utiliser une fonction/méthode, etc.

Lorsque vous avez une idée sur la fonction que vous souhaitez écrire il faut se poser les questions suivantes:

- Comment vais-je me servir de cette fonction ? (par exemple: server side, client side, etc... pour poser un cadre)
- De quoi ai-je besoin, au minimum pour appeler cette fonction ? (quels paramètres sont obligatoires ? et de quel type ?)
- Y a t-il des paramètres optionnels ? (cela permettra de définir combien de scénario vous aurez à minima)
- Y a t-il plusieurs façon d'utiliser cette fonction ? (est-ce que les opérations seront différentes selon certaines conditions ? par exemple connecté ou déconnecté)

Une fois que vous avez plus ou moins une idée des réponses vous pouvez commencer l'écriture de vos tests.

Les fichiers tests doivent par convention commencer par **test_**.
Personnellement, j'aime bien séparer en différents fichiers l'écriture de tests si nous sommes dans des cas différents, par exemple: **test_lib_a_disconnected** et **test_lib_a_connected**.

Par convention, les fonctions de tests commencent aussi par **test_**
Dans chaque fichier, je ferai une fonction séparée pour tester différents paramètre de ma fonction:
**def test_access_url_a_with_token()** et **def test_access_url_a_without_token()**...

Voyez ces fonctions de tests comme les **it** en **Node.js**. Le nom de votre fonction doit définir ce que vous êtes sur le point de tester. A vous de mettre le curseur sur un groupe d'actions où de limiter le test à une micro opération, nécessitant ainsi, plusieurs tests pour pouvoir couvrir toutes les fonctionnalités, ainsi que les scénarios couverts.

J'ai créé l'arborescence suivante : 

```shell
├── libs
│   └── reader.py
└── tests
    └── test_reader.py
    └── sample.txt
 ```
 
 Pour que ce soit plus lisible, je vais commencer ici par là lib, donc nous ne faisons pas réellement du TDD, mais presque...
 Ecrivons une petite lib reader qui ne fait rien de mystique, à savoir, lire un fichier: 📄
 
 ```python
 # libs/reader.py

def read_file(filepath):
  f = open(filepath, "r")
  return f.read()

 ```
 
 Comme il s'agit d'une lib pour lire un fichier, je vais créer un petit fichier de test dans mon répertoire de tests, **sample.txt** :
 
 ```
Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, 
when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
It has survived not only five centuries, but also the leap into electronic typesetting, 
remaining essentially unchanged. 
It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, 
and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
 ```
 
Dans nos tests, nous allons importer notre lib reader, avec [la méthode que je vous ai présenté dans cet article](https://dev-freelance.fr/dev/importer-des-packages-python-depuis-des-sous-repertoires) :

```python
# tests/test_reader.py

import os
import sys
import os

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

from libs.reader import read_file

def test_reader():
  filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), './sample.txt')
  content = read_file(filepath)
  assert len(content) == 580
```

Pour lancer nos tests, il suffit de taper dans un terminal :

```shell
python3 -m pytest
```

Si jamais vous utilisez des **print** dans vos tests, il faut lancer pytest avec l'option **-s** pour que ceux-ci s'affichent, car ils sont catchés par défaut.

```shell
python3 -m pytest -s
```

Voilà c'était un article très simple et très basique mais qui permet de faire beaucoup de chose quand on s'y met. 😀

La prochaine fois nous allons voir comment créer des **mocks** avec python pour gérer les appels **HTTP Rest API** ou **JSON-RPC**, toujours dans une démarche de couverture de tests.



large_devl.jpg

medium_devl.jpg

small_devl.jpg

thumbnail_devl.jpg

devl.jpg

Pour coder efficacement, rien de plus pratique que les tests unitaires. Aussi, je recommande chaudement de les implémenter en TDD, c'est à dire faire les tests avant voire en même temps que chaque fonction, histoire d'avoir une direction, et de coder selon un plan (input/ouput).

Ecrire simplement ses tests unitaires avec Python

Lorsque vous travaillez dans un projet avec une arboresence comme celle-ci:

```shell
.
├── libs
│   ├── get_content.py
│   └── get_key.py
└── tests
    └── test_get_key.py
```

Pour importer les libs de  depuis le répertoire test, cela peut s'avérer un peu tricky. Mais voici comment procéder depuis notre fichier `test_get_key.py`:

```python
import os
import sys

# nous allons demander à Python de prendre aussi en considération les répertoires à partir du répertoire parent. 

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

# maintenant il est possible d'importer facilement toutes les libs du répertoire parent.

from libs.get_key import read_key
```

Rien ne vous empêche de spécifier des chemins plus complexe et de les importer.

large_screen-python-resized.jpg

medium_screen-python-resized.jpg

small_screen-python-resized.jpg

thumbnail_screen-python-resized.jpg

screen-python-resized.jpg

En Python, lorsque vous devez structurer un projet, il arrive que vous ayez besoin de charger une lib dans un répertoire parent, et pour cela, il est vrai que ce n'est pas évident de les importer. Voici un petit snippet code qui pourrait vous être utile.

Importer des packages Python depuis des sous répertoires

Il n’y a pas longtemps, [je postais un article plutôt critique](https://dev-freelance.fr/news/le-problemes-des-prompts-ia) concernant les **LLM** (Large Language Model, comprenez les bots intelligents comme **ChatGPT**). Le fait est qu’en tant qu’utilisateur je trouve cet outil de moins en moins pratique car ses réponses sont de plus en plus brèves et manquent de détails. [Et je ne suis pas le seul à l’avoir constaté](https://www.tomsguide.fr/chatgpt-la-derniere-mise-a-jour-a-soigne-gpt-4-turbo-de-la-paresse/).

De même, je tenais un discours assez critique concernant **Github Copilot** étant donné que ce dernier s’appuie sur **Chatgpt**. Je disais que j’avais de gros doutes quant à son efficacité car **Chatgpt** lui même n’est pas très précis, or le code nécessite de la précision. 

Et bien, là aussi, je ne suis pas le seul à penser de la sorte. [Mes confrères de développez.com ont justement posté un article plutôt critique sur le sujet](https://intelligence-artificielle.developpez.com/actu/353321/L-utilisation-de-l-assistant-d-IA-GitHub-Copilot-pour-la-programmation-entraine-une-baisse-de-la-qualite-globale-du-code-et-une-quantite-importante-de-code-redondant-selon-une-etude/).

Je pense qu'une IA serait plus utile à faire de l’optimisation de code, de la relecture, du formatage etc… qu’à penser réellement les features. Le fait que son contenu se base sur le passé, il arrive souvent que ces outils fournissent des snippets obsolètes. De même, j’ai un regard assez critique sur ce qu’ils fournissent comme résultat. 

Open source ou pas, les projets étant très différents, ainsi que l’organisation dans les projets. Ce qui signifie qu’en termes de qualité on peut avoir tout et n’importe quoi. Par exemple, un des moteurs qui fait tourner la majorité des pages du web s’appelle **Wordpress**, et pour y avoir mis les mains, je n’ai pas une haute opinion de ce moteur: le code est mal organisé, mal structuré, brouillon… Donc si on me dit génial “je génère ton code grâce à des projets complètement claqués”, et bien j’ai plus peur du résultat qu’autre chose. 

Donc voilà je ne suis pas autant enjoué de cette situation, je préfère de loin la qualité d’un expert qu’un générateur automatique qui ne comprend pas le quart de ce qu’il fait. Et comprenez-moi bien, c’est le cas aujourd’hui. Je ne dis pas que dans dix ans, ce sera toujours une réalité, et surtout j’espère bien que non. Ce serait évidemment intéressant de collaborer avec des IA au niveau, mais pour le moment ce n'est tout simplement pas envisageable.

Encore une fois, ces limitations sont dû à la conception actuelle des modèles neuronaux. **Ces derniers font de l'apprentissage, mais ne font pas de l'expérimentation**. Ce qui signifie que leur compréhension s'arrête à ce qui a été réalisé. Créant ainsi des lacunes lorsqu'il s'agit d'être innovant en matière d'approche et d'optimisation, ce qu'arrive à faire aisément un humain.

large_code-resized.jpg

medium_code-resized.jpg

small_code-resized.jpg

thumbnail_code-resized.jpg

code-resized.jpg

A tout ceux qui souhaite aller plus vite en utilisant des générateurs de code, je pense que vous prenez un risque à utiliser ces outils. Pour le moment, ces derniers manquent de maturité et je ne suis pas le seul à l'avoir constaté.

Github Copilot, pas si intéressant après tout

### A quoi sert Elastic Search ?

Pour faire rapide 👉 **Elastic Search est un moteur de recherche**. 

Maintenant, qu'est-ce qu'un moteur de recherche ? 

Vous stockez probablement déjà des informations dans une base de données. Lorsque vous recherchez des informations dans cette base, vous allez utiliser des requêtes. Si vous voulez faire des tris dans ces requêtes, en base de données vous aurez les possibilités suivantes: 

- trier par ordre alphabétique
- trier par ordre croissant, décroissant

Supposez qu'un utilisateur recherche le terme: **Volleyball**, il est possible que ce terme apparaisse dans le titre d'un article ou dans le contenu de l'article. 

👍 S'il s'agit du titre, la probabilité est forte que cette article intéresse notre utilisateur. 

👎 Dans le cas où l'article contient le terme Volleyball, il n'est pas garantie que cela corresponde à un article intéressant. En effet, ce terme peut très bien faire partie d'une phrase comme: 

>La municipalité interdit toute pratique de sport de ballon tel que le football et le volleyball dans ce secteur.

Vous voyez le terme apparait bien, mais il est peu probable que son occurence soit intéressante pour notre utilisateur. 

Comment fait-on pour classer et trier les contenus par intérêt avec une base de données traditionnelle ? 

La réponse est simple : on ne peut pas vraiment, car ces bases ne sont pas faîtes pour ça. 

Ce que vous devrez faire, c'est faire la requête puis retraiter les résultats au niveau du code avec votre langage de programmation, en repoussant encore plus le délai de réponse à votre utilisateur, soit une expérience dégradée pour ce dernier. 😒

**C'est à ce moment qu'entrent en jeu les moteurs de recherches 🤠.**

Mais avant de faire des manipulations poussées et toute sorte de test de scoring, il convient de préparer son index. Pour les moteurs de recherches on ne parle pas de base de données mais d'index. En d'autre termes, d'injecter des données dans le moteur pour qu'il puisse les classer et les scorer.

Nous allons utiliser **Elastic Search** en tant que moteur de recherche, c'est un outil qui a fait ses preuves et qui est utilisé aujourd'hui par Cisco, Adobe, BMW, Yelp, etc...

Dans l'ordre nous allons:

- installer notre stack docker
- créer notre premier index
- injecter des données dans cet index
- requêter notre index

### 1 - Déploiement d'une stack Elastic

Nous allons commencer par créer nos serveurs grâce à **Docker**. Ici, je pars du principe que vous avez déjà **docker** et **docker-compose** d'installé sur votre machine. Si ce n'est pas le cas, je vous prie de commencer par là et de reprendre ensuite la lecture de cet article. Je pars aussi du principe que vous êtes sur un système qui permet de bosser rapidement avec **docker** et **bash**, donc un système **Linux** ou **Darwin** (Mac OS).

Pour aller vite, sachez que les développeurs d'elastic search ont eux même mis en place un repo qui permet la création rapide d'une stack docker [disponible à cette adresse](https://github.com/elkninja/elastic-stack-docker-part-one)

Si vous voulez lire l'article associé à ce repository, [le voici](https://www.elastic.co/fr/blog/getting-started-with-the-elastic-stack-and-docker-compose).

Cependant, dans cet article, la configuration est découpée en plusieurs blocs rendant tout cela difficilement lisible. Aussi je vous recommande de faire un pull du repo et de passer directement à la configuration de votre fichier **.env**.

```
# Project namespace (defaults to the current folder name if not set)
#COMPOSE_PROJECT_NAME=myproject

# Password for the 'elastic' user (at least 6 characters)
ELASTIC_PASSWORD=changeme

# Password for the 'kibana_system' user (at least 6 characters)
KIBANA_PASSWORD=changeme

# Version of Elastic products
STACK_VERSION=8.7.1

# Set the cluster name
CLUSTER_NAME=docker-cluster

# Set to 'basic' or 'trial' to automatically start the 30-day trial
LICENSE=basic
#LICENSE=trial

# Port to expose Elasticsearch HTTP API to the host
ES_PORT=9200

# Port to expose Kibana to the host
KIBANA_PORT=5601

# Increase or decrease based on the available host memory (in bytes)
ES_MEM_LIMIT=1073741824
KB_MEM_LIMIT=1073741824
LS_MEM_LIMIT=1073741824

# SAMPLE Predefined Key only to be used in POC environments
ENCRYPTION_KEY=c34d38b3a14956121ff2170e5030b471551370178f43e5626eec58b04a30fae2
```

Modifier les mots de passe dans le fichier .env en replaçant les occurences de changeme par quelque chose de votre choix.

Nous allons maintenant démarrer nos containers.

```
sudo docker-compose up -d
```

Une fois votre container démarré, votre **elastic search** est lancé, mais en **HTTPS** !

### 2 - Création d'un premier index

Je vais créer un index avec 2 shards. 

Les shards pour faire simple sont des points d'entrées vers les données. 
Splitter un index en deux shards permet de les parcourir simultanément (si votre disque dur le permet). 

⚠️ Attention un shard n'est pas un cluster, d'ailleurs si vous utilisez un cluster, sachez que vos shards seront répartis sur ces derniers. C'est à dire qu'ils ne seront pas multipliés par le nombre d'instance.

👉 Le fait de passer par un faux certificat risque de poser problème à curl, mais nous allons forcer les appels grâce au flag insecure.

👉 L'utilisation d'un user/password a une incidence sur comment vous allez requêter le service: 

```bash
curl --insecure -X PUT \
-u elastic:<mot de passe> \
https://localhost:9200/<nom de votre index> \
-H 'Content-Type: application/json' \
-d '{"settings":{"number_of_shards": 2}}' -v
```

Si jamais vous vous êtes trompé dans le nom, vous pouvez toujours supprimer cet index avec: 

```bash
curl --insecure -X DLETE \
-u elastic:<mot de passe> \
https://localhost:9200/<nom de votre index> -v
```

Vous pouvez aussi bien utiliser **Postman** pour le faire. Cependant, n'ayant pas de raccourci **--user**, vous devrez utiliser un header '**Authorization**' avec en value '**Basic [base64 de username:password]**'. 

Pour obtenir votre **base64**, vous pouvez utiliser la console, ou [ce site](https://www.blitter.se/utils/basic-authentication-header-generator/).

```bash
echo -n "username:password" | base64
```

### 3 - Injection du jeu de données

Commençons par télécharger un dataset. J'ai choisi les catégories d'articles du Huffington Post de 2012 à 2022. Rendez-vous [ici pour télécharger le dataset](https://www.kaggle.com/datasets/rmisra/news-category-dataset/). 

Décompressez cela dans un dossier et vous obtiendrez le fichier:

```
News_Category_Dataset_v3.json
```

Maintenant que vous avez votre index Elastic Search et votre jeu de données, il ne reste plus qu'à y injecter les données.

Vous pouvez créer une plus petite version du dataset pour commencer ce script, cela vous permettra de faire des tests au lieu de vous farcir les 209 000 lignes du dataset.

Nous allons batcher la lecture de ce fichier en faisant de chacun de ces **JSON** en appels **curl**. 

Pour cela, nous avons besoin de **bash**, donc je crée un fichier '**start_index.sh**' :

```
url="https://localhost:9200/"
index_name="<nom de votre index>"
username=elastic
pwd=<votre mot de passe>
input="./News_Category_Dataset_v3.json"

echo "Start indexing data"

index_path=$(echo "${url}${index_name}/_doc")
credentials=$(echo -n "${username}:${pwd}" | base64)

while IFS= read -r line
do
 echo "\nPushing new line..."
 curl --insecure -X POST $index_path -H 'Content-Type: application/json' -H "Authorization: Basic ${credentials}" -d "$line" -v
done < "$input"

```

Remplacez ce dont vous avez besoin.

Et vous pouvez lancer cela en faisant: 

```bash
sh start-index.sh
```

Vous laissez tourner car ça risque d'être long en fonction de la taille du dataset. ⌚

### 4 - Requêter l'index Elastic

Une fois que vous avez nourri votre Elastic Search 🍚, vous pouvez le requêter:

```bash
curl --insecure -X GET 'https://localhost:9200/<nom de votre index>/_search' \
-u <username>:<password> \
-H 'Content-Type: application/json' \
-d '{
 "query": {
 "query_string": {
 "query": "Obama"
 }
 }
}' 
```

Pour que ce soit plus lisible depuis la console vous pouvez **| jq** à la fin, à condition que vous ayez **jq**.

Idem, remplacez ce dont vous avez besoin et n'hésitez pas à utiliser **Postman**.

On obtient:

```bash
# ...
 "_id": "EQbHQosBiMuykQNzVA3o",
 "_score": 8.201126,
 "_source": {
 "category": "POLITICS",
 "headline": "Team Obama",
 "authors": "Jeff Danziger, ContributorPolitical cartoonist syndicated by the NYTimes worldwide",
 "link": "https://www.huffingtonpost.com/entry/team-obama_1_b_6125962.html",
 "short_description": "Team Obama",
 "date": "2014-11-08"
 }
 },
 {
 "_index": "news",
 "_id": "6gfQQosBiMuykQNzlQiE",
 "_score": 7.803393,
 "_source": {
 "category": "STYLE & BEAUTY",
 "headline": "White House Tree Lighting Photos: Michelle Obama & Family Cozy Up! (PHOTOS, VIDEO)",
 "authors": "Jessica Misener",
 "link": "https://www.huffingtonpost.com/entry/white-house-tree-lighting-michelle-obama-malia-sasha-photos_us_5b9c97dde4b03a1dcc802043",
 "short_description": "Plus... President Obama sings!",
 "date": "2012-12-07"
 }
 },
 {
 "_index": "news",
 "_id": "CAXEQosBiMuykQNzgsCL",
 "_score": 7.5903983,
 "_source": {
 "category": "POLITICS",
 "headline": "Obama and the 'N' Word",
 "authors": "Jonathan Richards, ContributorCartoonist",
 "link": "https://www.huffingtonpost.com/entry/obama-and-the-n-word_b_7646922.html",
 "short_description": "Obama and the 'N' Word",
 "date": "2015-06-23"
 }
 },
 {
 "_index": "news",
 "_id": "8gS4QosBiMuykQNzkXdu",
 "_score": 7.5273933,
 "_source": {
 "category": "COMEDY",
 "headline": "Conan O’Brien Zings Donald Trump In Spoof Barack Obama Netflix Trailer",
 "authors": "Lee Moran",
 "link": "https://www.huffingtonpost.com/entry/conan-barack-obama-netflix-spoof-stand-up-special_us_5ab22b23e4b008c9e5f2ce5a",
 "short_description": "Fake Obama brings the gags.",
 "date": "2018-03-21"
 }
 },
 {
 "_index": "news",
 "_id": "zAS9QosBiMuykQNzIvVo",
 "_score": 7.5273933,
 "_source": {
 "category": "WOMEN",
 "headline": "Obama Spent His First Week In Office Championing Women's Rights To Equal Pay",
 "authors": "Jenavieve Hatch",
 "link": "https://www.huffingtonpost.com/entry/obama-spent-his-first-week-in-office-championing-womens-rights-to-equal-pay_us_588f7aa5e4b02772c4e8105f",
 "short_description": "The Obama Foundation looks back.",
 "date": "2017-01-30"
 }
 }
 ]
 }
}
```

Et voilà votre index est configuré et contient des données. Vous pouvez maintenant y effectuer des requêtes et tester toute sorte de classement et de tris à votre guise.

nicolas-hoizey--4trKf0Kbow-unsplash-resized.jpg

large_nicolas-hoizey--4trKf0Kbow-unsplash-resized.jpg

medium_nicolas-hoizey--4trKf0Kbow-unsplash-resized.jpg

small_nicolas-hoizey--4trKf0Kbow-unsplash-resized.jpg

thumbnail_nicolas-hoizey--4trKf0Kbow-unsplash-resized.jpg

Vous voulez vous exercer avec Elastic Search mais vous ne savez pas par où commencer ? Et si on s'installait une stack en local avec Docker pour y effectuer des tests ? Je vous propose aujourd'hui de créer tout ça de 0, ainsi que d'y injecter un premier jeu de données. 

Comment configurer rapidement un elastic stack local ?

Par où commencer lorsque l'on a besoin d'un jeu de données ?

### 1- Constituer soi même son jeu de données

Supposez que vous commenciez un business dans la vente automobile de marque Française. Vous allez constituer votre jeu de données avec les éléments suivants : 
- stock disponible chez les fournisseurs
- stock disponible chez vous
- liste des véhicules réservés ou achetés par des clients
- etc

Sur ces mêmes jeux de données vous allez commencer à effectuer des analyses: 
- combien de véhicules sont vendus par ces fournisseurs chaque années
- combien de véhicules vous vendez chaque années
- etc.

Mais avant même d'aller jusque là, imaginez un instant devoir passer en revue tout le stock disponible et les fiches complètes de chaque véhicules afin d'avoir un point de départ: la donnée sur laquelle viendront les analyses dans un second temps. Tout ceci est long et fastidieux...

### 2- Les sources de données existantes

C'est là qu'entre en jeu des sources de données existantes qui vont vous prémarcher une partie du travail. 🦥

Certains fournisseurs vous donnent immédiatement accès à leur stock que vous pourrez copier et coller chez vous histoire de gagner du temps... Mais dans bien des domaines vous serez livrer à vous même, contraint de commencer à partir de rien et de construire tout une base avec ces éléments.

Conscient de tout le travail que cela demande, certaines communautés se forment autour de la données et proposent même de s'échanger des jeux de données pour éviter à tout un chacun d'avoir à se farcir des heures de saisie.

J'ai nommé [kaggle.com](https://www.kaggle.com/)

![kaggle.png](https://bo.dev-freelance.fr/uploads/kaggle_3c94d826f2.png)

Site de référence sur lequel vous pourrez trouver énormément de listes en tout genre:

- liste d'animaux
- liste de séries TV
- liste de films
- liste de marque de voiture
- liste des titres d'article de presse
- etc...

Pour cela, penchez vous du côté des **datasets**.



scott-graham-5fNmWej4tAA-unsplash-resized.jpg

large_scott-graham-5fNmWej4tAA-unsplash-resized.jpg

medium_scott-graham-5fNmWej4tAA-unsplash-resized.jpg

small_scott-graham-5fNmWej4tAA-unsplash-resized.jpg

thumbnail_scott-graham-5fNmWej4tAA-unsplash-resized.jpg

Récupérer un jeu de données (dataset en anglais) n'a pas toujours été aussi simple. D'ailleurs la data a été et est toujours le nerf de la guerre dans l'informatique de demain. Dans le domaine de la stratégie, de l'IA, scientifique et des statistiques, les données sont au coeur de chacun de ses systèmes. Mais comment trouver une source de données ? 

Comment trouver ses jeux de données

### Pourquoi il n'est pas simple de modifier une table PostgreSQL directement en production ?

Lorsqu'il s'agit de votre base de données, la source de vérité sur laquelle vous vous appuyez pour des opérations, des calculs, ou même diffuser du contenu sur vos plateformes, **vous ne pouvez pas risquer de tout perdre**. Les enjeux sont importants au point que certaines compagnies prennent le temps de faire un backup de base avant ce genre d'opérations (il est notamment conseillé de le faire régulièrement). L'idée étant de pouvoir retomber sur vos pattes si vous rencontrez un problème. Cependant, vous conviendrez que si votre base fait 30go, le backup ne sera pas simple à faire.

Par ailleurs, il est difficile de mettre à jour une table de production car si l'opération est trop lourde pendant la modification de cette table, cela peut empêcher tout accès en parallèle. Ce qui implique littéralement un freeze de cette ressource pendant la durée de l'opération. Aussi, la question que vous devez vous poser est : **pouvez-vous vous permettre une interruption ?** Pour vous donner une idée, Amazon vend 150 produits par minutes. **Imaginer rendre une table produits inaccessible pendant 1 heure signifie se tirer une balle le pied !**

Donc, la gestion d'une base de données sur un projet actif n'est pas une mince affaire. 

### Les tâches obligatoires sur votre base

- 1. Toilettage Quotidien avec VACUUM

L'un des premiers défis réside dans le maintien de votre base de données en bonne santé au quotidien. C'est là que l'outil VACUUM entre en jeu. Il vous permet de récupérer de l'espace disque inutilisé suite aux suppressions, de prévenir la fragmentation, de nettoyer les transactions inachevées, et plus encore. La compréhension et l'utilisation appropriée de VACUUM sont cruciales pour maintenir la stabilité et la performance de votre base.

- 2. Optimisation de l'Architecture

Une architecture de base de données bien conçue est un élément clé de la performance. Savoir quand utiliser la redondance d'informations, c'est-à-dire répéter une colonne sur différentes tables pour éviter des jointures inutiles ou des sous-requêtes, peut considérablement accélérer vos requêtes.

- 3. Gestion du Volume de Données

Pour les projets de grande envergure, où des dizaines de sociétés vendent des milliers de produits chacune, le volume de données peut atteindre des dizaines, voire des centaines de gigaoctets. Il est essentiel de maintenir la base de données active dans une "tranche raisonnable" d'espace disque, idéalement en dessous de 1 Go pour garantir des performances optimales. Cela peut impliquer la mise en place d'une base de données active distincte de la base d'archives, avec des bascules périodiques pour libérer de l'espace et améliorer la réactivité de l'instance.

Il y a plusieurs façon de mettre à jour une table surtout si elle contient des données. Et par données, j'entends des dizaines, centaines de milliers de lignes, des millions voire plus. Croyez moi, à ce moment là, vous ne faîtes plus seulement un :

```
ALTER TABLE ADD COLUMN ... DEFAULT ...
```

Sous peine de mettre littéralement votre base de données en PLS ✝️.

Lorsque vous avez trop de données l'activation du **DEFAULT VALUE** peut faire très très mal à votre instance de base, le temps de passer sur chaque ligne pour y mettre la fameuse valeur par défaut. Au même moment, toutes les requêtes entrante vers cette table sont compromises, gros risques de perte d'accès à cause des **lock** de ressource etc. 


>Ne pas pouvoir répondre à une QUERY c'est une chose, mais perdre un INSERT/UPDATE/DELETE ça peut carrément être grave.

Il y a plusieurs façon de procéder dans ce cas de figure, certaines méthode sont plus complexes que d'autres, même si ce n'est pas mon domaine premier d'expertise (car je tiens à rappeler que c'est un métier à part entière et que nos experts **SysDBA**/**DBOps** sont biens plus qualifiés que moi pour vous aiguiller au mieux) je vais vous expliquer ce que je ferai dans ce cas. Bien sûr, ces méthodologies ont été testés et éprouvés sur le terrains avec mes confrères **DBOps** et sous couvert de leur expertise.

### 1- La nouvelle table

Il est tout à fait possible et plein de sens de créer une nouvelle table pour y effectuer les modification par rapport à une table initiale. On parle ici uniquement de la structure de table dans un premier temps.

Bien que cela comporte aussi ses inconvénients dans un second temps : 
Supposez que votre table principale fasse **10go**, cela signifie que vous allez vous retrouver avec le double, du moins, pendant un instant. Si vous êtes sur un serveur dont les limitations disque ne vous permettent pas d'aller aussi loin, cette procédure semble déjà compromise. 

Pour autant, cette méthode comporte aussi quelques avantages: 
**La sécurité et l'intégrité des données sur la table principale qui n'est pas altérée**, cela vous permet de structurer souplement vos colonnes et de prendre le temps d'améliorer le modèle. De plus, votre table principale est toujours accessible pour les utilisateurs. 

Une fois votre table terminée, vous pourrez à une heure de faible sollicitation (souvent le soir à 2h/3h du mat 🛏️), effectuer une bascule de données, via des batchs ou non. **Il est recommandé, pour avoir la garantie de récupérer 100% de l'état de la table initiale en sortie, d'utiliser des lock manuels pendant l'opération**. 

Cette solution est tout à fait convenable et fonctionne très bien. Quand votre opération est terminée, rien ne vous empêche de renommer les tables pour que la nouvelle puisse enfin remplacer l'ancienne.

### 2- Le batch update sur la table cible

Une autre alternative vous est possible : **directement modifier la table cible** !

>Cependant, pas si vite jeune fougeux(se) ! ✋

Rappelez vous ce que je vous ai dit plus haut, on ne fait pas un **ALTER TABLE** gratuit sur une table avec une **DEFAULT VALUE**. Votre base va cracher ses poumons ! 😷 

Pour cela je vous propose un peu d'algorithme et d'élégance pour paraphraser un ancien confrère.  

Voici un exemple de batch que je ferai, je batcherai par lot de 1000 les lignes afin de ne pas saturer ma base. De cette façon, j'ai plus de garantie qu'elle reste accessible en parallèle pour tout autre accès.

```
DO $$
DECLARE
  total_rows FLOAT; -- we need a float to calculate coeff 
  total_pages INTEGER; 
  pg_offset INTEGER = 1000; -- our limit for each iteration
  id_val INTEGER;
  temp_row RECORD;
BEGIN
  SELECT INTO total_rows count(*) FROM movies;
  total_pages = ceil(total_rows / pg_offset);
  
  -- log infos
  RAISE NOTICE 'Total rows: %', total_rows; 
  RAISE NOTICE 'Pages count: %', total_pages; 
  
  -- add new column without default value 
  ALTER TABLE movies ADD COLUMN in_collection BOOLEAN;
  
  -- batch update value
  FOR id_val IN 1..total_pages
  LOOP
    RAISE NOTICE 'Updating page % of %', id_val, total_pages; 
  	FOR temp_row IN
  	  SELECT * FROM movies LIMIT pg_offset offset pg_offset * (id_val - 1)
	LOOP
	  UPDATE movies SET in_collection=true WHERE id = temp_row.id;
	  COMMIT;
	END LOOP;
  END LOOP;
  
  RAISE NOTICE 'Job done, Rest soldier !';
  
END $$;
```

⚠️ Petite subtilité: l'usage du **FLOAT** pour **total_rows** est important pour la variable de coefficient. 

Le passage, même temporaire à un état flottant, bien que le **CEIL()** va suivre, est obligatoire ! Si vous déclarez cette variable en **INTEGER**, vous rencontrez un problème lors de l'opération 

```
CEIL(var / 1000); 
```

Si **var = 1300**, **var / 1000** ne sera plus 1.3 mais 1 et ça change tout avant exécution du **CEIL**. Oui, même si vous n'assignez pas le fameux 1.3 à votre **var** !  👈

__

Parenthèse fermée, rien ne vous empêche, quand tout est fini de faire un **ALTER COLUMN** et d'y ajouter votre **DEFAULT VALUE**. Au moins, on sait que les opérations d'écritures sont terminées.

Les notices permettent de suivre dans la console ce qu'il se passe pour ne pas vous faire poireauter à l'aveugle. 

Pour information, j'ai lancé cette requête sur une base temporaire de films avec exactement 7392 lignes et voici l'output console :

```
NOTICE:  Total rows: 7392
NOTICE:  Pages count: 8
NOTICE:  Updating page 1 of 8
NOTICE:  Updating page 2 of 8
NOTICE:  Updating page 3 of 8
NOTICE:  Updating page 4 of 8
NOTICE:  Updating page 5 of 8
NOTICE:  Updating page 6 of 8
NOTICE:  Updating page 7 of 8
NOTICE:  Updating page 8 of 8
NOTICE:  Job done, Rest soldier !
DO

Query returned successfully in 11 secs 493 msec.
```

**11.5sec pour 7392 lignes** ça laisse présager de ce que ça serait avec 10 millions de lignes. En extrapolant un peu, on serait au alentours de 4H30... 

Rien ne vous empêche de mettre des **hard limit** à vos batchs par exemple, d'ajouter des conditions pour s'arrêter à 1 000 000 de lignes, en vous obligeant ainsi à relancer plusieurs fois le script mais au moins vous aurez la possibilité de faire des contrôles entre les exécutions. N'oubliez pas ceci-dit, de commenter (double dash/tiret) la partie **ADD COLUMN** si vous le faites.

Pour conclure, je dirai que des solutions possibles pour faire une mise à jour de la structure de table en production sont :
- le backup de table et l'exécution brute des requêtes **ALTER TABLE** (bien que déconseillée)
- la nouvelle table et la copie incrémentale avec un batch  **SELECT** -> **INSERT** (bien que nécessitant un espace disque suffisant)
- le batch opération sur la table elle même 

C'est tout pour cet article qui j'espère vous apportera une solution dans vos problématiques quotidiennes. N'hésitez pas à le partager si vous avez apprécié, ou à me faire vos retours en commentaire ou sur la rubrique contact du site. Oui, je lis les messages ! 😉

large_warehouse.jpg

medium_warehouse.jpg

small_warehouse.jpg

thumbnail_warehouse.jpg

warehouse.jpg

Lorsque l'on veut modifier une table sur une base de production PostgreSQL, il convient de s'y ateler avec beaucoup de précautions. Bien sûr, tout va dépendre de la criticité de la base, de la fréquence d'utilisation, du volume de données etc... Mais en pratique, lorsqu'il s'agit de votre production il faut se préparer à une procédure très technique.

Comment modifier une grosse table PostgreSQL

Contrairement à ce que je peux laisser entendre dans mes écrits, Node.js a beau être ma techno préféré, JS/TS le langage dans lequel je me sens le plus à l'aise. Ce n'est pas le meilleur outil dans toutes les situations. 

Il y a effectivement de nombreuses possibilités notamment via les **spawn** etc pour faire des appels de commande terminal, mais l'async rend les choses un peu plus compliqués lorsque l'on veut uniquement séquencer des opérations.

Quand je parle de scripting, je parle d'opérations que j'exécute sur ma machine, mon OS, mon infra ou encore des scripts de scraping. Et je pense que **Python** est un outil bien plus adapté pour ce genre de chose.

## Pourquoi ? 

N'en déplaise aux fanboys Node.js de la première heure, **Python** est beaucoup plus puissant en terme d'outil. 

Dans 95% des cas (chiffre qui sort de ma tête, mais qu'on se le dise, qui ne doit pas être loin de la réalité), des gens se concentrent uniquement sur des fonctionnalités basiques lorsqu'ils font du scraping. 

Ils diront : **Puppeteer** c'est suffisant ! **Cypress** c'est trop cool, ou encore **Selenium** pour les plus techniques. 

Mais les gars, je vous mets au défi de créer un système bien plus complexe ou les interactions deviennent dynamique, etc... Par exemple, brancher vos scrapers sur des plateformes qui n'ont pas été adaptés pour la situation (login compris, captcha compris, sans détourner le système de connexion). Car la plupart du temps pour de l'automatisation E2E, les process sont adaptés pour gérer les scénarios de tests plus facilement. Et bien **Python** il peut faire tout ça, sans alléger le process et sans trop vous casser la tête.

## Compliqué ? 

Python permet de faire tellement de chose: 
- la lecture d'écran grâce à l'**opencv** (pour Open Computer Vision), c'est à dire être capable de prendre en entrée une image (typiquement ce sera un screenshot de votre page). 
- la prise en main de votre machine, déplacer la souris à votre place, taper au clavier à votre place etc...
- et pour pousser un peu plus, vous pouvez y ajouter un système de réseau de neurones si vous voulez y intégrer l'apprentissage et que votre système puisse évoluer

Figurez vous que Python fait tout cela facilement et sans broncher...


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

Par ailleurs, non je ne télécharge pas 🙈 ... Il faut bien que je teste quelque part 😇

Donc, je penses toujours que **Node.js** est le meilleur langage pour processer des pages sur un serveur grâce à son moteur fait pour l'i/o. 

Mais, ne restez pas dans votre zone de confort et explorez tous les langages car à chaque problème sa solution. Parfois un autre langage peut être un outil bien plus adapté à votre besoin.

todd-quackenbush-IClZBVw5W5A-unsplash.jpg

large_todd-quackenbush-IClZBVw5W5A-unsplash.jpg

medium_todd-quackenbush-IClZBVw5W5A-unsplash.jpg

small_todd-quackenbush-IClZBVw5W5A-unsplash.jpg

thumbnail_todd-quackenbush-IClZBVw5W5A-unsplash.jpg

Est-ce qu'en tant que développeur Typescript je ne fais que du ts ? Je ne jure que par lui et rien d'autre ? Et bien la réponse est non ! TS est un super langage pour coder des API et du frontend. Cependant, lorsque je code un script, automate, système ou autre, j'utilise autre chose.

Mon langage de scripting préféré

Il y a quelques jours, je me réveillais un matin avec une notification de **Bankin** qui avait généré mon relevé. Curieux je me dis bon, je jette un oeil, et après quelques slides je vois une transaction mensuelle d'environ **40€** pour **AWS**. Le chiffre dans l'absolu n'est pas fou, mais si je vous dis que c'est pour un service qui est appelé à tout cassé 10 fois dans le mois, là c'est tout de suite overkill.

### Les frais chez AWS

Dernièrement je parlais de [comment je choisis d'héberger mes solutions](https://dev-freelance.fr/dev/passer-de-frontend-a-backend-le-deploiement) et je vous disais que j'optais souvent pour des **VPS** grâce à leur faible coût. Non pas que je trouve qu'**AWS** soit trop cher, mais trop cher pour ce que je fais. **En effet, tout dépend de votre objectif !**

#### L'envergure du projet

Lorsque vous avez un projet de taille moyenne voire plus, c'est à dire qu'il vous faut au moins une équipe et plusieurs mois avant de sortir quelque chose, bien sûr qu'une solution **AWS** de type **serverless** est justifié, car tout ce temps passé à ne pas gérer le déploiement vous permet de vous concentrer sur les développements et les fonctionnalités. En revanche lorsqu'il s'agit d'un petit projet, avec peu de requêtes entrantes, je vous conseille de réfléchir à deux fois.

Pour ma part j'avais opté pour **AWS Serverless** (**Lambda** + **API Gateway**) et **RDS Postgres** pour un projet mobile que j'utilisais de temps en temps avec des amis. Mais à ne pas regardé cela fait plus de 2 ans que je paye cette solution et que plus de 1000€ ont été débité en tout pour faire tourner une base de données et un processus d'**API Node**.

#### Combien j'aurais économisé si j'avais tout fait moi même ?

Et bien c'est assez incroyable, mais j'arrive à **compresser les frais de 8 à 10 fois** pour ce genre de petit projet. Cela signifie que sur une plage de temps similaire, j'aurais dépensé en tout **100€** et des brouettes, au lieu des **1000€**. Ce qu'il faut garder en tête, c'est souvent, combien de temps va durer ce projet, et si c'est du long terme, je vous conseille d'optimiser vos frais avant tout !

J'opterais donc pour une solution **Scaleway** ou **PulseHeberg** **VPS** pour héberger des petits projets personnels. D'ailleurs en ce moment même je suis sur la refacto de cette application.

### Conclusion

Lorsque vous faîtes des projets personnels, des prototypes, etc. pensez d'avance aux frais que ceux-là vont générer dans la durée. Et ne négligez pas les optimisations que vous pourrez faire d'avance. Optez pour des solutions managées dans le cas d'application live avec de grosses audiences sur des projets longs. 💸💸


towfiqu-barbhuiya-xkArbdUcUeE-unsplash.jpg

large_towfiqu-barbhuiya-xkArbdUcUeE-unsplash.jpg

medium_towfiqu-barbhuiya-xkArbdUcUeE-unsplash.jpg

small_towfiqu-barbhuiya-xkArbdUcUeE-unsplash.jpg

thumbnail_towfiqu-barbhuiya-xkArbdUcUeE-unsplash.jpg

AWS me facture une blinde chaque mois depuis des années pour un service que j'utilise à peine. Je décide d'optimiser ça.

Découvrez tous nos articles de la catégorie Dev - page 3 sur 6