Skip to content

Génération et provisioning des données

Jump to bottom
Rémi... et pas Rémy edited this page Jun 8, 2023 · 1 revision

Génération des valeurs aléatoires

Dans ce script, nous avons créer des fonctions afin de générer des valeurs aléatoires. Ces valeurs sont utilisées pour remplir les 3 tables de la base de données "infrastructure" créer précédemment ICI
Les fonctions garantissent la diversité et l'aléatoire des données insérées, elles ont aussi été créer de façon a être cohérentes.

Liste des fonctions

  1. Les fonctions generate_servers_region(), generate_servers_uptodate() et generate_servers_os() génèrent des valeurs aléatoires pour les colonnes correspondantes de la table "servers".
  2. La fonction generate_containers_name() génère une valeur aléatoire pour la colonne "Name" de la table "containers".
  3. La fonction generate_containers_image() génère une valeur aléatoire pour la colonne "Image" de la table "containers".
  4. La fonction generate_databases_name() génère une valeur aléatoire pour la colonne "Name" de la table "databases".
  5. Les fonctions generate_databases_size() et generate_databases_uptodate() génèrent des valeurs aléatoires pour les colonnes correspondantes de la table "databases".

Focus sur les différents type de fonction utilisées

Voici la reformulation des parties spécifiques en utilisant le format Markdown :

generate_servers_region()

La fonction generate_servers_region() utilise un dictionnaire pour générer une région AWS aléatoire pour la colonne "Region" de la table "servers". Cette approche permet de définir les régions possibles de la table 'servers'.

def generate_servers_region():
    """Retourne une region AWS aleatoire pour la colonne "Region" de la table"servers" """
    
    regions = ['eu-central-1', 'eu-west-1', 'eu-west-2', 'eu-south-1', 'eu-west-3']
    return random.choice(regions)

La fonction utilise la méthode random.choices() qui permet de sélectionner aléatoirement un élément d'une liste, nous comprenons que la génération n'est pas aléatoire dans sa création, mais dans un choix spécifique, nous ne créons pas de région, mais nous demandons à en choisir parmi une sélection.

generate_containers_name()

La fonction generate_containers_name() utilise la fonction random.randint() pour générer un nom aléatoire pour la colonne "Name" de la table "containers". Le nom est généré en utilisant un format spécifique avec un nombre aléatoire compris entre 1 et 1000, puis utilise un F-string afin de rentrer nos données aléatoire à la suite d'un nom fixe.

def generate_containers_name():
    name = f'DCK{random.randint(1, 1000):02d}'
    return name

Le nombre généré aléatoirement est formatté avec deux chiffres à l'aide de ':02d' qui oblige a n'utiliser que 2 décimal et de remplir par des 0, cela qui garantit une longueur fixe du nom. Par exemple, le nom peut être "DCK001" ou "DCK789". Cette approche permet de générer des noms uniques et facilement identifiables pour les conteneurs.

generate_databases_uptodate()

La fonction generate_databases_uptodate() génère une valeur aléatoire pour la colonne "Uptodate" de la table "databases". La valeur représente une date aléatoire située entre deux dates prédéfinies.

def generate_databases_uptodate():
    start_date = date(2023, 5, 20)
    end_date = date(2023, 5, 31)
    random_date = start_date + timedelta(days=random.randint(0, (end_date - start_date).days))
    return random_date.strftime('%Y-%m-%d')

Notre fonction utilise la bibliothèque datetime pour manipuler les dates. Elle génère une date aléatoire en ajoutant un nombre de jours aléatoire entre la date de début et la date de fin. Ensuite, la date est formatée au format 'AAAA-MM-JJ'. Cela permet de générer des dates aléatoires dans une plage spécifique, ce qui est utile pour simuler des mises à jour de bases de données à différentes périodes, nous avons choisi de mettre des dates proche de nos jours afin de rester dans une certaine logique.

Nous avons pu constater ci-dessus que chacune de ces fonctions utile des techniques différentes afin de générer des données aléatoire, que ce soit de choisir dans une liste, de choisir des nombres aléatoires, ou bien pour prendre des dates dans une plage spécifique.

Boucle for et requêtes d'insertion

à cette étape, nous avons donc créer des fonctions permettant de générer des données de façon aléatoire et cohérente, ici, nous allons voir comment ces données générées, vont servir de QUERY sql afin qu'elles puissent être directement injecté dans notre base de donnée.

Notre script utilise donc maintenant une boucle for pour générer les requêtes d'insertion pour chaque ligne de chaque table de la BDD infrastructures. Les valeurs aléatoires générées par les fonctions sont utilisées pour construire les requêtes d'insertion.

server_values = (
    f"vm_aws_{random.randint(1, 1000)}",
    f"192.168.10.{random.randint(1, 200)}",
    generate_servers_region(),
    generate_servers_uptodate(),
    generate_servers_os()
)
insert_queries.append(f"INSERT INTO public.servers (hostname, ip, region, uptodate, os) VALUES {server_values};")

Ici, server_values = () génère des valeurs aléatoires pour chaque colonne de la table "servers". Par exemple, la colonne "hostname" sera une chaîne de caractères de la forme "vm_aws_" suivie d'un nombre aléatoire entre 1 et 1000 généré par random.randint(1, 1000). De même, les autres colonnes comme "ip" qui aura une base de 192.168.10.x (x étant compris entre 1 et 200), "region" (choix parmi une liste), "uptodate"(choix dans une plage) et "os" (choix parmi une liste) seront également remplies avec des valeurs aléatoires générées par les fonctions correspondantes. **Ce même type de requête est utilisé pour les tables "containers" et "databases" afin de pouvoir aussi générer des jeux de données.

Les requêtes d'insertion sont ensuite ajoutées à la liste nommé insert_queries. Cette liste contiendra toutes les requêtes d'insertion générées pour les tables "servers", "containers" et "databases" et permettrons de provisionné notre base de donnée "Infrastructure"

Concaténation et écriture du contenu

Une fois que toutes les requêtes d'insertion ont été générées, le script ouvre le fichier "db_tables.sql" en lecture et lit son contenu. ICI
Ensuite, les requêtes d'insertion sont concaténées avec le contenu du fichier pour former le script d'initialisation complet.

# Ouvre le fichier db_tables.sql en lecture
with open('db_tables.sql', 'r') as file:
    db_tables_sql = file.read()

Enfin, le contenu final, comprenant le contenu initial du fichier "db_tables.sql" et les requêtes d'insertion tout juste créer, est écrit dans le fichier "init.sql". Ce fichier sera utilisé ultérieurement pour initialiser la base de données avec des données aléatoires directement injecté dans cette dernière.

# Concatener le contenu du fichier db_tables.sql avec les requetes creer 
init_sql = db_tables_sql + "\n" + "\n".join(insert_queries)

# Ecrire le contenu dans le fichier init.sql
with open('init.sql', 'w') as file:
    file.write(init_sql)

Toutes ces étapes permettent de créer un fichier final "init.sql" qui contient les instructions SQL nécessaires pour créer notre base de donnée "infrastructure" avec son schéma et ses tables puis de provisionner ces tables avec des données aléatoires.

Clone this wiki locally