How to Implement Interoperability Cloud in NS2

To implement the Cloud Interoperability in ns2 encompasses to simulate a network with numerous clouds (private, public or hybrid) communicate and interoperate with one another. It permits various cloud service suppliers to work together, share resources and make certain effortless service provisioning over heterogeneous cloud scenarios. It can be prototyped by building several cloud systems (clusters of nodes) that interact and share resources via networks in ns2.

We have to simulate the interoperability amongst clouds by designing clusters of nodes (denoting various clouds) and accomplishing communication links amidst them. Due to ns2 lacks the cloud-related functionalities. The key characteristics of cloud interoperability to simulate are:

  1. Network Communication amongst various cloud infrastructures.
  2. Resource Sharing and data exchange amongst clouds.
  3. Routing and traffic management to manage communication amidst cloud systems.

Key Steps for Implementing Cloud Interoperability in NS2:

  1. Modeling Multiple Clouds: Replicate several cloud systems as clusters of nodes.
  2. Establishing Communication Between Clouds: Set up links and routes amongst the clouds.
  3. Traffic Setup: Simulate data exchange and resource sharing amidst clouds.
  4. Interoperability Simulation: Handle various network types and protocols amongst clouds (such as cloud 1 uses IPv4, and cloud 2 uses IPv6).
  1. NS2 Setup: Simulate Multiple Cloud Systems

Start by configuring the NS2 to simulate various cloud organisations as clusters of nodes. Each cloud system is a pair of nodes that interact into the cloud and with other clouds.

# Create an NS2 simulator instance

set ns [new Simulator]

# Create trace files to log the simulation

set tracefile [open “cloud_interoperability.tr” w]

set namfile [open “cloud_interoperability.nam” w]

$ns trace-all $tracefile

$ns namtrace-all-wireless $namfile 1000 1000

# Define channel for communication

set chan_1_ [new Channel/WirelessChannel]

# Define wireless channel properties for clouds

set prop [new Propagation/TwoRayGround]

set netif [new Phy/WirelessPhy]

set mac [new Mac/802_11]      ;# Assume Wi-Fi for simplicity

set ll [new LL]

set ifq [new Queue/DropTail/PriQueue]

set ant [new Antenna/OmniAntenna]

# Node configuration for cloud systems

$ns node-config -adhocRouting AODV \

-llType $ll \

-macType $mac \

-ifqType $ifq \

-ifqLen 50 \

-antType $ant \

-propType $prop \

-phyType $netif \

-channel $chan_1_

  1. Modeling Cloud Systems as Clusters of Nodes

State two various clouds (Cloud 1 and Cloud 2) as clusters of nodes. These clouds will communicate with one another, and the nodes inside each cloud will manage intra-cloud communication.

Cloud 1 Setup

# Define nodes for Cloud 1

set cloud1_node1 [$ns node]

set cloud1_node2 [$ns node]

set cloud1_node3 [$ns node]

# Position Cloud 1 nodes in space

$cloud1_node1 set X_ 100

$cloud1_node1 set Y_ 100

$cloud1_node2 set X_ 150

$cloud1_node2 set Y_ 100

$cloud1_node3 set X_ 200

$cloud1_node3 set Y_ 100

Cloud 2 Setup

# Define nodes for Cloud 2

set cloud2_node1 [$ns node]

set cloud2_node2 [$ns node]

set cloud2_node3 [$ns node]

# Position Cloud 2 nodes in space

$cloud2_node1 set X_ 400

$cloud2_node1 set Y_ 400

$cloud2_node2 set X_ 450

$cloud2_node2 set Y_ 400

$cloud2_node3 set X_ 500

$cloud2_node3 set Y_ 400

  1. Establish Communication Between Clouds

To allow communication amongst Cloud 1 and Cloud 2, build network links amidst the cloud systems. This simulates an environment where two different clouds (private or public) can interoperate and interchange data.

# Create links between Cloud 1 and Cloud 2

$ns duplex-link $cloud1_node3 $cloud2_node1 1Mb 10ms DropTail

$ns duplex-link $cloud1_node2 $cloud2_node2 1Mb 10ms DropTail

  1. Traffic Setup: Data Exchange Between Clouds

Use TCP and UDP traffic flows to simulate data exchange between Cloud 1 and Cloud 2. This indicates the sharing of resources or services among the cloud systems.

Example: TCP Data Exchange Between Cloud 1 and Cloud 2

# Create TCP agent for communication from Cloud 1 to Cloud 2

set tcp_cloud1 [new Agent/TCP]

set tcpSink_cloud2 [new Agent/TCPSink]

# Attach TCP agent to Cloud 1 node and TCP sink to Cloud 2 node

$ns attach-agent $cloud1_node1 $tcp_cloud1

$ns attach-agent $cloud2_node1 $tcpSink_cloud2

# Connect TCP agent to TCP Sink (Cloud 1 to Cloud 2)

$ns connect $tcp_cloud1 $tcpSink_cloud2

# Configure FTP application for file transfer between clouds

set ftp_cloud1 [new Application/FTP]

$ftp_cloud1 attach-agent $tcp_cloud1

# Start and stop FTP communication between clouds

$ns at 1.0 “$ftp_cloud1 start”

$ns at 10.0 “$ftp_cloud1 stop”

Example: UDP Data Exchange Between Cloud 2 and Cloud 1

# Create UDP agent for communication from Cloud 2 to Cloud 1

set udp_cloud2 [new Agent/UDP]

set null_cloud1 [new Agent/Null]

# Attach UDP agent to Cloud 2 node and null agent to Cloud 1 node

$ns attach-agent $cloud2_node2 $udp_cloud2

$ns attach-agent $cloud1_node2 $null_cloud1

# Connect UDP agent to Null agent (Cloud 2 to Cloud 1)

$ns connect $udp_cloud2 $null_cloud1

# Configure CBR traffic for UDP data exchange

set cbr_cloud2 [new Application/Traffic/CBR]

$cbr_cloud2 attach-agent $udp_cloud2

$cbr_cloud2 set packetSize_ 512

$cbr_cloud2 set rate_ 100Kb

# Start and stop UDP communication between clouds

$ns at 2.0 “$cbr_cloud2 start”

$ns at 10.0 “$cbr_cloud2 stop”

  1. Simulating Cloud Interoperability with Different Protocols

Simulate Interoperability amongst nodes that use several protocols (for instance: Cloud 1 using IPv4 and Cloud 2 using IPv6) by imitating protocol transition or various network settings.

Example: Cloud 2 Using IPv6 (Simulating Protocol Differences)

# Configure Cloud 2 nodes to use IPv6 (simulating protocol differences)

$ns node-config -addressType IPv6

# Cloud 2 communication with IPv6 nodes

set tcp6_cloud2 [new Agent/TCP]

set tcp6Sink_cloud1 [new Agent/TCPSink]

$ns attach-agent $cloud2_node3 $tcp6_cloud2

$ns attach-agent $cloud1_node3 $tcp6Sink_cloud1

# Connect TCP agents between Cloud 1 and Cloud 2

$ns connect $tcp6_cloud2 $tcp6Sink_cloud1

This simulates a situation where two clouds are using numerous networking protocols (IPv4 vs. IPv6) and need to interoperate.

  1. Running the Simulation

Set the simulation terminates time and execute the simulation.

# Define the simulation end time

$ns at 15.0 “finish”

# Procedure to finish the simulation

proc finish {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

exit 0

}

# Run the simulation

$ns run

  1. Analyze the Results

Assess the performance of cloud interoperability by analyzing the trace files and network animation (NAM), once the simulation is done. You can validate:

  • Throughput: Compute the throughput amongst clouds during data exchange.
  • Latency: Estimate the communication delay amidst clouds.
  • Packet loss: Define if packets were lost during inter-cloud communication.
  • Interoperability: Verify if data was successfully exchanged amidst clouds with various configurations (like IPv4/IPv6 or different communication protocols).

As we saw in this process, it will help you to set up the simulation network, to fine-tune the simulator and to establish the Cloud Operability in the ns2 by Modeling Cloud Systems as Clusters of Nodes and establishing communication amongst them. If you need any extra information regarding their advanced mechanisms, we will deliver it to you.

We focus on improving your project, so please share your project details with us to achieve the best outcomes. Ns2project.com is here to be your top partner in helping you with your Interoperability Cloud setup using ns2tool. Our developers can provide you with great thesis ideas and topics that fit your needs. You can also get advice on cloud features related to your project from our researchers.