Faculté des Sciences et Techniques

Tanger

Projet CLOUD COMPUTING

Élève : Encadrants :
BEN SAADA Ziad Chaker EL
AMRANI
Contents
Part 1: CloudSim.............................................................................................................................4
Aperçu des besoins cloud de l'UAE.....................................................................................................4
Architecture cloud proposée..............................................................................................................4
Modèles de service :.......................................................................................................................4
Modèles de déploiement :..............................................................................................................4
Composants principaux :................................................................................................................5
Description des scénarios simulés......................................................................................................5
Scénario 1 : Pic d'utilisation des plateformes d'apprentissage en ligne..........................................5
Scénario 2 : Besoins en calcul pour la recherche............................................................................5
Scénario 3 : Services administratifs en ligne...................................................................................5
Simulation Scénario 1 avec CloudSim.................................................................................................6
Résultats et analyse des simulations................................................................................................11
Résumé des résultats :..................................................................................................................11
Analyse des résultats :..................................................................................................................11
Recommandations :..........................................................................................................................11
Part 2: OpenStack................................................................................................................................13
Test the Middleware Functionality...................................................................................................13
Keystone (Identity Service):..........................................................................................................13
Glance (Image Service):................................................................................................................14
Neutron (Networking Service):.....................................................................................................15
Implement an IaaS............................................................................................................................16
Develop a SaaS.................................................................................................................................23
Prepare cirrOS Instance................................................................................................................23
Create a Static HTML Page............................................................................................................24
Start the netcat HTTP Server........................................................................................................24
Allow HTTP Traffic.........................................................................................................................24
Test the SaaS.................................................................................................................................25
Part 3: Service Level Agreement (SLA).................................................................................................26
Création de fichier SLA.....................................................................................................................26
Install Virtual Environment Tools:.................................................................................................26
Create a Virtual Environment:......................................................................................................26
Activate the Virtual Environment:................................................................................................27
Install openstacksdk:....................................................................................................................27
Création de Script Python.................................................................................................................27
Déploiement du Script......................................................................................................................29
 Configuration les Variables d’Environnement :.............................................................................29
Exécution du Script :.....................................................................................................................29
Résultats dans le Fichier sla.txt:....................................................................................................29
Explications des Modules Utilisés.................................................................................................29
Rapport Final Exemple dans sla.txt:..................................................................................................30
Part 1: CloudSim
Aperçu des besoins cloud de l'UAE
L'Université Abdelmalek Essaâdi est composée de 16 établissements
universitaires répartis sur plusieurs villes, notamment Tétouan, Tanger, Larache
et Al Hoceima.

L'effectif des étudiants dépasse les 60 000, dont 3 000 doctorants.

Les besoins spécifiques de l'UAE incluent :

 Plateformes d'apprentissage en ligne : pour faciliter l'enseignement à

distance et les ressources pédagogiques.
 Ressources informatiques pour la recherche : pour soutenir les
projets de recherche nécessitant une puissance de calcul élevée.
 Services administratifs numériques : pour gérer les inscriptions, les
dossiers étudiants et les communications internes.
 Outils de collaboration : pour favoriser le travail en équipe entre
étudiants, enseignants et chercheurs.

Architecture cloud proposée

Pour répondre aux besoins de l'UAE, une architecture cloud hybride est
recommandée, combinant des solutions de cloud privé et public.

Modèles de service :

 Infrastructure en tant que service (IaaS) : fournir des machines

virtuelles et du stockage pour les besoins de recherche et administratifs.
 Plateforme en tant que service (PaaS) : offrir des plateformes pour le
développement d'applications par les étudiants et les chercheurs.
 Logiciel en tant que service (SaaS) : héberger des applications telles
que des plateformes d'apprentissage en ligne et des outils de
collaboration.

Modèles de déploiement :

 Cloud privé : pour les données sensibles et les systèmes internes de

l'université.
 Cloud public : pour les services nécessitant une évolutivité, comme les
plateformes d'apprentissage en ligne.

Composants principaux :

 Machines virtuelles : pour exécuter les applications et services

nécessaires.
 Stockage cloud : pour les documents, les ressources pédagogiques et les
données de recherche.
 Réseautage : pour assurer une communication fluide entre les différents
campus et les ressources cloud.
Pour concevoir une architecture cloud adaptée à l'Université Abdelmalek Essaâdi (UAE), il
est essentiel de comprendre ses besoins spécifiques, de proposer une architecture cloud
appropriée, de décrire les scénarios simulés, d'analyser les résultats des simulations et de
recommander le meilleur scénario.

Description des scénarios simulés

Pour évaluer l'efficacité de l'architecture proposée, plusieurs scénarios
peuvent être simulés :

Scénario 1 : Pic d'utilisation des plateformes d'apprentissage

en ligne

o Objectif : évaluer la performance du système lors des périodes de

forte affluence, comme les examens.
o Simulation : modéliser une augmentation significative du trafic et
observer la réponse du système.

Scénario 2 : Besoins en calcul pour la recherche

o Objectif : tester la capacité du cloud à gérer des tâches de calcul

intensives pour les projets de recherche.
o Simulation : allouer des ressources pour des simulations complexes
et mesurer les temps de traitement.

Scénario 3 : Services administratifs en ligne

o Objectif : assurer la disponibilité et la fiabilité des services

administratifs numériques.
o Simulation : introduire des pannes simulées et évaluer les
mécanismes de reprise.

Simulation Scénario 1 avec CloudSim

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.*;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.*;

public class Scenario1Simulation {

public static DatacenterBroker broker;
private static List<Cloudlet> cloudletList;
 private static List<Vm> vmlist;

public static void main(String[] args) {

Log.println("Starting E-Learning Platform Peak Usage Simulation...");

try {
// Initialize CloudSim
int num_user = 1;
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false;

CloudSim.init(num_user, calendar, trace_flag);

// Create Datacenter
Datacenter datacenter0 = createDatacenter("Datacenter_0");

// Create Broker
broker = new DatacenterBroker("Broker");
int brokerId = broker.getId();

// Create VMs for different services

vmlist = new ArrayList<>();

// Different VM configurations for different services

int[] mipsConfigs = {2000, 1500, 1000}; // High, medium, and low
performance VMs
int[] ramConfigs = {4096, 2048, 1024}; // RAM configurations in MB

int vmid = 0;
// Create VMs of different configurations
for (int config = 0; config < mipsConfigs.length; config++) {
for (int i = 0; i < 5; i++) { // 5 VMs of each type
Vm vm = new Vm(vmid++, brokerId, mipsConfigs[config], 2,
ramConfigs[config], 1000, 10000, "Xen",
new CloudletSchedulerTimeShared());
vmlist.add(vm);
}
}

broker.submitGuestList(vmlist);

// Create cloudlets representing different e-learning activities

cloudletList = new ArrayList<>();

// Different lengths for different types of activities

long[] taskLengths = {
10000, // Light tasks (page views, quiz submissions)
25000, // Medium tasks (video streaming, file uploads)
50000 // Heavy tasks (video conferencing, complex simulations)
 };

int cloudletId = 0;
// Simulate peak period with many concurrent users
for (int userId = 0; userId < 500; userId++) { // 500 concurrent users
for (int taskType = 0; taskType < taskLengths.length; taskType++) {
Cloudlet cloudlet = new Cloudlet(cloudletId++,
taskLengths[taskType],
2, 300, 300, new UtilizationModelFull(),
new UtilizationModelFull(), new UtilizationModelFull());
cloudlet.setUserId(brokerId);
cloudletList.add(cloudlet);
}
}

broker.submitCloudletList(cloudletList);

// Start simulation
CloudSim.startSimulation();

// Get results
List<Cloudlet> newList = broker.getCloudletReceivedList();
CloudSim.stopSimulation();

printCloudletList(newList);

Log.println("E-Learning Platform Peak Usage Simulation finished!");

} catch (Exception e) {
e.printStackTrace();
Log.println("The simulation has been terminated due to an unexpected
error");
}
}

private static Datacenter createDatacenter(String name) {

List<Host> hostList = new ArrayList<>();

// Create powerful hosts to handle peak load

List<Pe> peList = new ArrayList<>();
int mips = 3000; // Higher MIPS for better performance

// 4 processors per host

for(int i = 0; i < 4; i++) {
peList.add(new Pe(i, new PeProvisionerSimple(mips)));
}

// Create hosts with high capacity

int ram = 32768; // 32 GB RAM
 long storage = 2000000; // 2 TB storage
int bw = 20000; // 20 Gbps

// Create multiple hosts

for(int hostId = 0; hostId < 3; hostId++) { // 3 powerful hosts
hostList.add(new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
));
}

String arch = "x86";

String os = "Linux";
String vmm = "Xen";
double time_zone = 10.0;
double cost = 3.0;
double costPerMem = 0.05;
double costPerStorage = 0.001;
double costPerBw = 0.0;

DatacenterCharacteristics characteristics = new DatacenterCharacteristics(

arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw);

Datacenter datacenter = null;

try {
datacenter = new Datacenter(name, characteristics,
new VmAllocationPolicySimple(hostList), new LinkedList<Storage>(),
0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

private static void printCloudletList(List<Cloudlet> list) {

int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.println();
Log.println("========== E-Learning Platform Peak Usage Results
==========");
Log.println("Cloudlet ID" + indent + "STATUS" + indent +
 "Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

int successfulTasks = 0;
double totalResponseTime = 0.0;
double maxResponseTime = 0.0;

for (Cloudlet value : list) {

cloudlet = value;
Log.print(indent + cloudlet.getCloudletId() + indent + indent);

if (cloudlet.getStatus() == Cloudlet.CloudletStatus.SUCCESS) {
successfulTasks++;
double responseTime = cloudlet.getFinishTime() -
cloudlet.getExecStartTime();
totalResponseTime += responseTime;
maxResponseTime = Math.max(maxResponseTime, responseTime);

Log.print("SUCCESS");
Log.println(indent + indent + cloudlet.getResourceId() +
indent + indent + cloudlet.getGuestId() +
indent + indent + dft.format(cloudlet.getActualCPUTime()) +
indent + indent + dft.format(cloudlet.getExecStartTime()) +
indent + indent + dft.format(cloudlet.getFinishTime()));
}
}

// Print analysis for e-learning platform performance

Log.println("\n============= Performance Analysis
=============");
Log.println("Total number of tasks: " + size);
Log.println("Successfully completed tasks: " + successfulTasks);
Log.println("Success Rate: " + dft.format((successfulTasks * 100.0) / size) +
"%");
Log.println("Average Response Time: " + dft.format(totalResponseTime /
successfulTasks) + " seconds");
Log.println("Maximum Response Time: " + dft.format(maxResponseTime) + "
seconds");

Log.println("==========================================
====");
}
}

 Performance Analysis
Résultats et analyse des simulations
La simulation pour le scénario de pic d'utilisation des plateformes
d'apprentissage en ligne a été réalisée avec succès. Les résultats obtenus sont
les suivants :

Résumé des résultats :

 Nombre total de tâches simulées (Cloudlets) : 1500

 Tâches complétées avec succès : 1500
 Taux de réussite : 100%
 Temps de réponse moyen : 1798,58 secondes
 Temps de réponse maximal : 4249,93 secondes

Analyse des résultats :

1. Taux de réussite :
o Un taux de réussite de 100 % indique que toutes les tâches ont été
correctement exécutées par les machines virtuelles (VM). Cela
montre que l'infrastructure cloud configurée est suffisante pour
gérer la charge de travail générée pendant les périodes de forte
affluence.

2. Temps de réponse moyen :

o Le temps de réponse moyen est relativement élevé (1798,58
secondes), ce qui peut être attribué au grand nombre de tâches
simultanées et à la complexité des calculs. Cela suggère que
l'infrastructure peut nécessiter des améliorations, comme l'ajout de
VMs plus performantes ou l'optimisation des allocations des tâches.

3. Temps de réponse maximal :

o Le temps de réponse maximal (4249,93 secondes) indique que
certaines tâches, probablement les plus complexes (par exemple,
les simulations vidéo ou les tâches de conférence en ligne), ont pris
beaucoup de temps à s'exécuter. Cela reflète une surcharge
temporaire des ressources.
Recommandations :
La simulation montre que l'architecture cloud est fonctionnelle pour gérer le pic d'utilisation
des plateformes d'apprentissage en ligne. Cependant, pour améliorer davantage les
performances, les actions suivantes sont recommandées :

 Ajouter des machines virtuelles avec des capacités plus élevées (plus de MIPS et de RAM)
pour réduire les temps de réponse.
 Optimiser l'algorithme d'allocation des ressources pour mieux équilibrer la charge entre les
machines virtuelles.

 Évaluer l'impact de la redondance (ajout d'autres Datacenters) pour garantir une meilleure
répartition de la charge en cas de surcharge.

Part 2: OpenStack
Test the Middleware Functionality
OpenStack middleware facilitates various services (e.g., Keystone for
identity, Neutron for networking, and Glance for images). To test it:

Keystone (Identity Service):

o List available projects:

$ openstack project list

o Create a new user to verify it works:

$ openstack user create --domain default --password testuser testuser

 Glance (Image Service):

o Verify image listing:

$ openstack image list

o Add a test image:

$ wget http://download.cirros-cloud.net/0.6.1/cirros-0.6.1-x86_64-
disk.img

$ openstack image create "cirros" --file cirros-0.6.1-x86_64-

disk.img --disk-format qcow2 --container-format bare --public
 Neutron (Networking Service):

o Verify networks:

$ openstack network list

o Create a new network for testing:

$ openstack network create test-network

$ openstack subnet create --network test-network --subnet-range 192.168.1.0/24 test-
subnet
Implement an IaaS
 Create router from network/Router

 Create Internal Network Network network/network

 Add this network to the interface of the router just created

 Create Instance Compute/Instances
 Click Launch Instance

 Source : select the image

 Flavor: select the requirements

 Network: select network just created (ext-net)

  Key Pair: import public key

$ ssh-keygen -t rsa -b 4096

 After that , Launch Instance

 In Instance , Action , click on Associate Floating IP

 Click on Allocate Floating IP

 And then Allocate IP

 And Then Associate.

 pour connecter via ssh , we need to add a rule to work Network/Security
Groups
  and then manage rules -> add rule

 And then click add

 Now from my machine:

$ ssh [email protected]
  I connect with rsa key without any password!

 This is our Network Topology

Develop a SaaS
Prepare cirrOS Instance

 Access the cirrOS Instance:

$ ssh [email protected]

 Verify netcat Availability: cirrOS includes netcat by default. Confirm

it's available:

$ nc --version

 If it outputs a version, it’s good to go.

Create a Static HTML Page

Since cirrOS cannot run sophisticated servers like Apache, we serve static
content instead.

 Create an HTML file inside the instance:

$ echo "<h1>Welcome to Our SaaS Application!</h1>" > index.html

Start the netcat HTTP Server

 Use netcat to serve the HTML file on port 80:

 $ while true; do
echo -e "HTTP/1.1 200 OK\r\a-Length: $(wc -c < index.html)\r\n\r\n$(cat index.html)"
| nc -l -p 80;
done

 This command:

o Creates an HTTP response header (HTTP/1.1 200 OK).

o Reads the content of index.html.
o Listens on port 80 using netcat.

Allow HTTP Traffic

 Open the HTTP port (80) in OpenStack's security group:

 Or with command line

$ openstack security group rule create --proto tcp --dst-port 80 default

Test the SaaS

 Open a web browser on local machine.

 Enter the floating IP of the cirrOS instance:

$ http://<floating-ip> ( in my case 10.0.3.20 )

Part 3: Service Level Agreement (SLA)
Cette solution inclut la création du fichier SLA, le développement du programme
Python pour la surveillance des instances, et l'intégration des rapports dans le
fichier SLA.

Création de fichier SLA

Le fichier SLA contiendra les termes de l'accord, notamment l'objectif de
disponibilité à 99,5 % et les règles de surveillance.

 Exemple de contenu de sla.txt :

Service Level Agreement (SLA)

Objectif :
- Surveiller la disponibilité des instances OpenStack.

Conditions :
- Les instances doivent avoir une disponibilité minimale de 99.5% sur une
période d'évaluation quotidienne.
- La disponibilité sera surveillée toutes les 5 minutes.

Rapports :
- Un rapport journalier sera généré et inclus à la fin de ce fichier.
Date de début de l'accord : 2025-01-19

Install Virtual Environment Tools:

$ sudo apt install python3-venv -y

Create a Virtual Environment:

 Create a directory for the virtual environment and initialize it:

$ mkdir ~/openstack-env
$ python3 -m venv ~/openstack-env

Activate the Virtual Environment:

 Activate the virtual environment:

$ source ~/openstack-env/bin/activate
 Install openstacksdk:

 The virtual environment is activated, now we can use pip:

$ pip install openstacksdk

Création de Script Python
Le script doit surveiller la disponibilité des instances toutes les 5 minutes,
calculer leur disponibilité sur une période quotidienne, et inclure les résultats
dans le fichier sla.txt.

 Code Python :

import time
from datetime import datetime, timedelta
from openstack import connection

# Connexion à OpenStack
def connect_to_openstack():
conn = connection.Connection(
auth_url="http://10.0.3.8/identity",
project_name="admin",
username="admin",
password="ziadadmin”,
user_domain_name="Default",
project_domain_name="Default",
)
return conn

# Surveiller la disponibilité des instances

def monitor_instances(conn, sla_file):
# Récupérer toutes les instances
instances = conn.compute.servers()
total_instances = 0
available_instances = 0

for instance in instances:

total_instances += 1
# Vérifier l'état de l'instance
if instance.status.lower() == "active":
available_instances += 1

# Calculer la disponibilité
availability = (available_instances / total_instances) * 100 if total_instances
> 0 else 0
return availability, total_instances, available_instances

# Ajouter les résultats au fichier SLA

def update_sla_report(sla_file, availability, total_instances, available_instances):
with open(sla_file, "a") as file:
file.write("\n")
 file.write(f"Rapport de surveillance : {datetime.now()}\n")
file.write(f"Instances totales : {total_instances}\n")
file.write(f"Instances disponibles : {available_instances}\n")
file.write(f"Disponibilité : {availability:.2f}%\n")
file.write("-" * 50 + "\n")

# Script principal
def main():
sla_file = "sla.txt"
conn = connect_to_openstack()

start_time = datetime.now()
end_time = start_time + timedelta(days=1) # Surveiller pendant 24 heures

while datetime.now() < end_time:

availability, total_instances, available_instances =
monitor_instances(conn, sla_file)
update_sla_report(sla_file, availability, total_instances,
available_instances)
print(f"Surveillance effectuée. Disponibilité actuelle : {availability:.2f}%")
time.sleep(300) # Pause de 5 minutes

print("Surveillance quotidienne terminée.")

if __name__ == "__main__":
main()

Déploiement du Script
Configuration les Variables d’Environnement :

$ Source ~/devstack/openrc

Exécution du Script :

 Lancement de script avec Python :

$ python monitor_sla.py
 Résultats dans le Fichier sla.txt:

 Chaque exécution de surveillance ajoutera une section de rapport avec les

résultats actuels.

Explications des Modules Utilisés

 Nova (Compute):

o Récupère l’état des instances (ex. : ACTIVE, ERROR).

 Ceilometer (Telemetry):

o Peut être utilisé pour collecter des métriques supplémentaires

(optionnel dans ce projet).

 Keystone (Identity):

o Authentifie et autorise les interactions avec OpenStack.

 Neutron (Networking):

o Fournit des informations sur les réseaux et connectivité des

instances.

Rapport Final Exemple dans sla.txt:

Service Level Agreement (SLA)

Objectif :
- Surveiller la disponibilité des instances OpenStack.

Conditions :
- Les instances doivent avoir une disponibilité minimale de 99.5% sur une
période d'évaluation quotidienne.
- La disponibilité sera surveillée toutes les 5 minutes.
Rapports :
- Un rapport journalier sera généré et inclus à la fin de ce fichier.

Date de début de l'accord : 2025-01-19

--------------------------------------------------
Rapport de surveillance : 2025-01-19 10:00:00
Instances totales : 10
Instances disponibles : 10
Disponibilité : 100.00%
--------------------------------------------------

Rapport de surveillance : 2025-01-19 10:05:00

Instances totales : 10
Instances disponibles : 9
Disponibilité : 90.00%
--------------------------------------------------