CloudSim, simulateur du Cloud computing

Le framework de simulation de l'environement du Cloud

Pourquoi la Simulation?

Dans un système distribué, il existe des enjeux à résoudre tels que la gestion des ressources et l'ordonnancement des applications car, ces taches sont compliquées et il n'existe pas une solution optimale pour répondre à ces issues. D'autre part, dans l'environnement d'un système distribué comme Cloud, il est difficile d'effectuer les différents scénarios avec différent nombres de ressources et utilisateurs afin d'évaluer la performance des algorithmes du partage de charge, Broker, gestion des ressources...etc. Lorsque on veut évaluer les scénarios de manière répétable et contrôlable, cela est parfois impossible car l'issue du coût et la gestion. Afin de résoudre cette issue, les chercheurs utilisent les simulateurs pour effectuer leur scénarios avant de les effectuer au sein d'un système distribué réel. Dans ce qui suit, on va présenter l'un des outils de simulation le plus connu et utilisé dans le domaine de simulation du Cloud.

CloudSim

Ce framework modélise et simule l'environnement du Cloud computing et ses services, a été réalisé en Java. Afin que nous puissions simuler cet environnement, il faut connaitre l'architecture de ce framework.

La figure illustre les différentes couches de la structure du CloudSim et ses éléments architecturaux. Au niveau le plus bas est le moteur de simulation aux événements discrets SimJava, qui implémente les fonctionnalités de base requises pour les cadres de simulation au niveau supérieur, telles que les files d'attente, le traitement des événements, création de composants du système (services, hôte, Datacenter, Broker, les machines virtuelles), la communication entre les composants et la gestion de l'horloge de simulation.

CloudSim supporte la modélisation et la simulation de l'environnement de Datacenter basé sur Cloud, tel que des interfaces de gestion dédiées aux VMs, la mémoire, le stockage et la bande passante. La couche CloudSim gère l'instanciation et l'exécution des entités de base (VM, hôtes, Datacenters, applications) au cours de la période de simulation. Dans la couche plus haute de la pile de simulation, on trouve le code de l'utilisateur qui expose la configuration des fonctionnalités liées aux hôtes (ex: nombre de machines, leurs spécifications), les politiques d'ordonnancement de Broker, applications ( ex: nombre de tâches et leurs besoins), VM, nombre d'utilisateurs. Les fichiers du CloudSim sont accessible ici.

Pour utiliser ce framework, il faut un outil de programmation. C'est pour cela, on utilise Eclipse pour faire la programmation en Java. La vidéo ci-dessous montre comment intégrer CloudSim dans Eclipse. Il est nécessaire de connaissance la programmation en Java

De nos jours, offrir des services tels que site de commerce, stockage online et réseaux sociaux sur internet est augmente. Les clients utilisent des sites de commerce ou des réseaux sociaux pour leur achats ou communication. D'autre part, des utilisateurs sont dans les endroits différents (partagés sur la planète) par conséquent, il est nécessaire de rendre ces services à la fois rapide et fiable. Pour ce faire, il faut une architecture bien configurée qui puisse traiter les requêtes envoyées depuis les clients vers les serveurs traitant des services proposés, dans un court délai de temps et de manière fiable pour satisfaire le client. Afin de porter ces services, on utilise les systèmes distribués, comme technologie, on peut citer le Cloud et la grille.

Le Cloud computing est la prestation de services informatiques sur Internet. Ses services permettent à des individus et des entreprises d'utiliser les logiciels et les matériels qui sont gérées par les tiers sur les sites distants. Les services proposés par le Cloud comprennent le stockage de fichiers en ligne, sites de réseaux sociaux, webmail, et les applications en ligne. Le modèle de Cloud computing permet d'accéder à des ressources d'information et de l'informatique depuis n'importe quel endroit, où une connexion réseau est disponible. Les avantages du Cloud computing comprennent l'économie de coûts, la haute disponibilité et l'évolutivité facile.

Outils de simulation

Il y a plusieurs outils de simulation de systèmes distribués. Les plus connus sont GridSim, CloudSim, Simgrid. Dans ce qui suit, on va présenter le framework CloudSim, qui permet de la simulation de l'environnement du Cloud computing.

Parametrage de la simulation

L'intégration du CloudSim dans Eclipse

Dans cet exemple, la configuration de la VM est:

//VM description
     int vmid = 0;//vm id
     int mips = 250;//number of operations
     long size = 10000; //image size (MB)
     int ram = 512; //vm memory (MB)
     long bw = 1000;//vm bandwidth
     int pesNumber = 1; //number of cpus
     String vmm = "Xen"; //VMM name

//create VMs
      Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());

Et la configuration de l'hôte est:

//create host
     List<Host> hostList = new ArrayList<Host>();
     List<Pe> peList = new ArrayList<Pe>();
      int mips = 1000;
      peList.add(new Pe(0, new PeProvisionerSimple(mips))); // need to store Pe id and MIPS Rating
      int hostId=0;
      int ram = 2048; //host memory (MB)
      long storage = 1000000; //host storage
      int bw = 10000;

      hostList.add(
                        new Host(
                                hostId,
                                new RamProvisionerSimple(ram),
                                new BwProvisionerSimple(bw),
                                storage,
                                peList,
                                new VmSchedulerSpaceShared(peList)
                        )
                );

Et finalement le Datacenter:

      String arch = "x86";      // system architecture
      String os = "Linux";          // operating system
      String vmm = "Xen";
      double time_zone = 10.0;         // time zone this resource located
      double cost = 3.0;              // the cost of using processing in this resource
      double costPerMem = 0.05;               // the cost of using memory in this resource
      double costPerStorage = 0.001;  // the cost of using storage in this resource
      double costPerBw = 0.0;                 // the cost of using bw in this resource
      LinkedList<Storage> storageList = new LinkedList<Storage>();    //we are not adding SAN devices by now

       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), storageList, 0);
                } catch (Exception e) {
                        e.printStackTrace();
                }

Architecture du CloudSim

Maintenant, notre infrastructure du Cloud est prête à utiliser pour la simulation d’une application distribuée. Par exemple, on a une application qui est composée de 2 parties et chaque partie doit être s'exécutée sur une machine virtuelle et puis les données sont échangées entre ces deux parties aussi entre les machines. Pour ce faire, il faut écrire une classe qui simule le comportement d’une application. L’exemple ci-dessous (basé sur l'exemple ici), est un exemple de simulation de Client/Serveur. Le client envoi des paquets ICMP vers le serveur et le serveur lui répond.

* This class simulates Client/Server architecture.
* We have two Vms, one that plays the role of Client and another one Server.
 
   package org.cloudbus.cloudsim.network.datacenter;

import java.util.List;
   import org.cloudbus.cloudsim.UtilizationModel;
   import org.cloudbus.cloudsim.UtilizationModelFull;
   import org.cloudbus.cloudsim.core.CloudSim;

public class ClientServerApp extends AppCloudlet {
	int packetsize = 400;//Size of each packet
	int numpacket = 100;//Number of Packet for sending to server
	int client;//ID of client machine
	
	
	public ClientServer(int type, intappID, double deadline, intnumbervm,
			intuserId) {
		super(type, appID, deadline, numbervm, userId);
		exeTime = 100;
		this.numbervm = 2;
	}

@Override
	public void create CloudletList(List<Integer>vmIdList) {
		long fileSize = NetworkConstants.FILE_SIZE;
		long outputSize = NetworkConstants.OUTPUT_SIZE;
		int memory = 100;
		UtilizationModel utilizationModel = new UtilizationModelFull();
		int vm_client = vmIdList.get(0);// get ID of client 
		int vm_server = vmIdList.get(1);//get ID of server
		
		//Task(client)
		NetworkCloudlet cl_client = new NetworkCloudlet(NetworkConstants.currentCloudletId, 0, 1, fileSize, outputSize,memory, utilizationModel, utilizationModel, utilizationModel);
		cl_client.numStage = 1+2*numpacket;
		NetworkConstants.currentCloudletId++;
		cl_client.setUserId(userId);
		cl_client.submittime = CloudSim.clock();
		cl_client.setVmId(vm_client);
		
		// Define Stages of Task
		cl_client.stages.add(new TaskStage(NetworkConstants.EXECUTION, 0, 1000 * 0.8,
				0, memory, vm_client, cl_client.getCloudletId()));// This execution stage of this Cloudlet
		
		//This is Sending stage of this cloudlet,packets will be send to the server up to numpacket
		for(int count=1;count<=numpacket;count++){
			cl_client.stages.add(new TaskStage(NetworkConstants.WAIT_SEND, PacketType.ICMP_REQUEST, 0, count,memory, vm_server, cl_client.getCloudletId() + 1));
		}
		
		//in this stage,Cloudlet waits for receiving reply from server  
		/*for(int m=numpacket+1;m<=2*numpacket;m++){
		cl_client.stages.add(new TaskStage(NetworkConstants.WAIT_RECV, PacketType.ICMP_REPLY, 0, m,
				memory, vm_server, cl_client.getCloudletId()+1));
		}*/
		clist.add(cl_client);
			
				
		// Task(server)
		NetworkCloudlet cl_server = new NetworkCloudlet(NetworkConstants.currentCloudletId, 0, 1, fileSize, outputSize,memory, utilizationModel, utilizationModel, utilizationModel);
		cl_server.numStage = 2*numpacket+1;
		NetworkConstants.currentCloudletId++;
		cl_server.setUserId(userId);
		cl_server.submittime = CloudSim.clock();
		//cl_server.currStagenum = -1;
		cl_server.setVmId(vm_server);//on which VM we want to Execute the task of server.
		// first stage: big computation
		for(int cn1=0;cn1<numpacket;cn1++){
			cl_server.stages.add(new TaskStage(NetworkConstants.WAIT_RECV, PacketType.ICMP_REQUEST, 0, cn1,
   memory, vm_cleint, cl_client.getCloudletId()));
		}
		cl_server.stages.add(new TaskStage(NetworkConstants.EXECUTION, 0, 1000 * 0.8,
				numpacket, memory, vm_server, cl_server.getCloudletId()));
		
		//in this stage, server VM replies to the sender VM
		for(int k = numpacket+1; k<=2*numpacket;k++){
		cl_server.stages.add(new TaskStage(NetworkConstants.WAIT_SEND, PacketType.ICMP_REPLY, 0, k,
		memory, vm_client, cl_client.getCloudletId()));
		}
		
		clist.add(cl_server);

}
}

Maintenant, notre simulation est prête à exécuter !

Dans CloudSim, il y a deux aspects importants, Broker et Cloudlet. Broker gère la création de vms, la soumission aux VMs et la destruction de VMs et les Cloudlet sont les taches à exécuter sur les machines virtuelles. La dernière version de CloudSim, nous permet de faire le réseau entre les hôtes dans un datacenter, aussi entre les datacenters en utilisant de Switchs et Routeurs.

[1]	Rodrigo N Calheiros, Rajiv Ranjan, César AF De Rose, and Rajkumar Buyya. Cloudsim: A novel framework for modeling and simulation of cloud computing infrastructures and services. arXiv preprint arXiv:0903.2525, 2009.
[2]	Saurabh Kumar Garg and Rajkumar Buyya. Networkcloudsim: Modelling parallel applications in cloud simulations. In Utility and Cloud Computing (UCC), 2011 Fourth IEEE International Conference on, pages 105-113. IEEE, 2011.
[3]	www.cloudbus.org

Référence

Lien outile

[Youtube]Learning CloudSim

Dans cette partie, on va voir comment simuler une application distribuée au sein d'un Cloud. Chaque Cloud est constitué des

Datacenters et dans le dernier, on trouve des hôtes et chaque hôte héberge les VMs. Pour faire la simulation, il faut définir une

classe qui contient la fonction Main(), dans laquelle, on définit les paramètres de notre Cloud comme le nombre de Datacenter,

hôtes, les caractéristiques de chaque hôte et VM comme la bande passante, CPU et RAM. Sur le

site de Cloudbus.org , il existe plusieurs exemples.

20 Jan 2015 22:05

En général, il y a trois types de services proposés par les fournisseurs de Cloud, selon [NIST] :

- Software-as-a-Service (SaaS) : Le service proposé est une application qui est accessible par Internet. En effet, au lieu d'installer et de maintenance des logiciels, il suffit à une connexion d'Internet pour accéder au service.
- Platform-as-a-Service (PaaS) : Ce modèle offre des plates-formes d'exploitation et de développement au consommateur. Le consommateur peut utiliser la plate-forme pour développer et exécuter ses propres applications, soutenues par une infrastructure fournie par le fournisseur de Cloud.
- Infrastructure-as-a-Service (IaaS) : C'est le modèle de service plus bas dans la pile technologie de Cloud, offrant des ressources d'infrastructure comme un service, tel que le stockage de données brutes, la puissance de traitement et la capacité du réseau.

D'autre part, il y a 4 modèles de déploiement de Cloud :

- Privé : Cloud privé est détenu et exploité par une seule société, et les services fournis par le Cloud sont utilisés par les différents secteurs d'activité dans la même entreprise.
- Public : Les Clouds publics sont détenus et exploités par les fournisseurs pour offrir un accès rapide à des ressources informatiques abordables à d'autres organisations ou individus.
- Hybride : Ce Cloud utilise la base de Cloud privé combiné avec les stratégies d'usage de services du Cloud public.
- Communauté : Le Cloud partagé qui est destiné à un ensemble limité d'organisations(universités).